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 FF_API_LAVF_AVCTX
168 FF_DISABLE_DEPRECATION_WARNINGS
169 if (st->codec->codec)
170 return st->codec->codec;
171 FF_ENABLE_DEPRECATION_WARNINGS
174 switch (st->codecpar->codec_type) {
175 case AVMEDIA_TYPE_VIDEO:
176 if (s->video_codec) return s->video_codec;
178 case AVMEDIA_TYPE_AUDIO:
179 if (s->audio_codec) return s->audio_codec;
181 case AVMEDIA_TYPE_SUBTITLE:
182 if (s->subtitle_codec) return s->subtitle_codec;
186 return avcodec_find_decoder(codec_id);
189 int av_format_get_probe_score(const AVFormatContext *s)
191 return s->probe_score;
194 /* an arbitrarily chosen "sane" max packet size -- 50M */
195 #define SANE_CHUNK_SIZE (50000000)
197 int ffio_limit(AVIOContext *s, int size)
199 if (s->maxsize>= 0) {
200 int64_t remaining= s->maxsize - avio_tell(s);
201 if (remaining < size) {
202 int64_t newsize = avio_size(s);
203 if (!s->maxsize || s->maxsize<newsize)
204 s->maxsize = newsize - !newsize;
205 remaining= s->maxsize - avio_tell(s);
206 remaining= FFMAX(remaining, 0);
209 if (s->maxsize>= 0 && remaining+1 < size) {
210 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
217 /* Read the data in sane-sized chunks and append to pkt.
218 * Return the number of bytes read or an error. */
219 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
221 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
222 int orig_size = pkt->size;
226 int prev_size = pkt->size;
229 /* When the caller requests a lot of data, limit it to the amount
230 * left in file or SANE_CHUNK_SIZE when it is not known. */
232 if (read_size > SANE_CHUNK_SIZE/10) {
233 read_size = ffio_limit(s, read_size);
234 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
236 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
239 ret = av_grow_packet(pkt, read_size);
243 ret = avio_read(s, pkt->data + prev_size, read_size);
244 if (ret != read_size) {
245 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
252 pkt->flags |= AV_PKT_FLAG_CORRUPT;
256 av_packet_unref(pkt);
257 return pkt->size > orig_size ? pkt->size - orig_size : ret;
260 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
265 pkt->pos = avio_tell(s);
267 return append_packet_chunked(s, pkt, size);
270 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
273 return av_get_packet(s, pkt, size);
274 return append_packet_chunked(s, pkt, size);
277 int av_filename_number_test(const char *filename)
281 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
284 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
287 static const struct {
290 enum AVMediaType type;
292 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
293 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
294 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
295 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
296 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
297 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
298 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
299 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
300 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
301 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
302 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
303 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
304 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
308 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
310 if (fmt && st->request_probe <= score) {
312 av_log(s, AV_LOG_DEBUG,
313 "Probe with size=%d, packets=%d detected %s with score=%d\n",
314 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
316 for (i = 0; fmt_id_type[i].name; i++) {
317 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
318 st->codecpar->codec_id = fmt_id_type[i].id;
319 st->codecpar->codec_type = fmt_id_type[i].type;
320 st->internal->need_context_update = 1;
321 #if FF_API_LAVF_AVCTX
322 FF_DISABLE_DEPRECATION_WARNINGS
323 st->codec->codec_type = st->codecpar->codec_type;
324 st->codec->codec_id = st->codecpar->codec_id;
325 FF_ENABLE_DEPRECATION_WARNINGS
334 /************************************************************/
335 /* input media file */
337 int av_demuxer_open(AVFormatContext *ic) {
340 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
341 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
342 return AVERROR(EINVAL);
345 if (ic->iformat->read_header) {
346 err = ic->iformat->read_header(ic);
351 if (ic->pb && !ic->internal->data_offset)
352 ic->internal->data_offset = avio_tell(ic->pb);
357 /* Open input file and probe the format if necessary. */
358 static int init_input(AVFormatContext *s, const char *filename,
359 AVDictionary **options)
362 AVProbeData pd = { filename, NULL, 0 };
363 int score = AVPROBE_SCORE_RETRY;
366 s->flags |= AVFMT_FLAG_CUSTOM_IO;
368 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
369 s, 0, s->format_probesize);
370 else if (s->iformat->flags & AVFMT_NOFILE)
371 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
372 "will be ignored with AVFMT_NOFILE format.\n");
376 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
377 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
380 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
385 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
386 s, 0, s->format_probesize);
389 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
390 AVPacketList **plast_pktl, int ref)
392 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
396 return AVERROR(ENOMEM);
399 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
408 (*plast_pktl)->next = pktl;
410 *packet_buffer = pktl;
412 /* Add the packet in the buffered packet list. */
417 int avformat_queue_attached_pictures(AVFormatContext *s)
420 for (i = 0; i < s->nb_streams; i++)
421 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
422 s->streams[i]->discard < AVDISCARD_ALL) {
423 if (s->streams[i]->attached_pic.size <= 0) {
424 av_log(s, AV_LOG_WARNING,
425 "Attached picture on stream %d has invalid size, "
430 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
431 &s->streams[i]->attached_pic,
432 &s->internal->raw_packet_buffer_end, 1);
439 static int update_stream_avctx(AVFormatContext *s)
442 for (i = 0; i < s->nb_streams; i++) {
443 AVStream *st = s->streams[i];
445 if (!st->internal->need_context_update)
448 /* update internal codec context, for the parser */
449 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
453 #if FF_API_LAVF_AVCTX
454 FF_DISABLE_DEPRECATION_WARNINGS
455 /* update deprecated public codec context */
456 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
459 FF_ENABLE_DEPRECATION_WARNINGS
462 st->internal->need_context_update = 0;
468 int avformat_open_input(AVFormatContext **ps, const char *filename,
469 AVInputFormat *fmt, AVDictionary **options)
471 AVFormatContext *s = *ps;
473 AVDictionary *tmp = NULL;
474 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
476 if (!s && !(s = avformat_alloc_context()))
477 return AVERROR(ENOMEM);
479 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
480 return AVERROR(EINVAL);
486 av_dict_copy(&tmp, *options, 0);
488 if (s->pb) // must be before any goto fail
489 s->flags |= AVFMT_FLAG_CUSTOM_IO;
491 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
494 if ((ret = init_input(s, filename, &tmp)) < 0)
496 s->probe_score = ret;
498 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
499 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
500 if (!s->protocol_whitelist) {
501 ret = AVERROR(ENOMEM);
506 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
507 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
508 if (!s->protocol_blacklist) {
509 ret = AVERROR(ENOMEM);
514 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
515 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
516 ret = AVERROR(EINVAL);
520 avio_skip(s->pb, s->skip_initial_bytes);
522 /* Check filename in case an image number is expected. */
523 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
524 if (!av_filename_number_test(filename)) {
525 ret = AVERROR(EINVAL);
530 s->duration = s->start_time = AV_NOPTS_VALUE;
531 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
533 /* Allocate private data. */
534 if (s->iformat->priv_data_size > 0) {
535 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
536 ret = AVERROR(ENOMEM);
539 if (s->iformat->priv_class) {
540 *(const AVClass **) s->priv_data = s->iformat->priv_class;
541 av_opt_set_defaults(s->priv_data);
542 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
547 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
549 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
551 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
552 if ((ret = s->iformat->read_header(s)) < 0)
555 if (id3v2_extra_meta) {
556 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
557 !strcmp(s->iformat->name, "tta")) {
558 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
561 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
563 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
565 if ((ret = avformat_queue_attached_pictures(s)) < 0)
568 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
569 s->internal->data_offset = avio_tell(s->pb);
571 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
573 update_stream_avctx(s);
575 for (i = 0; i < s->nb_streams; i++)
576 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
579 av_dict_free(options);
586 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
588 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
590 avformat_free_context(s);
595 /*******************************************************/
597 static void force_codec_ids(AVFormatContext *s, AVStream *st)
599 switch (st->codecpar->codec_type) {
600 case AVMEDIA_TYPE_VIDEO:
601 if (s->video_codec_id)
602 st->codecpar->codec_id = s->video_codec_id;
604 case AVMEDIA_TYPE_AUDIO:
605 if (s->audio_codec_id)
606 st->codecpar->codec_id = s->audio_codec_id;
608 case AVMEDIA_TYPE_SUBTITLE:
609 if (s->subtitle_codec_id)
610 st->codecpar->codec_id = s->subtitle_codec_id;
615 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
617 if (st->request_probe>0) {
618 AVProbeData *pd = &st->probe_data;
620 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
624 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
626 av_log(s, AV_LOG_WARNING,
627 "Failed to reallocate probe buffer for stream %d\n",
632 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
633 pd->buf_size += pkt->size;
634 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
637 st->probe_packets = 0;
639 av_log(s, AV_LOG_WARNING,
640 "nothing to probe for stream %d\n", st->index);
644 end= s->internal->raw_packet_buffer_remaining_size <= 0
645 || st->probe_packets<= 0;
647 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
648 int score = set_codec_from_probe_data(s, st, pd);
649 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
653 st->request_probe = -1;
654 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
655 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
657 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
659 force_codec_ids(s, st);
665 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
667 int64_t ref = pkt->dts;
668 int i, pts_wrap_behavior;
669 int64_t pts_wrap_reference;
670 AVProgram *first_program;
672 if (ref == AV_NOPTS_VALUE)
674 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
676 ref &= (1LL << st->pts_wrap_bits)-1;
678 // reference time stamp should be 60 s before first time stamp
679 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
680 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
681 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
682 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
683 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
685 first_program = av_find_program_from_stream(s, NULL, stream_index);
687 if (!first_program) {
688 int default_stream_index = av_find_default_stream_index(s);
689 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
690 for (i = 0; i < s->nb_streams; i++) {
691 if (av_find_program_from_stream(s, NULL, i))
693 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
694 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
698 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
699 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
703 AVProgram *program = first_program;
705 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
706 pts_wrap_reference = program->pts_wrap_reference;
707 pts_wrap_behavior = program->pts_wrap_behavior;
710 program = av_find_program_from_stream(s, program, stream_index);
713 // update every program with differing pts_wrap_reference
714 program = first_program;
716 if (program->pts_wrap_reference != pts_wrap_reference) {
717 for (i = 0; i<program->nb_stream_indexes; i++) {
718 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
719 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
722 program->pts_wrap_reference = pts_wrap_reference;
723 program->pts_wrap_behavior = pts_wrap_behavior;
725 program = av_find_program_from_stream(s, program, stream_index);
731 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
737 AVPacketList *pktl = s->internal->raw_packet_buffer;
741 st = s->streams[pkt->stream_index];
742 if (s->internal->raw_packet_buffer_remaining_size <= 0)
743 if ((err = probe_codec(s, st, NULL)) < 0)
745 if (st->request_probe <= 0) {
746 s->internal->raw_packet_buffer = pktl->next;
747 s->internal->raw_packet_buffer_remaining_size += pkt->size;
756 ret = s->iformat->read_packet(s, pkt);
758 /* Some demuxers return FFERROR_REDO when they consume
759 data and discard it (ignored streams, junk, extradata).
760 We must re-call the demuxer to get the real packet. */
761 if (ret == FFERROR_REDO)
763 if (!pktl || ret == AVERROR(EAGAIN))
765 for (i = 0; i < s->nb_streams; i++) {
767 if (st->probe_packets)
768 if ((err = probe_codec(s, st, NULL)) < 0)
770 av_assert0(st->request_probe <= 0);
776 AVPacket tmp = { 0 };
777 ret = av_packet_ref(&tmp, pkt);
783 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
784 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
785 av_log(s, AV_LOG_WARNING,
786 "Dropped corrupted packet (stream = %d)\n",
788 av_packet_unref(pkt);
792 if (pkt->stream_index >= (unsigned)s->nb_streams) {
793 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
797 st = s->streams[pkt->stream_index];
799 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
800 // correct first time stamps to negative values
801 if (!is_relative(st->first_dts))
802 st->first_dts = wrap_timestamp(st, st->first_dts);
803 if (!is_relative(st->start_time))
804 st->start_time = wrap_timestamp(st, st->start_time);
805 if (!is_relative(st->cur_dts))
806 st->cur_dts = wrap_timestamp(st, st->cur_dts);
809 pkt->dts = wrap_timestamp(st, pkt->dts);
810 pkt->pts = wrap_timestamp(st, pkt->pts);
812 force_codec_ids(s, st);
814 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
815 if (s->use_wallclock_as_timestamps)
816 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
818 if (!pktl && st->request_probe <= 0)
821 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
822 &s->internal->raw_packet_buffer_end, 0);
825 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
827 if ((err = probe_codec(s, st, pkt)) < 0)
833 /**********************************************************/
835 static int determinable_frame_size(AVCodecContext *avctx)
837 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
838 avctx->codec_id == AV_CODEC_ID_MP1 ||
839 avctx->codec_id == AV_CODEC_ID_MP2 ||
840 avctx->codec_id == AV_CODEC_ID_MP3/* ||
841 avctx->codec_id == AV_CODEC_ID_CELT*/)
847 * Return the frame duration in seconds. Return 0 if not available.
849 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
850 AVCodecParserContext *pc, AVPacket *pkt)
852 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
853 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
854 int frame_size, sample_rate;
856 #if FF_API_LAVF_AVCTX
857 FF_DISABLE_DEPRECATION_WARNINGS
858 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
859 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
860 FF_ENABLE_DEPRECATION_WARNINGS
865 switch (st->codecpar->codec_type) {
866 case AVMEDIA_TYPE_VIDEO:
867 if (st->r_frame_rate.num && !pc && s->iformat) {
868 *pnum = st->r_frame_rate.den;
869 *pden = st->r_frame_rate.num;
870 } else if (st->time_base.num * 1000LL > st->time_base.den) {
871 *pnum = st->time_base.num;
872 *pden = st->time_base.den;
873 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
874 av_assert0(st->internal->avctx->ticks_per_frame);
875 av_reduce(pnum, pden,
877 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
880 if (pc && pc->repeat_pict) {
881 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
882 av_reduce(pnum, pden,
883 (*pnum) * (1LL + pc->repeat_pict),
887 /* If this codec can be interlaced or progressive then we need
888 * a parser to compute duration of a packet. Thus if we have
889 * no parser in such case leave duration undefined. */
890 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
894 case AVMEDIA_TYPE_AUDIO:
895 if (st->internal->avctx_inited) {
896 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
897 sample_rate = st->internal->avctx->sample_rate;
899 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
900 sample_rate = st->codecpar->sample_rate;
902 if (frame_size <= 0 || sample_rate <= 0)
912 static int is_intra_only(enum AVCodecID id)
914 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
917 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
922 static int has_decode_delay_been_guessed(AVStream *st)
924 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
925 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
927 #if CONFIG_H264_DECODER
928 if (st->internal->avctx->has_b_frames &&
929 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
932 if (st->internal->avctx->has_b_frames<3)
933 return st->nb_decoded_frames >= 7;
934 else if (st->internal->avctx->has_b_frames<4)
935 return st->nb_decoded_frames >= 18;
937 return st->nb_decoded_frames >= 20;
940 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
944 if (pktl == s->internal->packet_buffer_end)
945 return s->internal->parse_queue;
949 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
950 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
951 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
954 int delay = st->internal->avctx->has_b_frames;
957 if (dts == AV_NOPTS_VALUE) {
958 int64_t best_score = INT64_MAX;
959 for (i = 0; i<delay; i++) {
960 if (st->pts_reorder_error_count[i]) {
961 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
962 if (score < best_score) {
969 for (i = 0; i<delay; i++) {
970 if (pts_buffer[i] != AV_NOPTS_VALUE) {
971 int64_t diff = FFABS(pts_buffer[i] - dts)
972 + (uint64_t)st->pts_reorder_error[i];
973 diff = FFMAX(diff, st->pts_reorder_error[i]);
974 st->pts_reorder_error[i] = diff;
975 st->pts_reorder_error_count[i]++;
976 if (st->pts_reorder_error_count[i] > 250) {
977 st->pts_reorder_error[i] >>= 1;
978 st->pts_reorder_error_count[i] >>= 1;
985 if (dts == AV_NOPTS_VALUE)
992 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
993 * of the packets in a window.
995 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
996 AVPacketList *pkt_buffer)
998 AVStream *st = s->streams[stream_index];
999 int delay = st->internal->avctx->has_b_frames;
1002 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1004 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1005 pts_buffer[i] = AV_NOPTS_VALUE;
1007 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1008 if (pkt_buffer->pkt.stream_index != stream_index)
1011 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1012 pts_buffer[0] = pkt_buffer->pkt.pts;
1013 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1014 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1016 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1021 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1022 int64_t dts, int64_t pts, AVPacket *pkt)
1024 AVStream *st = s->streams[stream_index];
1025 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1026 AVPacketList *pktl_it;
1030 if (st->first_dts != AV_NOPTS_VALUE ||
1031 dts == AV_NOPTS_VALUE ||
1032 st->cur_dts == AV_NOPTS_VALUE ||
1036 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1038 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1040 if (is_relative(pts))
1043 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1044 if (pktl_it->pkt.stream_index != stream_index)
1046 if (is_relative(pktl_it->pkt.pts))
1047 pktl_it->pkt.pts += shift;
1049 if (is_relative(pktl_it->pkt.dts))
1050 pktl_it->pkt.dts += shift;
1052 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1053 st->start_time = pktl_it->pkt.pts;
1054 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1055 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1059 if (has_decode_delay_been_guessed(st)) {
1060 update_dts_from_pts(s, stream_index, pktl);
1063 if (st->start_time == AV_NOPTS_VALUE) {
1064 st->start_time = pts;
1065 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1066 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1070 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1071 int stream_index, int duration)
1073 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1074 int64_t cur_dts = RELATIVE_TS_BASE;
1076 if (st->first_dts != AV_NOPTS_VALUE) {
1077 if (st->update_initial_durations_done)
1079 st->update_initial_durations_done = 1;
1080 cur_dts = st->first_dts;
1081 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1082 if (pktl->pkt.stream_index == stream_index) {
1083 if (pktl->pkt.pts != pktl->pkt.dts ||
1084 pktl->pkt.dts != AV_NOPTS_VALUE ||
1087 cur_dts -= duration;
1090 if (pktl && pktl->pkt.dts != st->first_dts) {
1091 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1092 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1096 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1099 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1100 st->first_dts = cur_dts;
1101 } else if (st->cur_dts != RELATIVE_TS_BASE)
1104 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1105 if (pktl->pkt.stream_index != stream_index)
1107 if (pktl->pkt.pts == pktl->pkt.dts &&
1108 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1109 !pktl->pkt.duration) {
1110 pktl->pkt.dts = cur_dts;
1111 if (!st->internal->avctx->has_b_frames)
1112 pktl->pkt.pts = cur_dts;
1113 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1114 pktl->pkt.duration = duration;
1117 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1120 st->cur_dts = cur_dts;
1123 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1124 AVCodecParserContext *pc, AVPacket *pkt,
1125 int64_t next_dts, int64_t next_pts)
1127 int num, den, presentation_delayed, delay, i;
1129 AVRational duration;
1130 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1131 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1133 if (s->flags & AVFMT_FLAG_NOFILLIN)
1136 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1137 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1138 if (st->last_dts_for_order_check <= pkt->dts) {
1141 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1142 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1144 st->last_dts_for_order_check);
1145 st->dts_misordered++;
1147 if (st->dts_ordered + st->dts_misordered > 250) {
1148 st->dts_ordered >>= 1;
1149 st->dts_misordered >>= 1;
1153 st->last_dts_for_order_check = pkt->dts;
1154 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1155 pkt->dts = AV_NOPTS_VALUE;
1158 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1159 pkt->dts = AV_NOPTS_VALUE;
1161 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1162 && !st->internal->avctx->has_b_frames)
1163 //FIXME Set low_delay = 0 when has_b_frames = 1
1164 st->internal->avctx->has_b_frames = 1;
1166 /* do we have a video B-frame ? */
1167 delay = st->internal->avctx->has_b_frames;
1168 presentation_delayed = 0;
1170 /* XXX: need has_b_frame, but cannot get it if the codec is
1171 * not initialized */
1173 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1174 presentation_delayed = 1;
1176 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1177 st->pts_wrap_bits < 63 &&
1178 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1179 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1180 pkt->dts -= 1LL << st->pts_wrap_bits;
1182 pkt->pts += 1LL << st->pts_wrap_bits;
1185 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1186 * We take the conservative approach and discard both.
1187 * Note: If this is misbehaving for an H.264 file, then possibly
1188 * presentation_delayed is not set correctly. */
1189 if (delay == 1 && pkt->dts == pkt->pts &&
1190 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1191 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1192 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1193 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1194 pkt->dts = AV_NOPTS_VALUE;
1197 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1198 if (pkt->duration == 0) {
1199 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1201 duration = (AVRational) {num, den};
1202 pkt->duration = av_rescale_rnd(1,
1203 num * (int64_t) st->time_base.den,
1204 den * (int64_t) st->time_base.num,
1209 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1210 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1212 /* Correct timestamps with byte offset if demuxers only have timestamps
1213 * on packet boundaries */
1214 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1215 /* this will estimate bitrate based on this frame's duration and size */
1216 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1217 if (pkt->pts != AV_NOPTS_VALUE)
1219 if (pkt->dts != AV_NOPTS_VALUE)
1223 /* This may be redundant, but it should not hurt. */
1224 if (pkt->dts != AV_NOPTS_VALUE &&
1225 pkt->pts != AV_NOPTS_VALUE &&
1226 pkt->pts > pkt->dts)
1227 presentation_delayed = 1;
1229 if (s->debug & FF_FDEBUG_TS)
1230 av_log(s, AV_LOG_TRACE,
1231 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1232 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1233 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1235 /* Interpolate PTS and DTS if they are not present. We skip H264
1236 * currently because delay and has_b_frames are not reliably set. */
1237 if ((delay == 0 || (delay == 1 && pc)) &&
1239 if (presentation_delayed) {
1240 /* DTS = decompression timestamp */
1241 /* PTS = presentation timestamp */
1242 if (pkt->dts == AV_NOPTS_VALUE)
1243 pkt->dts = st->last_IP_pts;
1244 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1245 if (pkt->dts == AV_NOPTS_VALUE)
1246 pkt->dts = st->cur_dts;
1248 /* This is tricky: the dts must be incremented by the duration
1249 * of the frame we are displaying, i.e. the last I- or P-frame. */
1250 if (st->last_IP_duration == 0)
1251 st->last_IP_duration = pkt->duration;
1252 if (pkt->dts != AV_NOPTS_VALUE)
1253 st->cur_dts = pkt->dts + st->last_IP_duration;
1254 if (pkt->dts != AV_NOPTS_VALUE &&
1255 pkt->pts == AV_NOPTS_VALUE &&
1256 st->last_IP_duration > 0 &&
1257 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1258 next_dts != next_pts &&
1259 next_pts != AV_NOPTS_VALUE)
1260 pkt->pts = next_dts;
1262 st->last_IP_duration = pkt->duration;
1263 st->last_IP_pts = pkt->pts;
1264 /* Cannot compute PTS if not present (we can compute it only
1265 * by knowing the future. */
1266 } else if (pkt->pts != AV_NOPTS_VALUE ||
1267 pkt->dts != AV_NOPTS_VALUE ||
1270 /* presentation is not delayed : PTS and DTS are the same */
1271 if (pkt->pts == AV_NOPTS_VALUE)
1272 pkt->pts = pkt->dts;
1273 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1275 if (pkt->pts == AV_NOPTS_VALUE)
1276 pkt->pts = st->cur_dts;
1277 pkt->dts = pkt->pts;
1278 if (pkt->pts != AV_NOPTS_VALUE)
1279 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1283 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1284 st->pts_buffer[0] = pkt->pts;
1285 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1286 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1288 if(has_decode_delay_been_guessed(st))
1289 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1291 // We skipped it above so we try here.
1293 // This should happen on the first packet
1294 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1295 if (pkt->dts > st->cur_dts)
1296 st->cur_dts = pkt->dts;
1298 if (s->debug & FF_FDEBUG_TS)
1299 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1300 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1303 if (is_intra_only(st->codecpar->codec_id))
1304 pkt->flags |= AV_PKT_FLAG_KEY;
1305 #if FF_API_CONVERGENCE_DURATION
1306 FF_DISABLE_DEPRECATION_WARNINGS
1308 pkt->convergence_duration = pc->convergence_duration;
1309 FF_ENABLE_DEPRECATION_WARNINGS
1313 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1316 AVPacketList *pktl = *pkt_buf;
1317 *pkt_buf = pktl->next;
1318 av_packet_unref(&pktl->pkt);
1321 *pkt_buf_end = NULL;
1325 * Parse a packet, add all split parts to parse_queue.
1327 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1329 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1331 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1332 AVStream *st = s->streams[stream_index];
1333 uint8_t *data = pkt ? pkt->data : NULL;
1334 int size = pkt ? pkt->size : 0;
1335 int ret = 0, got_output = 0;
1338 av_init_packet(&flush_pkt);
1341 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1342 // preserve 0-size sync packets
1343 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1346 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1348 int64_t next_pts = pkt->pts;
1349 int64_t next_dts = pkt->dts;
1351 av_init_packet(&out_pkt);
1352 len = av_parser_parse2(st->parser, st->internal->avctx,
1353 &out_pkt.data, &out_pkt.size, data, size,
1354 pkt->pts, pkt->dts, pkt->pos);
1356 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1358 /* increment read pointer */
1362 got_output = !!out_pkt.size;
1367 if (pkt->side_data) {
1368 out_pkt.side_data = pkt->side_data;
1369 out_pkt.side_data_elems = pkt->side_data_elems;
1370 pkt->side_data = NULL;
1371 pkt->side_data_elems = 0;
1374 /* set the duration */
1375 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1376 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1377 if (st->internal->avctx->sample_rate > 0) {
1379 av_rescale_q_rnd(st->parser->duration,
1380 (AVRational) { 1, st->internal->avctx->sample_rate },
1386 out_pkt.stream_index = st->index;
1387 out_pkt.pts = st->parser->pts;
1388 out_pkt.dts = st->parser->dts;
1389 out_pkt.pos = st->parser->pos;
1391 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1392 out_pkt.pos = st->parser->frame_offset;
1394 if (st->parser->key_frame == 1 ||
1395 (st->parser->key_frame == -1 &&
1396 st->parser->pict_type == AV_PICTURE_TYPE_I))
1397 out_pkt.flags |= AV_PKT_FLAG_KEY;
1399 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1400 out_pkt.flags |= AV_PKT_FLAG_KEY;
1402 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1404 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1405 &s->internal->parse_queue_end, 1);
1406 av_packet_unref(&out_pkt);
1411 /* end of the stream => close and free the parser */
1412 if (pkt == &flush_pkt) {
1413 av_parser_close(st->parser);
1418 av_packet_unref(pkt);
1422 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1423 AVPacketList **pkt_buffer_end,
1427 av_assert0(*pkt_buffer);
1430 *pkt_buffer = pktl->next;
1432 *pkt_buffer_end = NULL;
1437 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1439 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1442 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1444 int ret = 0, i, got_packet = 0;
1445 AVDictionary *metadata = NULL;
1447 av_init_packet(pkt);
1449 while (!got_packet && !s->internal->parse_queue) {
1453 /* read next packet */
1454 ret = ff_read_packet(s, &cur_pkt);
1456 if (ret == AVERROR(EAGAIN))
1458 /* flush the parsers */
1459 for (i = 0; i < s->nb_streams; i++) {
1461 if (st->parser && st->need_parsing)
1462 parse_packet(s, NULL, st->index);
1464 /* all remaining packets are now in parse_queue =>
1465 * really terminate parsing */
1469 st = s->streams[cur_pkt.stream_index];
1471 /* update context if required */
1472 if (st->internal->need_context_update) {
1473 if (avcodec_is_open(st->internal->avctx)) {
1474 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1475 avcodec_close(st->internal->avctx);
1476 st->info->found_decoder = 0;
1479 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1483 st->internal->need_context_update = 0;
1486 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1487 cur_pkt.dts != AV_NOPTS_VALUE &&
1488 cur_pkt.pts < cur_pkt.dts) {
1489 av_log(s, AV_LOG_WARNING,
1490 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1491 cur_pkt.stream_index,
1492 av_ts2str(cur_pkt.pts),
1493 av_ts2str(cur_pkt.dts),
1496 if (s->debug & FF_FDEBUG_TS)
1497 av_log(s, AV_LOG_DEBUG,
1498 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1499 cur_pkt.stream_index,
1500 av_ts2str(cur_pkt.pts),
1501 av_ts2str(cur_pkt.dts),
1502 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1504 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1505 st->parser = av_parser_init(st->codecpar->codec_id);
1507 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1508 "%s, packets or times may be invalid.\n",
1509 avcodec_get_name(st->codecpar->codec_id));
1510 /* no parser available: just output the raw packets */
1511 st->need_parsing = AVSTREAM_PARSE_NONE;
1512 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1513 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1514 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1515 st->parser->flags |= PARSER_FLAG_ONCE;
1516 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1517 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1520 if (!st->need_parsing || !st->parser) {
1521 /* no parsing needed: we just output the packet as is */
1523 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1524 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1525 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1526 ff_reduce_index(s, st->index);
1527 av_add_index_entry(st, pkt->pos, pkt->dts,
1528 0, 0, AVINDEX_KEYFRAME);
1531 } else if (st->discard < AVDISCARD_ALL) {
1532 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1534 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1535 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1536 st->codecpar->channels = st->internal->avctx->channels;
1537 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1538 st->codecpar->codec_id = st->internal->avctx->codec_id;
1541 av_packet_unref(&cur_pkt);
1543 if (pkt->flags & AV_PKT_FLAG_KEY)
1544 st->skip_to_keyframe = 0;
1545 if (st->skip_to_keyframe) {
1546 av_packet_unref(&cur_pkt);
1554 if (!got_packet && s->internal->parse_queue)
1555 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1558 AVStream *st = s->streams[pkt->stream_index];
1559 int discard_padding = 0;
1560 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1561 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1562 int64_t sample = ts_to_samples(st, pts);
1563 int duration = ts_to_samples(st, pkt->duration);
1564 int64_t end_sample = sample + duration;
1565 if (duration > 0 && end_sample >= st->first_discard_sample &&
1566 sample < st->last_discard_sample)
1567 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1569 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1570 st->skip_samples = st->start_skip_samples;
1571 if (st->skip_samples || discard_padding) {
1572 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1574 AV_WL32(p, st->skip_samples);
1575 AV_WL32(p + 4, discard_padding);
1576 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1578 st->skip_samples = 0;
1581 if (st->inject_global_side_data) {
1582 for (i = 0; i < st->nb_side_data; i++) {
1583 AVPacketSideData *src_sd = &st->side_data[i];
1586 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1589 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1591 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1595 memcpy(dst_data, src_sd->data, src_sd->size);
1597 st->inject_global_side_data = 0;
1600 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1601 av_packet_merge_side_data(pkt);
1604 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1606 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1607 av_dict_copy(&s->metadata, metadata, 0);
1608 av_dict_free(&metadata);
1609 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1612 #if FF_API_LAVF_AVCTX
1613 update_stream_avctx(s);
1616 if (s->debug & FF_FDEBUG_TS)
1617 av_log(s, AV_LOG_DEBUG,
1618 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1619 "size=%d, duration=%"PRId64", flags=%d\n",
1621 av_ts2str(pkt->pts),
1622 av_ts2str(pkt->dts),
1623 pkt->size, pkt->duration, pkt->flags);
1628 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1630 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1636 ret = s->internal->packet_buffer
1637 ? read_from_packet_buffer(&s->internal->packet_buffer,
1638 &s->internal->packet_buffer_end, pkt)
1639 : read_frame_internal(s, pkt);
1646 AVPacketList *pktl = s->internal->packet_buffer;
1649 AVPacket *next_pkt = &pktl->pkt;
1651 if (next_pkt->dts != AV_NOPTS_VALUE) {
1652 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1653 // last dts seen for this stream. if any of packets following
1654 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1655 int64_t last_dts = next_pkt->dts;
1656 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1657 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1658 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1659 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1661 next_pkt->pts = pktl->pkt.dts;
1663 if (last_dts != AV_NOPTS_VALUE) {
1664 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1665 last_dts = pktl->pkt.dts;
1670 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1671 // Fixing the last reference frame had none pts issue (For MXF etc).
1672 // We only do this when
1674 // 2. we are not able to resolve a pts value for current packet.
1675 // 3. the packets for this stream at the end of the files had valid dts.
1676 next_pkt->pts = last_dts + next_pkt->duration;
1678 pktl = s->internal->packet_buffer;
1681 /* read packet from packet buffer, if there is data */
1682 st = s->streams[next_pkt->stream_index];
1683 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1684 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1685 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1686 &s->internal->packet_buffer_end, pkt);
1691 ret = read_frame_internal(s, pkt);
1693 if (pktl && ret != AVERROR(EAGAIN)) {
1700 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1701 &s->internal->packet_buffer_end, 1);
1702 av_packet_unref(pkt);
1709 st = s->streams[pkt->stream_index];
1710 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1711 ff_reduce_index(s, st->index);
1712 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1715 if (is_relative(pkt->dts))
1716 pkt->dts -= RELATIVE_TS_BASE;
1717 if (is_relative(pkt->pts))
1718 pkt->pts -= RELATIVE_TS_BASE;
1723 /* XXX: suppress the packet queue */
1724 static void flush_packet_queue(AVFormatContext *s)
1728 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1729 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1730 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1732 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1735 /*******************************************************/
1738 int av_find_default_stream_index(AVFormatContext *s)
1742 int best_stream = 0;
1743 int best_score = INT_MIN;
1745 if (s->nb_streams <= 0)
1747 for (i = 0; i < s->nb_streams; i++) {
1750 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1751 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1753 if (st->codecpar->width && st->codecpar->height)
1757 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1758 if (st->codecpar->sample_rate)
1761 if (st->codec_info_nb_frames)
1764 if (st->discard != AVDISCARD_ALL)
1767 if (score > best_score) {
1775 /** Flush the frame reader. */
1776 void ff_read_frame_flush(AVFormatContext *s)
1781 flush_packet_queue(s);
1783 /* Reset read state for each stream. */
1784 for (i = 0; i < s->nb_streams; i++) {
1788 av_parser_close(st->parser);
1791 st->last_IP_pts = AV_NOPTS_VALUE;
1792 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1793 if (st->first_dts == AV_NOPTS_VALUE)
1794 st->cur_dts = RELATIVE_TS_BASE;
1796 /* We set the current DTS to an unspecified origin. */
1797 st->cur_dts = AV_NOPTS_VALUE;
1799 st->probe_packets = MAX_PROBE_PACKETS;
1801 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1802 st->pts_buffer[j] = AV_NOPTS_VALUE;
1804 if (s->internal->inject_global_side_data)
1805 st->inject_global_side_data = 1;
1807 st->skip_samples = 0;
1811 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1815 for (i = 0; i < s->nb_streams; i++) {
1816 AVStream *st = s->streams[i];
1819 av_rescale(timestamp,
1820 st->time_base.den * (int64_t) ref_st->time_base.num,
1821 st->time_base.num * (int64_t) ref_st->time_base.den);
1825 void ff_reduce_index(AVFormatContext *s, int stream_index)
1827 AVStream *st = s->streams[stream_index];
1828 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1830 if ((unsigned) st->nb_index_entries >= max_entries) {
1832 for (i = 0; 2 * i < st->nb_index_entries; i++)
1833 st->index_entries[i] = st->index_entries[2 * i];
1834 st->nb_index_entries = i;
1838 int ff_add_index_entry(AVIndexEntry **index_entries,
1839 int *nb_index_entries,
1840 unsigned int *index_entries_allocated_size,
1841 int64_t pos, int64_t timestamp,
1842 int size, int distance, int flags)
1844 AVIndexEntry *entries, *ie;
1847 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1850 if (timestamp == AV_NOPTS_VALUE)
1851 return AVERROR(EINVAL);
1853 if (size < 0 || size > 0x3FFFFFFF)
1854 return AVERROR(EINVAL);
1856 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1857 timestamp -= RELATIVE_TS_BASE;
1859 entries = av_fast_realloc(*index_entries,
1860 index_entries_allocated_size,
1861 (*nb_index_entries + 1) *
1862 sizeof(AVIndexEntry));
1866 *index_entries = entries;
1868 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1869 timestamp, AVSEEK_FLAG_ANY);
1872 index = (*nb_index_entries)++;
1873 ie = &entries[index];
1874 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1876 ie = &entries[index];
1877 if (ie->timestamp != timestamp) {
1878 if (ie->timestamp <= timestamp)
1880 memmove(entries + index + 1, entries + index,
1881 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1882 (*nb_index_entries)++;
1883 } else if (ie->pos == pos && distance < ie->min_distance)
1884 // do not reduce the distance
1885 distance = ie->min_distance;
1889 ie->timestamp = timestamp;
1890 ie->min_distance = distance;
1897 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1898 int size, int distance, int flags)
1900 timestamp = wrap_timestamp(st, timestamp);
1901 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1902 &st->index_entries_allocated_size, pos,
1903 timestamp, size, distance, flags);
1906 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1907 int64_t wanted_timestamp, int flags)
1915 // Optimize appending index entries at the end.
1916 if (b && entries[b - 1].timestamp < wanted_timestamp)
1921 timestamp = entries[m].timestamp;
1922 if (timestamp >= wanted_timestamp)
1924 if (timestamp <= wanted_timestamp)
1927 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1929 if (!(flags & AVSEEK_FLAG_ANY))
1930 while (m >= 0 && m < nb_entries &&
1931 !(entries[m].flags & AVINDEX_KEYFRAME))
1932 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1934 if (m == nb_entries)
1939 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1942 int64_t pos_delta = 0;
1944 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1945 const char *proto = avio_find_protocol_name(s->filename);
1948 av_log(s, AV_LOG_INFO,
1949 "Protocol name not provided, cannot determine if input is local or "
1950 "a network protocol, buffers and access patterns cannot be configured "
1951 "optimally without knowing the protocol\n");
1954 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1957 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1958 AVStream *st1 = s->streams[ist1];
1959 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1960 AVStream *st2 = s->streams[ist2];
1966 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1967 AVIndexEntry *e1 = &st1->index_entries[i1];
1968 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1970 skip = FFMAX(skip, e1->size);
1971 for (; i2 < st2->nb_index_entries; i2++) {
1972 AVIndexEntry *e2 = &st2->index_entries[i2];
1973 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1974 if (e2_pts - e1_pts < time_tolerance)
1976 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1984 /* XXX This could be adjusted depending on protocol*/
1985 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1986 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1987 ffio_set_buf_size(s->pb, pos_delta);
1988 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1991 if (skip < (1<<23)) {
1992 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1996 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1998 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1999 wanted_timestamp, flags);
2002 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2003 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2005 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2006 if (stream_index >= 0)
2007 ts = wrap_timestamp(s->streams[stream_index], ts);
2011 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2012 int64_t target_ts, int flags)
2014 AVInputFormat *avif = s->iformat;
2015 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2016 int64_t ts_min, ts_max, ts;
2021 if (stream_index < 0)
2024 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2027 ts_min = AV_NOPTS_VALUE;
2028 pos_limit = -1; // GCC falsely says it may be uninitialized.
2030 st = s->streams[stream_index];
2031 if (st->index_entries) {
2034 /* FIXME: Whole function must be checked for non-keyframe entries in
2035 * index case, especially read_timestamp(). */
2036 index = av_index_search_timestamp(st, target_ts,
2037 flags | AVSEEK_FLAG_BACKWARD);
2038 index = FFMAX(index, 0);
2039 e = &st->index_entries[index];
2041 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2043 ts_min = e->timestamp;
2044 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2045 pos_min, av_ts2str(ts_min));
2047 av_assert1(index == 0);
2050 index = av_index_search_timestamp(st, target_ts,
2051 flags & ~AVSEEK_FLAG_BACKWARD);
2052 av_assert0(index < st->nb_index_entries);
2054 e = &st->index_entries[index];
2055 av_assert1(e->timestamp >= target_ts);
2057 ts_max = e->timestamp;
2058 pos_limit = pos_max - e->min_distance;
2059 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2060 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2064 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2065 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2070 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2073 ff_read_frame_flush(s);
2074 ff_update_cur_dts(s, st, ts);
2079 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2080 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2082 int64_t step = 1024;
2083 int64_t limit, ts_max;
2084 int64_t filesize = avio_size(s->pb);
2085 int64_t pos_max = filesize - 1;
2088 pos_max = FFMAX(0, (pos_max) - step);
2089 ts_max = ff_read_timestamp(s, stream_index,
2090 &pos_max, limit, read_timestamp);
2092 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2093 if (ts_max == AV_NOPTS_VALUE)
2097 int64_t tmp_pos = pos_max + 1;
2098 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2099 &tmp_pos, INT64_MAX, read_timestamp);
2100 if (tmp_ts == AV_NOPTS_VALUE)
2102 av_assert0(tmp_pos > pos_max);
2105 if (tmp_pos >= filesize)
2117 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2118 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2119 int64_t ts_min, int64_t ts_max,
2120 int flags, int64_t *ts_ret,
2121 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2122 int64_t *, int64_t))
2129 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2131 if (ts_min == AV_NOPTS_VALUE) {
2132 pos_min = s->internal->data_offset;
2133 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2134 if (ts_min == AV_NOPTS_VALUE)
2138 if (ts_min >= target_ts) {
2143 if (ts_max == AV_NOPTS_VALUE) {
2144 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2146 pos_limit = pos_max;
2149 if (ts_max <= target_ts) {
2154 av_assert0(ts_min < ts_max);
2157 while (pos_min < pos_limit) {
2158 av_log(s, AV_LOG_TRACE,
2159 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2160 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2161 av_assert0(pos_limit <= pos_max);
2163 if (no_change == 0) {
2164 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2165 // interpolate position (better than dichotomy)
2166 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2168 pos_min - approximate_keyframe_distance;
2169 } else if (no_change == 1) {
2170 // bisection if interpolation did not change min / max pos last time
2171 pos = (pos_min + pos_limit) >> 1;
2173 /* linear search if bisection failed, can only happen if there
2174 * are very few or no keyframes between min/max */
2179 else if (pos > pos_limit)
2183 // May pass pos_limit instead of -1.
2184 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2189 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2190 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2191 pos_min, pos, pos_max,
2192 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2193 pos_limit, start_pos, no_change);
2194 if (ts == AV_NOPTS_VALUE) {
2195 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2198 if (target_ts <= ts) {
2199 pos_limit = start_pos - 1;
2203 if (target_ts >= ts) {
2209 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2210 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2213 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2215 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2216 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2217 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2223 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2224 int64_t pos, int flags)
2226 int64_t pos_min, pos_max;
2228 pos_min = s->internal->data_offset;
2229 pos_max = avio_size(s->pb) - 1;
2233 else if (pos > pos_max)
2236 avio_seek(s->pb, pos, SEEK_SET);
2238 s->io_repositioned = 1;
2243 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2244 int64_t timestamp, int flags)
2251 st = s->streams[stream_index];
2253 index = av_index_search_timestamp(st, timestamp, flags);
2255 if (index < 0 && st->nb_index_entries &&
2256 timestamp < st->index_entries[0].timestamp)
2259 if (index < 0 || index == st->nb_index_entries - 1) {
2263 if (st->nb_index_entries) {
2264 av_assert0(st->index_entries);
2265 ie = &st->index_entries[st->nb_index_entries - 1];
2266 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2268 ff_update_cur_dts(s, st, ie->timestamp);
2270 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2276 read_status = av_read_frame(s, &pkt);
2277 } while (read_status == AVERROR(EAGAIN));
2278 if (read_status < 0)
2280 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2281 if (pkt.flags & AV_PKT_FLAG_KEY) {
2282 av_packet_unref(&pkt);
2285 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2286 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);
2287 av_packet_unref(&pkt);
2291 av_packet_unref(&pkt);
2293 index = av_index_search_timestamp(st, timestamp, flags);
2298 ff_read_frame_flush(s);
2299 if (s->iformat->read_seek)
2300 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2302 ie = &st->index_entries[index];
2303 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2305 ff_update_cur_dts(s, st, ie->timestamp);
2310 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2311 int64_t timestamp, int flags)
2316 if (flags & AVSEEK_FLAG_BYTE) {
2317 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2319 ff_read_frame_flush(s);
2320 return seek_frame_byte(s, stream_index, timestamp, flags);
2323 if (stream_index < 0) {
2324 stream_index = av_find_default_stream_index(s);
2325 if (stream_index < 0)
2328 st = s->streams[stream_index];
2329 /* timestamp for default must be expressed in AV_TIME_BASE units */
2330 timestamp = av_rescale(timestamp, st->time_base.den,
2331 AV_TIME_BASE * (int64_t) st->time_base.num);
2334 /* first, we try the format specific seek */
2335 if (s->iformat->read_seek) {
2336 ff_read_frame_flush(s);
2337 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2343 if (s->iformat->read_timestamp &&
2344 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2345 ff_read_frame_flush(s);
2346 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2347 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2348 ff_read_frame_flush(s);
2349 return seek_frame_generic(s, stream_index, timestamp, flags);
2354 int av_seek_frame(AVFormatContext *s, int stream_index,
2355 int64_t timestamp, int flags)
2359 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2360 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2361 if ((flags & AVSEEK_FLAG_BACKWARD))
2365 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2366 flags & ~AVSEEK_FLAG_BACKWARD);
2369 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2372 ret = avformat_queue_attached_pictures(s);
2377 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2378 int64_t ts, int64_t max_ts, int flags)
2380 if (min_ts > ts || max_ts < ts)
2382 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2383 return AVERROR(EINVAL);
2386 flags |= AVSEEK_FLAG_ANY;
2387 flags &= ~AVSEEK_FLAG_BACKWARD;
2389 if (s->iformat->read_seek2) {
2391 ff_read_frame_flush(s);
2393 if (stream_index == -1 && s->nb_streams == 1) {
2394 AVRational time_base = s->streams[0]->time_base;
2395 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2396 min_ts = av_rescale_rnd(min_ts, time_base.den,
2397 time_base.num * (int64_t)AV_TIME_BASE,
2398 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2399 max_ts = av_rescale_rnd(max_ts, time_base.den,
2400 time_base.num * (int64_t)AV_TIME_BASE,
2401 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2404 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2408 ret = avformat_queue_attached_pictures(s);
2412 if (s->iformat->read_timestamp) {
2413 // try to seek via read_timestamp()
2416 // Fall back on old API if new is not implemented but old is.
2417 // Note the old API has somewhat different semantics.
2418 if (s->iformat->read_seek || 1) {
2419 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2420 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2421 if (ret<0 && ts != min_ts && max_ts != ts) {
2422 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2424 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2429 // try some generic seek like seek_frame_generic() but with new ts semantics
2430 return -1; //unreachable
2433 int avformat_flush(AVFormatContext *s)
2435 ff_read_frame_flush(s);
2439 /*******************************************************/
2442 * Return TRUE if the stream has accurate duration in any stream.
2444 * @return TRUE if the stream has accurate duration for at least one component.
2446 static int has_duration(AVFormatContext *ic)
2451 for (i = 0; i < ic->nb_streams; i++) {
2452 st = ic->streams[i];
2453 if (st->duration != AV_NOPTS_VALUE)
2456 if (ic->duration != AV_NOPTS_VALUE)
2462 * Estimate the stream timings from the one of each components.
2464 * Also computes the global bitrate if possible.
2466 static void update_stream_timings(AVFormatContext *ic)
2468 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2469 int64_t duration, duration1, filesize;
2474 start_time = INT64_MAX;
2475 start_time_text = INT64_MAX;
2476 end_time = INT64_MIN;
2477 duration = INT64_MIN;
2478 for (i = 0; i < ic->nb_streams; i++) {
2479 st = ic->streams[i];
2480 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2481 start_time1 = av_rescale_q(st->start_time, st->time_base,
2483 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2484 if (start_time1 < start_time_text)
2485 start_time_text = start_time1;
2487 start_time = FFMIN(start_time, start_time1);
2488 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2490 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2491 if (end_time1 != AV_NOPTS_VALUE) {
2492 end_time1 += start_time1;
2493 end_time = FFMAX(end_time, end_time1);
2495 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2496 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2497 p->start_time = start_time1;
2498 if (p->end_time < end_time1)
2499 p->end_time = end_time1;
2502 if (st->duration != AV_NOPTS_VALUE) {
2503 duration1 = av_rescale_q(st->duration, st->time_base,
2505 duration = FFMAX(duration, duration1);
2508 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2509 start_time = start_time_text;
2510 else if (start_time > start_time_text)
2511 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2513 if (start_time != INT64_MAX) {
2514 ic->start_time = start_time;
2515 if (end_time != INT64_MIN) {
2516 if (ic->nb_programs) {
2517 for (i = 0; i < ic->nb_programs; i++) {
2518 p = ic->programs[i];
2519 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2520 duration = FFMAX(duration, p->end_time - p->start_time);
2523 duration = FFMAX(duration, end_time - start_time);
2526 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2527 ic->duration = duration;
2529 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2530 /* compute the bitrate */
2531 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2532 (double) ic->duration;
2533 if (bitrate >= 0 && bitrate <= INT64_MAX)
2534 ic->bit_rate = bitrate;
2538 static void fill_all_stream_timings(AVFormatContext *ic)
2543 update_stream_timings(ic);
2544 for (i = 0; i < ic->nb_streams; i++) {
2545 st = ic->streams[i];
2546 if (st->start_time == AV_NOPTS_VALUE) {
2547 if (ic->start_time != AV_NOPTS_VALUE)
2548 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2550 if (ic->duration != AV_NOPTS_VALUE)
2551 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2557 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2559 int64_t filesize, duration;
2560 int i, show_warning = 0;
2563 /* if bit_rate is already set, we believe it */
2564 if (ic->bit_rate <= 0) {
2566 for (i = 0; i < ic->nb_streams; i++) {
2567 st = ic->streams[i];
2568 if (st->codecpar->bit_rate > 0) {
2569 if (INT_MAX - st->codecpar->bit_rate < bit_rate) {
2573 bit_rate += st->codecpar->bit_rate;
2574 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2575 // If we have a videostream with packets but without a bitrate
2576 // then consider the sum not known
2581 ic->bit_rate = bit_rate;
2584 /* if duration is already set, we believe it */
2585 if (ic->duration == AV_NOPTS_VALUE &&
2586 ic->bit_rate != 0) {
2587 filesize = ic->pb ? avio_size(ic->pb) : 0;
2588 if (filesize > ic->internal->data_offset) {
2589 filesize -= ic->internal->data_offset;
2590 for (i = 0; i < ic->nb_streams; i++) {
2591 st = ic->streams[i];
2592 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2593 && st->duration == AV_NOPTS_VALUE) {
2594 duration = av_rescale(8 * filesize, st->time_base.den,
2596 (int64_t) st->time_base.num);
2597 st->duration = duration;
2604 av_log(ic, AV_LOG_WARNING,
2605 "Estimating duration from bitrate, this may be inaccurate\n");
2608 #define DURATION_MAX_READ_SIZE 250000LL
2609 #define DURATION_MAX_RETRY 6
2611 /* only usable for MPEG-PS streams */
2612 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2614 AVPacket pkt1, *pkt = &pkt1;
2616 int num, den, read_size, i, ret;
2617 int found_duration = 0;
2619 int64_t filesize, offset, duration;
2622 /* flush packet queue */
2623 flush_packet_queue(ic);
2625 for (i = 0; i < ic->nb_streams; i++) {
2626 st = ic->streams[i];
2627 if (st->start_time == AV_NOPTS_VALUE &&
2628 st->first_dts == AV_NOPTS_VALUE &&
2629 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2630 av_log(ic, AV_LOG_WARNING,
2631 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2634 av_parser_close(st->parser);
2639 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2640 /* estimate the end time (duration) */
2641 /* XXX: may need to support wrapping */
2642 filesize = ic->pb ? avio_size(ic->pb) : 0;
2644 is_end = found_duration;
2645 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2649 avio_seek(ic->pb, offset, SEEK_SET);
2652 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2656 ret = ff_read_packet(ic, pkt);
2657 } while (ret == AVERROR(EAGAIN));
2660 read_size += pkt->size;
2661 st = ic->streams[pkt->stream_index];
2662 if (pkt->pts != AV_NOPTS_VALUE &&
2663 (st->start_time != AV_NOPTS_VALUE ||
2664 st->first_dts != AV_NOPTS_VALUE)) {
2665 if (pkt->duration == 0) {
2666 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2668 pkt->duration = av_rescale_rnd(1,
2669 num * (int64_t) st->time_base.den,
2670 den * (int64_t) st->time_base.num,
2674 duration = pkt->pts + pkt->duration;
2676 if (st->start_time != AV_NOPTS_VALUE)
2677 duration -= st->start_time;
2679 duration -= st->first_dts;
2681 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2682 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2683 st->duration = duration;
2684 st->info->last_duration = duration;
2687 av_packet_unref(pkt);
2690 /* check if all audio/video streams have valid duration */
2693 for (i = 0; i < ic->nb_streams; i++) {
2694 st = ic->streams[i];
2695 switch (st->codecpar->codec_type) {
2696 case AVMEDIA_TYPE_VIDEO:
2697 case AVMEDIA_TYPE_AUDIO:
2698 if (st->duration == AV_NOPTS_VALUE)
2705 ++retry <= DURATION_MAX_RETRY);
2707 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2709 /* warn about audio/video streams which duration could not be estimated */
2710 for (i = 0; i < ic->nb_streams; i++) {
2711 st = ic->streams[i];
2712 if (st->duration == AV_NOPTS_VALUE) {
2713 switch (st->codecpar->codec_type) {
2714 case AVMEDIA_TYPE_VIDEO:
2715 case AVMEDIA_TYPE_AUDIO:
2716 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2717 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2719 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2723 fill_all_stream_timings(ic);
2725 avio_seek(ic->pb, old_offset, SEEK_SET);
2726 for (i = 0; i < ic->nb_streams; i++) {
2729 st = ic->streams[i];
2730 st->cur_dts = st->first_dts;
2731 st->last_IP_pts = AV_NOPTS_VALUE;
2732 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2733 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2734 st->pts_buffer[j] = AV_NOPTS_VALUE;
2738 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2742 /* get the file size, if possible */
2743 if (ic->iformat->flags & AVFMT_NOFILE) {
2746 file_size = avio_size(ic->pb);
2747 file_size = FFMAX(0, file_size);
2750 if ((!strcmp(ic->iformat->name, "mpeg") ||
2751 !strcmp(ic->iformat->name, "mpegts")) &&
2752 file_size && ic->pb->seekable) {
2753 /* get accurate estimate from the PTSes */
2754 estimate_timings_from_pts(ic, old_offset);
2755 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2756 } else if (has_duration(ic)) {
2757 /* at least one component has timings - we use them for all
2759 fill_all_stream_timings(ic);
2760 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2762 /* less precise: use bitrate info */
2763 estimate_timings_from_bit_rate(ic);
2764 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2766 update_stream_timings(ic);
2770 AVStream av_unused *st;
2771 for (i = 0; i < ic->nb_streams; i++) {
2772 st = ic->streams[i];
2773 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2774 (double) st->start_time / AV_TIME_BASE,
2775 (double) st->duration / AV_TIME_BASE);
2777 av_log(ic, AV_LOG_TRACE,
2778 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2779 (double) ic->start_time / AV_TIME_BASE,
2780 (double) ic->duration / AV_TIME_BASE,
2781 (int64_t)ic->bit_rate / 1000);
2785 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2787 AVCodecContext *avctx = st->internal->avctx;
2789 #define FAIL(errmsg) do { \
2791 *errmsg_ptr = errmsg; \
2795 if ( avctx->codec_id == AV_CODEC_ID_NONE
2796 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2797 FAIL("unknown codec");
2798 switch (avctx->codec_type) {
2799 case AVMEDIA_TYPE_AUDIO:
2800 if (!avctx->frame_size && determinable_frame_size(avctx))
2801 FAIL("unspecified frame size");
2802 if (st->info->found_decoder >= 0 &&
2803 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2804 FAIL("unspecified sample format");
2805 if (!avctx->sample_rate)
2806 FAIL("unspecified sample rate");
2807 if (!avctx->channels)
2808 FAIL("unspecified number of channels");
2809 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2810 FAIL("no decodable DTS frames");
2812 case AVMEDIA_TYPE_VIDEO:
2814 FAIL("unspecified size");
2815 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2816 FAIL("unspecified pixel format");
2817 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2818 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2819 FAIL("no frame in rv30/40 and no sar");
2821 case AVMEDIA_TYPE_SUBTITLE:
2822 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2823 FAIL("unspecified size");
2825 case AVMEDIA_TYPE_DATA:
2826 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2832 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2833 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2834 AVDictionary **options)
2836 AVCodecContext *avctx = st->internal->avctx;
2837 const AVCodec *codec;
2838 int got_picture = 1, ret = 0;
2839 AVFrame *frame = av_frame_alloc();
2840 AVSubtitle subtitle;
2841 AVPacket pkt = *avpkt;
2842 int do_skip_frame = 0;
2843 enum AVDiscard skip_frame;
2846 return AVERROR(ENOMEM);
2848 if (!avcodec_is_open(avctx) &&
2849 st->info->found_decoder <= 0 &&
2850 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2851 AVDictionary *thread_opt = NULL;
2853 codec = find_decoder(s, st, st->codecpar->codec_id);
2856 st->info->found_decoder = -st->codecpar->codec_id;
2861 /* Force thread count to 1 since the H.264 decoder will not extract
2862 * SPS and PPS to extradata during multi-threaded decoding. */
2863 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2864 if (s->codec_whitelist)
2865 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2866 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2868 av_dict_free(&thread_opt);
2870 st->info->found_decoder = -avctx->codec_id;
2873 st->info->found_decoder = 1;
2874 } else if (!st->info->found_decoder)
2875 st->info->found_decoder = 1;
2877 if (st->info->found_decoder < 0) {
2882 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2884 skip_frame = avctx->skip_frame;
2885 avctx->skip_frame = AVDISCARD_ALL;
2888 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2890 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2891 (!st->codec_info_nb_frames &&
2892 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2894 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2895 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2896 ret = avcodec_send_packet(avctx, &pkt);
2897 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2901 ret = avcodec_receive_frame(avctx, frame);
2904 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2906 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2907 ret = avcodec_decode_subtitle2(avctx, &subtitle,
2908 &got_picture, &pkt);
2914 st->nb_decoded_frames++;
2919 if (!pkt.data && !got_picture)
2923 if (do_skip_frame) {
2924 avctx->skip_frame = skip_frame;
2927 av_frame_free(&frame);
2931 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2933 while (tags->id != AV_CODEC_ID_NONE) {
2941 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2944 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2945 if (tag == tags[i].tag)
2947 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2948 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2950 return AV_CODEC_ID_NONE;
2953 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2958 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2960 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2962 return AV_CODEC_ID_NONE;
2967 if (sflags & (1 << (bps - 1))) {
2970 return AV_CODEC_ID_PCM_S8;
2972 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2974 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2976 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2978 return AV_CODEC_ID_NONE;
2983 return AV_CODEC_ID_PCM_U8;
2985 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2987 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2989 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2991 return AV_CODEC_ID_NONE;
2997 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3000 if (!av_codec_get_tag2(tags, id, &tag))
3005 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3009 for (i = 0; tags && tags[i]; i++) {
3010 const AVCodecTag *codec_tags = tags[i];
3011 while (codec_tags->id != AV_CODEC_ID_NONE) {
3012 if (codec_tags->id == id) {
3013 *tag = codec_tags->tag;
3022 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3025 for (i = 0; tags && tags[i]; i++) {
3026 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3027 if (id != AV_CODEC_ID_NONE)
3030 return AV_CODEC_ID_NONE;
3033 static void compute_chapters_end(AVFormatContext *s)
3036 int64_t max_time = 0;
3038 if (s->duration > 0)
3039 max_time = s->duration +
3040 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3042 for (i = 0; i < s->nb_chapters; i++)
3043 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3044 AVChapter *ch = s->chapters[i];
3045 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3049 for (j = 0; j < s->nb_chapters; j++) {
3050 AVChapter *ch1 = s->chapters[j];
3051 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3053 if (j != i && next_start > ch->start && next_start < end)
3056 ch->end = (end == INT64_MAX) ? ch->start : end;
3060 static int get_std_framerate(int i)
3063 return (i + 1) * 1001;
3067 return (i + 31) * 1001 * 12;
3071 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3075 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3078 /* Is the time base unreliable?
3079 * This is a heuristic to balance between quick acceptance of the values in
3080 * the headers vs. some extra checks.
3081 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3082 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3083 * And there are "variable" fps files this needs to detect as well. */
3084 static int tb_unreliable(AVCodecContext *c)
3086 if (c->time_base.den >= 101LL * c->time_base.num ||
3087 c->time_base.den < 5LL * c->time_base.num ||
3088 // c->codec_tag == AV_RL32("DIVX") ||
3089 // c->codec_tag == AV_RL32("XVID") ||
3090 c->codec_tag == AV_RL32("mp4v") ||
3091 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3092 c->codec_id == AV_CODEC_ID_GIF ||
3093 c->codec_id == AV_CODEC_ID_HEVC ||
3094 c->codec_id == AV_CODEC_ID_H264)
3099 int ff_alloc_extradata(AVCodecParameters *par, int size)
3103 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3104 par->extradata = NULL;
3105 par->extradata_size = 0;
3106 return AVERROR(EINVAL);
3108 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3109 if (par->extradata) {
3110 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3111 par->extradata_size = size;
3114 par->extradata_size = 0;
3115 ret = AVERROR(ENOMEM);
3120 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3122 int ret = ff_alloc_extradata(par, size);
3125 ret = avio_read(pb, par->extradata, size);
3127 av_freep(&par->extradata);
3128 par->extradata_size = 0;
3129 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3130 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3136 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3139 int64_t last = st->info->last_dts;
3141 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3142 && ts - (uint64_t)last < INT64_MAX) {
3143 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3144 int64_t duration = ts - last;
3146 if (!st->info->duration_error)
3147 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3148 if (!st->info->duration_error)
3149 return AVERROR(ENOMEM);
3151 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3152 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3153 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3154 if (st->info->duration_error[0][1][i] < 1e10) {
3155 int framerate = get_std_framerate(i);
3156 double sdts = dts*framerate/(1001*12);
3157 for (j= 0; j<2; j++) {
3158 int64_t ticks = llrint(sdts+j*0.5);
3159 double error= sdts - ticks + j*0.5;
3160 st->info->duration_error[j][0][i] += error;
3161 st->info->duration_error[j][1][i] += error*error;
3165 st->info->duration_count++;
3166 st->info->rfps_duration_sum += duration;
3168 if (st->info->duration_count % 10 == 0) {
3169 int n = st->info->duration_count;
3170 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3171 if (st->info->duration_error[0][1][i] < 1e10) {
3172 double a0 = st->info->duration_error[0][0][i] / n;
3173 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3174 double a1 = st->info->duration_error[1][0][i] / n;
3175 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3176 if (error0 > 0.04 && error1 > 0.04) {
3177 st->info->duration_error[0][1][i] = 2e10;
3178 st->info->duration_error[1][1][i] = 2e10;
3184 // ignore the first 4 values, they might have some random jitter
3185 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3186 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3188 if (ts != AV_NOPTS_VALUE)
3189 st->info->last_dts = ts;
3194 void ff_rfps_calculate(AVFormatContext *ic)
3198 for (i = 0; i < ic->nb_streams; i++) {
3199 AVStream *st = ic->streams[i];
3201 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3203 // the check for tb_unreliable() is not completely correct, since this is not about handling
3204 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3205 // ipmovie.c produces.
3206 if (tb_unreliable(st->internal->avctx) && 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)
3207 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);
3208 if (st->info->duration_count>1 && !st->r_frame_rate.num
3209 && tb_unreliable(st->internal->avctx)) {
3211 double best_error= 0.01;
3212 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3214 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3217 if (st->info->codec_info_duration &&
3218 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3220 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3223 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3226 for (k= 0; k<2; k++) {
3227 int n = st->info->duration_count;
3228 double a= st->info->duration_error[k][0][j] / n;
3229 double error= st->info->duration_error[k][1][j]/n - a*a;
3231 if (error < best_error && best_error> 0.000000001) {
3233 num = get_std_framerate(j);
3236 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3239 // do not increase frame rate by more than 1 % in order to match a standard rate.
3240 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3241 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3243 if ( !st->avg_frame_rate.num
3244 && st->r_frame_rate.num && st->info->rfps_duration_sum
3245 && st->info->codec_info_duration <= 0
3246 && st->info->duration_count > 2
3247 && 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
3249 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3250 st->avg_frame_rate = st->r_frame_rate;
3253 av_freep(&st->info->duration_error);
3254 st->info->last_dts = AV_NOPTS_VALUE;
3255 st->info->duration_count = 0;
3256 st->info->rfps_duration_sum = 0;
3260 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3262 int i, count, ret = 0, j;
3265 AVCodecContext *avctx;
3266 AVPacket pkt1, *pkt;
3267 int64_t old_offset = avio_tell(ic->pb);
3268 // new streams might appear, no options for those
3269 int orig_nb_streams = ic->nb_streams;
3271 int64_t max_analyze_duration = ic->max_analyze_duration;
3272 int64_t max_stream_analyze_duration;
3273 int64_t max_subtitle_analyze_duration;
3274 int64_t probesize = ic->probesize;
3275 int eof_reached = 0;
3277 flush_codecs = probesize > 0;
3279 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3281 max_stream_analyze_duration = max_analyze_duration;
3282 max_subtitle_analyze_duration = max_analyze_duration;
3283 if (!max_analyze_duration) {
3284 max_stream_analyze_duration =
3285 max_analyze_duration = 5*AV_TIME_BASE;
3286 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3287 if (!strcmp(ic->iformat->name, "flv"))
3288 max_stream_analyze_duration = 90*AV_TIME_BASE;
3289 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3290 max_stream_analyze_duration = 7*AV_TIME_BASE;
3294 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3295 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3297 for (i = 0; i < ic->nb_streams; i++) {
3298 const AVCodec *codec;
3299 AVDictionary *thread_opt = NULL;
3300 st = ic->streams[i];
3301 avctx = st->internal->avctx;
3303 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3304 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3305 /* if (!st->time_base.num)
3307 if (!avctx->time_base.num)
3308 avctx->time_base = st->time_base;
3310 // only for the split stuff
3311 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3312 st->parser = av_parser_init(st->codecpar->codec_id);
3314 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3315 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3316 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3317 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3319 } else if (st->need_parsing) {
3320 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3321 "%s, packets or times may be invalid.\n",
3322 avcodec_get_name(st->codecpar->codec_id));
3326 /* check if the caller has overridden the codec id */
3327 #if FF_API_LAVF_AVCTX
3328 FF_DISABLE_DEPRECATION_WARNINGS
3329 if (st->codec->codec_id != st->internal->orig_codec_id) {
3330 st->codecpar->codec_id = st->codec->codec_id;
3331 st->codecpar->codec_type = st->codec->codec_type;
3332 st->internal->orig_codec_id = st->codec->codec_id;
3334 FF_ENABLE_DEPRECATION_WARNINGS
3336 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3337 st->internal->orig_codec_id = st->codecpar->codec_id;
3339 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3341 goto find_stream_info_err;
3342 if (st->request_probe <= 0)
3343 st->internal->avctx_inited = 1;
3345 codec = find_decoder(ic, st, st->codecpar->codec_id);
3347 /* Force thread count to 1 since the H.264 decoder will not extract
3348 * SPS and PPS to extradata during multi-threaded decoding. */
3349 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3351 if (ic->codec_whitelist)
3352 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3354 /* Ensure that subtitle_header is properly set. */
3355 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3356 && codec && !avctx->codec) {
3357 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3358 av_log(ic, AV_LOG_WARNING,
3359 "Failed to open codec in av_find_stream_info\n");
3362 // Try to just open decoders, in case this is enough to get parameters.
3363 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3364 if (codec && !avctx->codec)
3365 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3366 av_log(ic, AV_LOG_WARNING,
3367 "Failed to open codec in av_find_stream_info\n");
3370 av_dict_free(&thread_opt);
3373 for (i = 0; i < ic->nb_streams; i++) {
3374 #if FF_API_R_FRAME_RATE
3375 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3377 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3378 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3384 int analyzed_all_streams;
3385 if (ff_check_interrupt(&ic->interrupt_callback)) {
3387 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3391 /* check if one codec still needs to be handled */
3392 for (i = 0; i < ic->nb_streams; i++) {
3393 int fps_analyze_framecount = 20;
3395 st = ic->streams[i];
3396 if (!has_codec_parameters(st, NULL))
3398 /* If the timebase is coarse (like the usual millisecond precision
3399 * of mkv), we need to analyze more frames to reliably arrive at
3400 * the correct fps. */
3401 if (av_q2d(st->time_base) > 0.0005)
3402 fps_analyze_framecount *= 2;
3403 if (!tb_unreliable(st->internal->avctx))
3404 fps_analyze_framecount = 0;
3405 if (ic->fps_probe_size >= 0)
3406 fps_analyze_framecount = ic->fps_probe_size;
3407 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3408 fps_analyze_framecount = 0;
3409 /* variable fps and no guess at the real fps */
3410 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3411 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3412 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3413 st->info->codec_info_duration_fields/2 :
3414 st->info->duration_count;
3415 if (count < fps_analyze_framecount)
3418 if (st->parser && st->parser->parser->split &&
3419 !st->codecpar->extradata)
3421 if (st->first_dts == AV_NOPTS_VALUE &&
3422 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3423 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3424 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3425 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3428 analyzed_all_streams = 0;
3429 if (i == ic->nb_streams) {
3430 analyzed_all_streams = 1;
3431 /* NOTE: If the format has no header, then we need to read some
3432 * packets to get most of the streams, so we cannot stop here. */
3433 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3434 /* If we found the info for all the codecs, we can stop. */
3436 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3441 /* We did not get all the codec info, but we read too much data. */
3442 if (read_size >= probesize) {
3444 av_log(ic, AV_LOG_DEBUG,
3445 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3446 for (i = 0; i < ic->nb_streams; i++)
3447 if (!ic->streams[i]->r_frame_rate.num &&
3448 ic->streams[i]->info->duration_count <= 1 &&
3449 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3450 strcmp(ic->iformat->name, "image2"))
3451 av_log(ic, AV_LOG_WARNING,
3452 "Stream #%d: not enough frames to estimate rate; "
3453 "consider increasing probesize\n", i);
3457 /* NOTE: A new stream can be added there if no header in file
3458 * (AVFMTCTX_NOHEADER). */
3459 ret = read_frame_internal(ic, &pkt1);
3460 if (ret == AVERROR(EAGAIN))
3471 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3472 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3473 &ic->internal->packet_buffer_end, 0);
3475 goto find_stream_info_err;
3478 st = ic->streams[pkt->stream_index];
3479 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3480 read_size += pkt->size;
3482 avctx = st->internal->avctx;
3483 if (!st->internal->avctx_inited) {
3484 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3486 goto find_stream_info_err;
3487 st->internal->avctx_inited = 1;
3490 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3491 /* check for non-increasing dts */
3492 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3493 st->info->fps_last_dts >= pkt->dts) {
3494 av_log(ic, AV_LOG_DEBUG,
3495 "Non-increasing DTS in stream %d: packet %d with DTS "
3496 "%"PRId64", packet %d with DTS %"PRId64"\n",
3497 st->index, st->info->fps_last_dts_idx,
3498 st->info->fps_last_dts, st->codec_info_nb_frames,
3500 st->info->fps_first_dts =
3501 st->info->fps_last_dts = AV_NOPTS_VALUE;
3503 /* Check for a discontinuity in dts. If the difference in dts
3504 * is more than 1000 times the average packet duration in the
3505 * sequence, we treat it as a discontinuity. */
3506 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3507 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3508 (pkt->dts - st->info->fps_last_dts) / 1000 >
3509 (st->info->fps_last_dts - st->info->fps_first_dts) /
3510 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3511 av_log(ic, AV_LOG_WARNING,
3512 "DTS discontinuity in stream %d: packet %d with DTS "
3513 "%"PRId64", packet %d with DTS %"PRId64"\n",
3514 st->index, st->info->fps_last_dts_idx,
3515 st->info->fps_last_dts, st->codec_info_nb_frames,
3517 st->info->fps_first_dts =
3518 st->info->fps_last_dts = AV_NOPTS_VALUE;
3521 /* update stored dts values */
3522 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3523 st->info->fps_first_dts = pkt->dts;
3524 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3526 st->info->fps_last_dts = pkt->dts;
3527 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3529 if (st->codec_info_nb_frames>1) {
3533 if (st->time_base.den > 0)
3534 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3535 if (st->avg_frame_rate.num > 0)
3536 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3539 && st->codec_info_nb_frames>30
3540 && st->info->fps_first_dts != AV_NOPTS_VALUE
3541 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3542 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3544 if (analyzed_all_streams) limit = max_analyze_duration;
3545 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3546 else limit = max_stream_analyze_duration;
3549 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3551 t, pkt->stream_index);
3552 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3553 av_packet_unref(pkt);
3556 if (pkt->duration) {
3557 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3558 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3560 st->info->codec_info_duration += pkt->duration;
3561 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3564 #if FF_API_R_FRAME_RATE
3565 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3566 ff_rfps_add_frame(ic, st, pkt->dts);
3568 if (st->parser && st->parser->parser->split && !avctx->extradata) {
3569 int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3570 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3571 avctx->extradata_size = i;
3572 avctx->extradata = av_mallocz(avctx->extradata_size +
3573 AV_INPUT_BUFFER_PADDING_SIZE);
3574 if (!avctx->extradata)
3575 return AVERROR(ENOMEM);
3576 memcpy(avctx->extradata, pkt->data,
3577 avctx->extradata_size);
3581 /* If still no information, we try to open the codec and to
3582 * decompress the frame. We try to avoid that in most cases as
3583 * it takes longer and uses more memory. For MPEG-4, we need to
3584 * decompress for QuickTime.
3586 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3587 * least one frame of codec data, this makes sure the codec initializes
3588 * the channel configuration and does not only trust the values from
3590 try_decode_frame(ic, st, pkt,
3591 (options && i < orig_nb_streams) ? &options[i] : NULL);
3593 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3594 av_packet_unref(pkt);
3596 st->codec_info_nb_frames++;
3600 if (eof_reached && ic->internal->packet_buffer) {
3602 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3603 // EOF already reached while reading the stream above.
3604 // So continue with reoordering DTS with whatever delay we have.
3605 if (!has_decode_delay_been_guessed(st)) {
3606 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3612 AVPacket empty_pkt = { 0 };
3614 av_init_packet(&empty_pkt);
3616 for (i = 0; i < ic->nb_streams; i++) {
3618 st = ic->streams[i];
3620 /* flush the decoders */
3621 if (st->info->found_decoder == 1) {
3623 err = try_decode_frame(ic, st, &empty_pkt,
3624 (options && i < orig_nb_streams)
3625 ? &options[i] : NULL);
3626 } while (err > 0 && !has_codec_parameters(st, NULL));
3629 av_log(ic, AV_LOG_INFO,
3630 "decoding for stream %d failed\n", st->index);
3636 // close codecs which were opened in try_decode_frame()
3637 for (i = 0; i < ic->nb_streams; i++) {
3638 st = ic->streams[i];
3639 avcodec_close(st->internal->avctx);
3642 ff_rfps_calculate(ic);
3644 for (i = 0; i < ic->nb_streams; i++) {
3645 st = ic->streams[i];
3646 avctx = st->internal->avctx;
3647 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3648 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3649 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3650 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3651 avctx->codec_tag= tag;
3654 /* estimate average framerate if not set by demuxer */
3655 if (st->info->codec_info_duration_fields &&
3656 !st->avg_frame_rate.num &&
3657 st->info->codec_info_duration) {
3659 double best_error = 0.01;
3661 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3662 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3663 st->info->codec_info_duration < 0)
3665 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3666 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3667 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3669 /* Round guessed framerate to a "standard" framerate if it's
3670 * within 1% of the original estimate. */
3671 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3672 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3673 double error = fabs(av_q2d(st->avg_frame_rate) /
3674 av_q2d(std_fps) - 1);
3676 if (error < best_error) {
3678 best_fps = std_fps.num;
3682 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3683 best_fps, 12 * 1001, INT_MAX);
3686 if (!st->r_frame_rate.num) {
3687 if ( avctx->time_base.den * (int64_t) st->time_base.num
3688 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3689 st->r_frame_rate.num = avctx->time_base.den;
3690 st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3692 st->r_frame_rate.num = st->time_base.den;
3693 st->r_frame_rate.den = st->time_base.num;
3696 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3697 AVRational hw_ratio = { avctx->height, avctx->width };
3698 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3701 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3702 if (!avctx->bits_per_coded_sample)
3703 avctx->bits_per_coded_sample =
3704 av_get_bits_per_sample(avctx->codec_id);
3705 // set stream disposition based on audio service type
3706 switch (avctx->audio_service_type) {
3707 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3708 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3710 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3711 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3713 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3714 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3716 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3717 st->disposition = AV_DISPOSITION_COMMENT;
3719 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3720 st->disposition = AV_DISPOSITION_KARAOKE;
3727 estimate_timings(ic, old_offset);
3729 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3731 if (ret >= 0 && ic->nb_streams)
3732 /* We could not have all the codec parameters before EOF. */
3734 for (i = 0; i < ic->nb_streams; i++) {
3736 st = ic->streams[i];
3738 /* if no packet was ever seen, update context now for has_codec_parameters */
3739 if (!st->internal->avctx_inited) {
3740 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3742 goto find_stream_info_err;
3744 if (!has_codec_parameters(st, &errmsg)) {
3746 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3747 av_log(ic, AV_LOG_WARNING,
3748 "Could not find codec parameters for stream %d (%s): %s\n"
3749 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3756 compute_chapters_end(ic);
3758 /* update the stream parameters from the internal codec contexts */
3759 for (i = 0; i < ic->nb_streams; i++) {
3760 st = ic->streams[i];
3762 if (st->internal->avctx_inited) {
3763 int orig_w = st->codecpar->width;
3764 int orig_h = st->codecpar->height;
3765 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
3767 goto find_stream_info_err;
3768 // The decoder might reduce the video size by the lowres factor.
3769 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3770 st->codecpar->width = orig_w;
3771 st->codecpar->height = orig_h;
3775 #if FF_API_LAVF_AVCTX
3776 FF_DISABLE_DEPRECATION_WARNINGS
3777 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3779 goto find_stream_info_err;
3781 // The old API (AVStream.codec) "requires" the resolution to be adjusted
3782 // by the lowres factor.
3783 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3784 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
3785 st->codec->width = st->internal->avctx->width;
3786 st->codec->height = st->internal->avctx->height;
3787 st->codec->coded_width = st->internal->avctx->coded_width;
3788 st->codec->coded_height = st->internal->avctx->coded_height;
3791 if (st->codec->codec_tag != MKTAG('t','m','c','d'))
3792 st->codec->time_base = st->internal->avctx->time_base;
3793 st->codec->framerate = st->avg_frame_rate;
3795 if (st->internal->avctx->subtitle_header) {
3796 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3797 if (!st->codec->subtitle_header)
3798 goto find_stream_info_err;
3799 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3800 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3801 st->codec->subtitle_header_size);
3803 FF_ENABLE_DEPRECATION_WARNINGS
3806 st->internal->avctx_inited = 0;
3809 find_stream_info_err:
3810 for (i = 0; i < ic->nb_streams; i++) {
3811 st = ic->streams[i];
3813 av_freep(&st->info->duration_error);
3814 av_freep(&ic->streams[i]->info);
3817 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3818 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3822 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3826 for (i = 0; i < ic->nb_programs; i++) {
3827 if (ic->programs[i] == last) {
3831 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3832 if (ic->programs[i]->stream_index[j] == s)
3833 return ic->programs[i];
3839 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3840 int wanted_stream_nb, int related_stream,
3841 AVCodec **decoder_ret, int flags)
3843 int i, nb_streams = ic->nb_streams;
3844 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3845 unsigned *program = NULL;
3846 const AVCodec *decoder = NULL, *best_decoder = NULL;
3848 if (related_stream >= 0 && wanted_stream_nb < 0) {
3849 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3851 program = p->stream_index;
3852 nb_streams = p->nb_stream_indexes;
3855 for (i = 0; i < nb_streams; i++) {
3856 int real_stream_index = program ? program[i] : i;
3857 AVStream *st = ic->streams[real_stream_index];
3858 AVCodecParameters *par = st->codecpar;
3859 if (par->codec_type != type)
3861 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3863 if (wanted_stream_nb != real_stream_index &&
3864 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3865 AV_DISPOSITION_VISUAL_IMPAIRED))
3867 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
3870 decoder = find_decoder(ic, st, par->codec_id);
3873 ret = AVERROR_DECODER_NOT_FOUND;
3877 count = st->codec_info_nb_frames;
3878 bitrate = par->bit_rate;
3879 multiframe = FFMIN(5, count);
3880 if ((best_multiframe > multiframe) ||
3881 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3882 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3885 best_bitrate = bitrate;
3886 best_multiframe = multiframe;
3887 ret = real_stream_index;
3888 best_decoder = decoder;
3889 if (program && i == nb_streams - 1 && ret < 0) {
3891 nb_streams = ic->nb_streams;
3892 /* no related stream found, try again with everything */
3897 *decoder_ret = (AVCodec*)best_decoder;
3901 /*******************************************************/
3903 int av_read_play(AVFormatContext *s)
3905 if (s->iformat->read_play)
3906 return s->iformat->read_play(s);
3908 return avio_pause(s->pb, 0);
3909 return AVERROR(ENOSYS);
3912 int av_read_pause(AVFormatContext *s)
3914 if (s->iformat->read_pause)
3915 return s->iformat->read_pause(s);
3917 return avio_pause(s->pb, 1);
3918 return AVERROR(ENOSYS);
3921 static void free_stream(AVStream **pst)
3923 AVStream *st = *pst;
3929 for (i = 0; i < st->nb_side_data; i++)
3930 av_freep(&st->side_data[i].data);
3931 av_freep(&st->side_data);
3934 av_parser_close(st->parser);
3936 if (st->attached_pic.data)
3937 av_packet_unref(&st->attached_pic);
3940 avcodec_free_context(&st->internal->avctx);
3942 av_freep(&st->internal);
3944 av_dict_free(&st->metadata);
3945 avcodec_parameters_free(&st->codecpar);
3946 av_freep(&st->probe_data.buf);
3947 av_freep(&st->index_entries);
3948 #if FF_API_LAVF_AVCTX
3949 FF_DISABLE_DEPRECATION_WARNINGS
3950 av_freep(&st->codec->extradata);
3951 av_freep(&st->codec->subtitle_header);
3952 av_freep(&st->codec);
3953 FF_ENABLE_DEPRECATION_WARNINGS
3955 av_freep(&st->priv_data);
3957 av_freep(&st->info->duration_error);
3958 av_freep(&st->info);
3959 av_freep(&st->recommended_encoder_configuration);
3960 av_freep(&st->priv_pts);
3965 void ff_free_stream(AVFormatContext *s, AVStream *st)
3967 av_assert0(s->nb_streams>0);
3968 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3970 free_stream(&s->streams[ --s->nb_streams ]);
3973 void avformat_free_context(AVFormatContext *s)
3981 if (s->iformat && s->iformat->priv_class && s->priv_data)
3982 av_opt_free(s->priv_data);
3983 if (s->oformat && s->oformat->priv_class && s->priv_data)
3984 av_opt_free(s->priv_data);
3986 for (i = s->nb_streams - 1; i >= 0; i--)
3987 ff_free_stream(s, s->streams[i]);
3990 for (i = s->nb_programs - 1; i >= 0; i--) {
3991 av_dict_free(&s->programs[i]->metadata);
3992 av_freep(&s->programs[i]->stream_index);
3993 av_freep(&s->programs[i]);
3995 av_freep(&s->programs);
3996 av_freep(&s->priv_data);
3997 while (s->nb_chapters--) {
3998 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3999 av_freep(&s->chapters[s->nb_chapters]);
4001 av_freep(&s->chapters);
4002 av_dict_free(&s->metadata);
4003 av_freep(&s->streams);
4004 av_freep(&s->internal);
4005 flush_packet_queue(s);
4009 void avformat_close_input(AVFormatContext **ps)
4020 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4021 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4024 flush_packet_queue(s);
4027 if (s->iformat->read_close)
4028 s->iformat->read_close(s);
4030 avformat_free_context(s);
4037 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4043 if (s->nb_streams >= INT_MAX/sizeof(*streams))
4045 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4048 s->streams = streams;
4050 st = av_mallocz(sizeof(AVStream));
4053 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4057 st->info->last_dts = AV_NOPTS_VALUE;
4059 #if FF_API_LAVF_AVCTX
4060 FF_DISABLE_DEPRECATION_WARNINGS
4061 st->codec = avcodec_alloc_context3(c);
4067 FF_ENABLE_DEPRECATION_WARNINGS
4070 st->internal = av_mallocz(sizeof(*st->internal));
4074 st->codecpar = avcodec_parameters_alloc();
4078 st->internal->avctx = avcodec_alloc_context3(NULL);
4079 if (!st->internal->avctx)
4083 #if FF_API_LAVF_AVCTX
4084 FF_DISABLE_DEPRECATION_WARNINGS
4085 /* no default bitrate if decoding */
4086 st->codec->bit_rate = 0;
4087 FF_ENABLE_DEPRECATION_WARNINGS
4090 /* default pts setting is MPEG-like */
4091 avpriv_set_pts_info(st, 33, 1, 90000);
4092 /* we set the current DTS to 0 so that formats without any timestamps
4093 * but durations get some timestamps, formats with some unknown
4094 * timestamps have their first few packets buffered and the
4095 * timestamps corrected before they are returned to the user */
4096 st->cur_dts = RELATIVE_TS_BASE;
4098 st->cur_dts = AV_NOPTS_VALUE;
4101 st->index = s->nb_streams;
4102 st->start_time = AV_NOPTS_VALUE;
4103 st->duration = AV_NOPTS_VALUE;
4104 st->first_dts = AV_NOPTS_VALUE;
4105 st->probe_packets = MAX_PROBE_PACKETS;
4106 st->pts_wrap_reference = AV_NOPTS_VALUE;
4107 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4109 st->last_IP_pts = AV_NOPTS_VALUE;
4110 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4111 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4112 st->pts_buffer[i] = AV_NOPTS_VALUE;
4114 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4116 #if FF_API_R_FRAME_RATE
4117 st->info->last_dts = AV_NOPTS_VALUE;
4119 st->info->fps_first_dts = AV_NOPTS_VALUE;
4120 st->info->fps_last_dts = AV_NOPTS_VALUE;
4122 st->inject_global_side_data = s->internal->inject_global_side_data;
4124 st->internal->need_context_update = 1;
4126 s->streams[s->nb_streams++] = st;
4133 AVProgram *av_new_program(AVFormatContext *ac, int id)
4135 AVProgram *program = NULL;
4138 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4140 for (i = 0; i < ac->nb_programs; i++)
4141 if (ac->programs[i]->id == id)
4142 program = ac->programs[i];
4145 program = av_mallocz(sizeof(AVProgram));
4148 dynarray_add(&ac->programs, &ac->nb_programs, program);
4149 program->discard = AVDISCARD_NONE;
4152 program->pts_wrap_reference = AV_NOPTS_VALUE;
4153 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4155 program->start_time =
4156 program->end_time = AV_NOPTS_VALUE;
4161 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4162 int64_t start, int64_t end, const char *title)
4164 AVChapter *chapter = NULL;
4167 if (end != AV_NOPTS_VALUE && start > end) {
4168 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4172 for (i = 0; i < s->nb_chapters; i++)
4173 if (s->chapters[i]->id == id)
4174 chapter = s->chapters[i];
4177 chapter = av_mallocz(sizeof(AVChapter));
4180 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4182 av_dict_set(&chapter->metadata, "title", title, 0);
4184 chapter->time_base = time_base;
4185 chapter->start = start;
4191 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4194 AVProgram *program = NULL;
4197 if (idx >= ac->nb_streams) {
4198 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4202 for (i = 0; i < ac->nb_programs; i++) {
4203 if (ac->programs[i]->id != progid)
4205 program = ac->programs[i];
4206 for (j = 0; j < program->nb_stream_indexes; j++)
4207 if (program->stream_index[j] == idx)
4210 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4213 program->stream_index = tmp;
4214 program->stream_index[program->nb_stream_indexes++] = idx;
4219 uint64_t ff_ntp_time(void)
4221 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4224 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4227 char *q, buf1[20], c;
4228 int nd, len, percentd_found;
4240 while (av_isdigit(*p))
4241 nd = nd * 10 + *p++ - '0';
4243 } while (av_isdigit(c));
4254 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4256 if ((q - buf + len) > buf_size - 1)
4258 memcpy(q, buf1, len);
4266 if ((q - buf) < buf_size - 1)
4270 if (!percentd_found)
4279 void av_url_split(char *proto, int proto_size,
4280 char *authorization, int authorization_size,
4281 char *hostname, int hostname_size,
4282 int *port_ptr, char *path, int path_size, const char *url)
4284 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4290 if (authorization_size > 0)
4291 authorization[0] = 0;
4292 if (hostname_size > 0)
4297 /* parse protocol */
4298 if ((p = strchr(url, ':'))) {
4299 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4306 /* no protocol means plain filename */
4307 av_strlcpy(path, url, path_size);
4311 /* separate path from hostname */
4312 ls = strchr(p, '/');
4313 ls2 = strchr(p, '?');
4317 ls = FFMIN(ls, ls2);
4319 av_strlcpy(path, ls, path_size);
4321 ls = &p[strlen(p)]; // XXX
4323 /* the rest is hostname, use that to parse auth/port */
4325 /* authorization (user[:pass]@hostname) */
4327 while ((at = strchr(p, '@')) && at < ls) {
4328 av_strlcpy(authorization, at2,
4329 FFMIN(authorization_size, at + 1 - at2));
4330 p = at + 1; /* skip '@' */
4333 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4335 av_strlcpy(hostname, p + 1,
4336 FFMIN(hostname_size, brk - p));
4337 if (brk[1] == ':' && port_ptr)
4338 *port_ptr = atoi(brk + 2);
4339 } else if ((col = strchr(p, ':')) && col < ls) {
4340 av_strlcpy(hostname, p,
4341 FFMIN(col + 1 - p, hostname_size));
4343 *port_ptr = atoi(col + 1);
4345 av_strlcpy(hostname, p,
4346 FFMIN(ls + 1 - p, hostname_size));
4350 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4353 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4356 'C', 'D', 'E', 'F' };
4357 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4360 'c', 'd', 'e', 'f' };
4361 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4363 for (i = 0; i < s; i++) {
4364 buff[i * 2] = hex_table[src[i] >> 4];
4365 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4371 int ff_hex_to_data(uint8_t *data, const char *p)
4378 p += strspn(p, SPACE_CHARS);
4381 c = av_toupper((unsigned char) *p++);
4382 if (c >= '0' && c <= '9')
4384 else if (c >= 'A' && c <= 'F')
4399 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4400 unsigned int pts_num, unsigned int pts_den)
4403 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4404 if (new_tb.num != pts_num)
4405 av_log(NULL, AV_LOG_DEBUG,
4406 "st:%d removing common factor %d from timebase\n",
4407 s->index, pts_num / new_tb.num);
4409 av_log(NULL, AV_LOG_WARNING,
4410 "st:%d has too large timebase, reducing\n", s->index);
4412 if (new_tb.num <= 0 || new_tb.den <= 0) {
4413 av_log(NULL, AV_LOG_ERROR,
4414 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4415 new_tb.num, new_tb.den,
4419 s->time_base = new_tb;
4420 #if FF_API_LAVF_AVCTX
4421 FF_DISABLE_DEPRECATION_WARNINGS
4422 av_codec_set_pkt_timebase(s->codec, new_tb);
4423 FF_ENABLE_DEPRECATION_WARNINGS
4425 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4426 s->pts_wrap_bits = pts_wrap_bits;
4429 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4432 const char *ptr = str;
4434 /* Parse key=value pairs. */
4437 char *dest = NULL, *dest_end;
4438 int key_len, dest_len = 0;
4440 /* Skip whitespace and potential commas. */
4441 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4448 if (!(ptr = strchr(key, '=')))
4451 key_len = ptr - key;
4453 callback_get_buf(context, key, key_len, &dest, &dest_len);
4454 dest_end = dest + dest_len - 1;
4458 while (*ptr && *ptr != '\"') {
4462 if (dest && dest < dest_end)
4466 if (dest && dest < dest_end)
4474 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4475 if (dest && dest < dest_end)
4483 int ff_find_stream_index(AVFormatContext *s, int id)
4486 for (i = 0; i < s->nb_streams; i++)
4487 if (s->streams[i]->id == id)
4492 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4496 unsigned int codec_tag;
4497 if (ofmt->query_codec)
4498 return ofmt->query_codec(codec_id, std_compliance);
4499 else if (ofmt->codec_tag)
4500 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4501 else if (codec_id == ofmt->video_codec ||
4502 codec_id == ofmt->audio_codec ||
4503 codec_id == ofmt->subtitle_codec)
4506 return AVERROR_PATCHWELCOME;
4509 int avformat_network_init(void)
4513 ff_network_inited_globally = 1;
4514 if ((ret = ff_network_init()) < 0)
4516 if ((ret = ff_tls_init()) < 0)
4522 int avformat_network_deinit(void)
4527 ff_network_inited_globally = 0;
4532 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4533 uint64_t channel_layout, int32_t sample_rate,
4534 int32_t width, int32_t height)
4540 return AVERROR(EINVAL);
4543 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4545 if (channel_layout) {
4547 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4551 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4553 if (width || height) {
4555 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4557 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4559 return AVERROR(ENOMEM);
4560 bytestream_put_le32(&data, flags);
4562 bytestream_put_le32(&data, channels);
4564 bytestream_put_le64(&data, channel_layout);
4566 bytestream_put_le32(&data, sample_rate);
4567 if (width || height) {
4568 bytestream_put_le32(&data, width);
4569 bytestream_put_le32(&data, height);
4574 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4576 AVRational undef = {0, 1};
4577 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4578 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4579 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4581 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4582 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4583 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4584 stream_sample_aspect_ratio = undef;
4586 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4587 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4588 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4589 frame_sample_aspect_ratio = undef;
4591 if (stream_sample_aspect_ratio.num)
4592 return stream_sample_aspect_ratio;
4594 return frame_sample_aspect_ratio;
4597 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4599 AVRational fr = st->r_frame_rate;
4600 AVRational codec_fr = st->internal->avctx->framerate;
4601 AVRational avg_fr = st->avg_frame_rate;
4603 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4604 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4609 if (st->internal->avctx->ticks_per_frame > 1) {
4610 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4611 (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))
4618 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4621 if (*spec <= '9' && *spec >= '0') /* opt:index */
4622 return strtol(spec, NULL, 0) == st->index;
4623 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4624 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4625 enum AVMediaType type;
4629 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4630 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4631 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4632 case 'd': type = AVMEDIA_TYPE_DATA; break;
4633 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4634 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4635 default: av_assert0(0);
4637 #if FF_API_LAVF_AVCTX
4638 FF_DISABLE_DEPRECATION_WARNINGS
4639 if (type != st->codecpar->codec_type
4640 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4642 FF_ENABLE_DEPRECATION_WARNINGS
4644 if (type != st->codecpar->codec_type)
4647 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4649 if (*spec++ == ':') { /* possibly followed by :index */
4650 int i, index = strtol(spec, NULL, 0);
4651 for (i = 0; i < s->nb_streams; i++) {
4652 #if FF_API_LAVF_AVCTX
4653 FF_DISABLE_DEPRECATION_WARNINGS
4654 if ((s->streams[i]->codecpar->codec_type == type
4655 || s->streams[i]->codec->codec_type == type
4657 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4659 return i == st->index;
4660 FF_ENABLE_DEPRECATION_WARNINGS
4662 if ((s->streams[i]->codecpar->codec_type == type) &&
4663 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4665 return i == st->index;
4671 } else if (*spec == 'p' && *(spec + 1) == ':') {
4675 prog_id = strtol(spec, &endptr, 0);
4676 for (i = 0; i < s->nb_programs; i++) {
4677 if (s->programs[i]->id != prog_id)
4680 if (*endptr++ == ':') {
4681 int stream_idx = strtol(endptr, NULL, 0);
4682 return stream_idx >= 0 &&
4683 stream_idx < s->programs[i]->nb_stream_indexes &&
4684 st->index == s->programs[i]->stream_index[stream_idx];
4687 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4688 if (st->index == s->programs[i]->stream_index[j])
4692 } else if (*spec == '#' ||
4693 (*spec == 'i' && *(spec + 1) == ':')) {
4696 spec += 1 + (*spec == 'i');
4697 stream_id = strtol(spec, &endptr, 0);
4699 return stream_id == st->id;
4700 } else if (*spec == 'm' && *(spec + 1) == ':') {
4701 AVDictionaryEntry *tag;
4706 val = strchr(spec, ':');
4708 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4710 return AVERROR(ENOMEM);
4712 tag = av_dict_get(st->metadata, key, NULL, 0);
4714 if (!val || !strcmp(tag->value, val + 1))
4723 } else if (*spec == 'u') {
4724 AVCodecParameters *par = st->codecpar;
4725 #if FF_API_LAVF_AVCTX
4726 FF_DISABLE_DEPRECATION_WARNINGS
4727 AVCodecContext *codec = st->codec;
4728 FF_ENABLE_DEPRECATION_WARNINGS
4731 switch (par->codec_type) {
4732 case AVMEDIA_TYPE_AUDIO:
4733 val = par->sample_rate && par->channels;
4734 #if FF_API_LAVF_AVCTX
4735 val = val || (codec->sample_rate && codec->channels);
4737 if (par->format == AV_SAMPLE_FMT_NONE
4738 #if FF_API_LAVF_AVCTX
4739 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4744 case AVMEDIA_TYPE_VIDEO:
4745 val = par->width && par->height;
4746 #if FF_API_LAVF_AVCTX
4747 val = val || (codec->width && codec->height);
4749 if (par->format == AV_PIX_FMT_NONE
4750 #if FF_API_LAVF_AVCTX
4751 && codec->pix_fmt == AV_PIX_FMT_NONE
4756 case AVMEDIA_TYPE_UNKNOWN:
4763 #if FF_API_LAVF_AVCTX
4764 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4766 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4768 } else if (!*spec) /* empty specifier, matches everything */
4771 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4772 return AVERROR(EINVAL);
4775 int ff_generate_avci_extradata(AVStream *st)
4777 static const uint8_t avci100_1080p_extradata[] = {
4779 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4780 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4781 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4782 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4783 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4784 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4785 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4786 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4787 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4789 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4792 static const uint8_t avci100_1080i_extradata[] = {
4794 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4795 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4796 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4797 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4798 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4799 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4800 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4801 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4802 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4803 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4804 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4806 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4809 static const uint8_t avci50_1080p_extradata[] = {
4811 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4812 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4813 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4814 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4815 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4816 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4817 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4818 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4819 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4821 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4824 static const uint8_t avci50_1080i_extradata[] = {
4826 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4827 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4828 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4829 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4830 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4831 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4832 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4833 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4834 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4835 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4836 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4838 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4841 static const uint8_t avci100_720p_extradata[] = {
4843 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4844 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4845 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4846 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4847 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4848 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4849 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4850 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4851 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4852 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4854 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4857 static const uint8_t avci50_720p_extradata[] = {
4859 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4860 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4861 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4862 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4863 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4864 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4865 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4866 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4867 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4869 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4873 const uint8_t *data = NULL;
4876 if (st->codecpar->width == 1920) {
4877 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
4878 data = avci100_1080p_extradata;
4879 size = sizeof(avci100_1080p_extradata);
4881 data = avci100_1080i_extradata;
4882 size = sizeof(avci100_1080i_extradata);
4884 } else if (st->codecpar->width == 1440) {
4885 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
4886 data = avci50_1080p_extradata;
4887 size = sizeof(avci50_1080p_extradata);
4889 data = avci50_1080i_extradata;
4890 size = sizeof(avci50_1080i_extradata);
4892 } else if (st->codecpar->width == 1280) {
4893 data = avci100_720p_extradata;
4894 size = sizeof(avci100_720p_extradata);
4895 } else if (st->codecpar->width == 960) {
4896 data = avci50_720p_extradata;
4897 size = sizeof(avci50_720p_extradata);
4903 av_freep(&st->codecpar->extradata);
4904 if (ff_alloc_extradata(st->codecpar, size))
4905 return AVERROR(ENOMEM);
4906 memcpy(st->codecpar->extradata, data, size);
4911 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4916 for (i = 0; i < st->nb_side_data; i++) {
4917 if (st->side_data[i].type == type) {
4919 *size = st->side_data[i].size;
4920 return st->side_data[i].data;
4926 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4929 AVPacketSideData *sd, *tmp;
4931 uint8_t *data = av_malloc(size);
4936 for (i = 0; i < st->nb_side_data; i++) {
4937 sd = &st->side_data[i];
4939 if (sd->type == type) {
4940 av_freep(&sd->data);
4947 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4953 st->side_data = tmp;
4956 sd = &st->side_data[st->nb_side_data - 1];
4963 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4965 AVBitStreamFilterContext *bsfc = NULL;
4966 AVBitStreamFilterContext **dest = &st->internal->bsfc;
4967 while (*dest && (*dest)->next)
4968 dest = &(*dest)->next;
4970 if (!(bsfc = av_bitstream_filter_init(name))) {
4971 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4972 return AVERROR(EINVAL);
4974 if (args && !(bsfc->args = av_strdup(args))) {
4975 av_bitstream_filter_close(bsfc);
4976 return AVERROR(ENOMEM);
4978 av_log(NULL, AV_LOG_VERBOSE,
4979 "Automatically inserted bitstream filter '%s'; args='%s'\n",
4980 name, args ? args : "");
4985 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4986 AVBitStreamFilterContext *bsfc)
4990 AVPacket new_pkt = *pkt;
4991 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4992 &new_pkt.data, &new_pkt.size,
4993 pkt->data, pkt->size,
4994 pkt->flags & AV_PKT_FLAG_KEY);
4995 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
4996 av_packet_unref(pkt);
4997 memset(pkt, 0, sizeof(*pkt));
5000 if(a == 0 && new_pkt.data != pkt->data) {
5001 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
5003 memcpy(t, new_pkt.data, new_pkt.size);
5004 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5009 a = AVERROR(ENOMEM);
5013 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5014 av_buffer_default_free, NULL, 0);
5016 pkt->side_data = NULL;
5017 pkt->side_data_elems = 0;
5018 av_packet_unref(pkt);
5020 av_freep(&new_pkt.data);
5021 a = AVERROR(ENOMEM);
5025 av_log(codec, AV_LOG_ERROR,
5026 "Failed to open bitstream filter %s for stream %d with codec %s",
5027 bsfc->filter->name, pkt->stream_index,
5028 codec->codec ? codec->codec->name : "copy");
5039 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5042 s->io_close(s, *pb);
5046 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5048 AVDictionaryEntry *entry;
5049 int64_t parsed_timestamp;
5051 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5052 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5053 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5056 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5063 int ff_standardize_creation_time(AVFormatContext *s)
5066 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5068 time_t seconds = timestamp / 1000000;
5069 struct tm *ptm, tmbuf;
5070 ptm = gmtime_r(&seconds, &tmbuf);
5073 if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
5074 return AVERROR_EXTERNAL;
5075 av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
5076 av_dict_set(&s->metadata, "creation_time", buf, 0);
5078 return AVERROR_EXTERNAL;
5084 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5089 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5091 if (size != AVPALETTE_SIZE) {
5092 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5093 return AVERROR_INVALIDDATA;
5095 memcpy(palette, side_data, AVPALETTE_SIZE);
5099 if (ret == CONTAINS_PAL) {
5101 for (i = 0; i < AVPALETTE_COUNT; i++)
5102 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5109 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5114 ret = av_bprint_finalize(buf, &str);
5117 if (!av_bprint_is_complete(buf)) {
5119 return AVERROR(ENOMEM);
5122 par->extradata = str;
5123 /* Note: the string is NUL terminated (so extradata can be read as a
5124 * string), but the ending character is not accounted in the size (in
5125 * binary formats you are likely not supposed to mux that character). When
5126 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5128 par->extradata_size = buf->len;