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 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
319 st->codecpar->sample_rate)
321 st->codecpar->codec_id = fmt_id_type[i].id;
322 st->codecpar->codec_type = fmt_id_type[i].type;
323 st->internal->need_context_update = 1;
324 #if FF_API_LAVF_AVCTX
325 FF_DISABLE_DEPRECATION_WARNINGS
326 st->codec->codec_type = st->codecpar->codec_type;
327 st->codec->codec_id = st->codecpar->codec_id;
328 FF_ENABLE_DEPRECATION_WARNINGS
337 /************************************************************/
338 /* input media file */
340 int av_demuxer_open(AVFormatContext *ic) {
343 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
344 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
345 return AVERROR(EINVAL);
348 if (ic->iformat->read_header) {
349 err = ic->iformat->read_header(ic);
354 if (ic->pb && !ic->internal->data_offset)
355 ic->internal->data_offset = avio_tell(ic->pb);
360 /* Open input file and probe the format if necessary. */
361 static int init_input(AVFormatContext *s, const char *filename,
362 AVDictionary **options)
365 AVProbeData pd = { filename, NULL, 0 };
366 int score = AVPROBE_SCORE_RETRY;
369 s->flags |= AVFMT_FLAG_CUSTOM_IO;
371 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
372 s, 0, s->format_probesize);
373 else if (s->iformat->flags & AVFMT_NOFILE)
374 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
375 "will be ignored with AVFMT_NOFILE format.\n");
379 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
380 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
383 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
388 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
389 s, 0, s->format_probesize);
392 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
393 AVPacketList **plast_pktl, int ref)
395 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
399 return AVERROR(ENOMEM);
402 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
411 (*plast_pktl)->next = pktl;
413 *packet_buffer = pktl;
415 /* Add the packet in the buffered packet list. */
420 int avformat_queue_attached_pictures(AVFormatContext *s)
423 for (i = 0; i < s->nb_streams; i++)
424 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
425 s->streams[i]->discard < AVDISCARD_ALL) {
426 if (s->streams[i]->attached_pic.size <= 0) {
427 av_log(s, AV_LOG_WARNING,
428 "Attached picture on stream %d has invalid size, "
433 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
434 &s->streams[i]->attached_pic,
435 &s->internal->raw_packet_buffer_end, 1);
442 static int update_stream_avctx(AVFormatContext *s)
445 for (i = 0; i < s->nb_streams; i++) {
446 AVStream *st = s->streams[i];
448 if (!st->internal->need_context_update)
451 /* update internal codec context, for the parser */
452 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
456 #if FF_API_LAVF_AVCTX
457 FF_DISABLE_DEPRECATION_WARNINGS
458 /* update deprecated public codec context */
459 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
462 FF_ENABLE_DEPRECATION_WARNINGS
465 st->internal->need_context_update = 0;
471 int avformat_open_input(AVFormatContext **ps, const char *filename,
472 AVInputFormat *fmt, AVDictionary **options)
474 AVFormatContext *s = *ps;
476 AVDictionary *tmp = NULL;
477 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
479 if (!s && !(s = avformat_alloc_context()))
480 return AVERROR(ENOMEM);
482 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
483 return AVERROR(EINVAL);
489 av_dict_copy(&tmp, *options, 0);
491 if (s->pb) // must be before any goto fail
492 s->flags |= AVFMT_FLAG_CUSTOM_IO;
494 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
497 if ((ret = init_input(s, filename, &tmp)) < 0)
499 s->probe_score = ret;
501 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
502 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
503 if (!s->protocol_whitelist) {
504 ret = AVERROR(ENOMEM);
509 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
510 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
511 if (!s->protocol_blacklist) {
512 ret = AVERROR(ENOMEM);
517 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
518 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
519 ret = AVERROR(EINVAL);
523 avio_skip(s->pb, s->skip_initial_bytes);
525 /* Check filename in case an image number is expected. */
526 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
527 if (!av_filename_number_test(filename)) {
528 ret = AVERROR(EINVAL);
533 s->duration = s->start_time = AV_NOPTS_VALUE;
534 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
536 /* Allocate private data. */
537 if (s->iformat->priv_data_size > 0) {
538 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
539 ret = AVERROR(ENOMEM);
542 if (s->iformat->priv_class) {
543 *(const AVClass **) s->priv_data = s->iformat->priv_class;
544 av_opt_set_defaults(s->priv_data);
545 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
550 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
552 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
554 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
555 if ((ret = s->iformat->read_header(s)) < 0)
558 if (id3v2_extra_meta) {
559 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
560 !strcmp(s->iformat->name, "tta")) {
561 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
564 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
566 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
568 if ((ret = avformat_queue_attached_pictures(s)) < 0)
571 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
572 s->internal->data_offset = avio_tell(s->pb);
574 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
576 update_stream_avctx(s);
578 for (i = 0; i < s->nb_streams; i++)
579 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
582 av_dict_free(options);
589 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
591 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
593 avformat_free_context(s);
598 /*******************************************************/
600 static void force_codec_ids(AVFormatContext *s, AVStream *st)
602 switch (st->codecpar->codec_type) {
603 case AVMEDIA_TYPE_VIDEO:
604 if (s->video_codec_id)
605 st->codecpar->codec_id = s->video_codec_id;
607 case AVMEDIA_TYPE_AUDIO:
608 if (s->audio_codec_id)
609 st->codecpar->codec_id = s->audio_codec_id;
611 case AVMEDIA_TYPE_SUBTITLE:
612 if (s->subtitle_codec_id)
613 st->codecpar->codec_id = s->subtitle_codec_id;
618 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
620 if (st->request_probe>0) {
621 AVProbeData *pd = &st->probe_data;
623 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
627 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
629 av_log(s, AV_LOG_WARNING,
630 "Failed to reallocate probe buffer for stream %d\n",
635 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
636 pd->buf_size += pkt->size;
637 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
640 st->probe_packets = 0;
642 av_log(s, AV_LOG_WARNING,
643 "nothing to probe for stream %d\n", st->index);
647 end= s->internal->raw_packet_buffer_remaining_size <= 0
648 || st->probe_packets<= 0;
650 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
651 int score = set_codec_from_probe_data(s, st, pd);
652 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
656 st->request_probe = -1;
657 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
658 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
660 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
662 force_codec_ids(s, st);
668 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
670 int64_t ref = pkt->dts;
671 int i, pts_wrap_behavior;
672 int64_t pts_wrap_reference;
673 AVProgram *first_program;
675 if (ref == AV_NOPTS_VALUE)
677 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
679 ref &= (1LL << st->pts_wrap_bits)-1;
681 // reference time stamp should be 60 s before first time stamp
682 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
683 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
684 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
685 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
686 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
688 first_program = av_find_program_from_stream(s, NULL, stream_index);
690 if (!first_program) {
691 int default_stream_index = av_find_default_stream_index(s);
692 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
693 for (i = 0; i < s->nb_streams; i++) {
694 if (av_find_program_from_stream(s, NULL, i))
696 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
697 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
701 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
702 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
706 AVProgram *program = first_program;
708 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
709 pts_wrap_reference = program->pts_wrap_reference;
710 pts_wrap_behavior = program->pts_wrap_behavior;
713 program = av_find_program_from_stream(s, program, stream_index);
716 // update every program with differing pts_wrap_reference
717 program = first_program;
719 if (program->pts_wrap_reference != pts_wrap_reference) {
720 for (i = 0; i<program->nb_stream_indexes; i++) {
721 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
722 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
725 program->pts_wrap_reference = pts_wrap_reference;
726 program->pts_wrap_behavior = pts_wrap_behavior;
728 program = av_find_program_from_stream(s, program, stream_index);
734 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
740 AVPacketList *pktl = s->internal->raw_packet_buffer;
744 st = s->streams[pkt->stream_index];
745 if (s->internal->raw_packet_buffer_remaining_size <= 0)
746 if ((err = probe_codec(s, st, NULL)) < 0)
748 if (st->request_probe <= 0) {
749 s->internal->raw_packet_buffer = pktl->next;
750 s->internal->raw_packet_buffer_remaining_size += pkt->size;
759 ret = s->iformat->read_packet(s, pkt);
761 /* Some demuxers return FFERROR_REDO when they consume
762 data and discard it (ignored streams, junk, extradata).
763 We must re-call the demuxer to get the real packet. */
764 if (ret == FFERROR_REDO)
766 if (!pktl || ret == AVERROR(EAGAIN))
768 for (i = 0; i < s->nb_streams; i++) {
770 if (st->probe_packets)
771 if ((err = probe_codec(s, st, NULL)) < 0)
773 av_assert0(st->request_probe <= 0);
779 AVPacket tmp = { 0 };
780 ret = av_packet_ref(&tmp, pkt);
786 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
787 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
788 av_log(s, AV_LOG_WARNING,
789 "Dropped corrupted packet (stream = %d)\n",
791 av_packet_unref(pkt);
795 if (pkt->stream_index >= (unsigned)s->nb_streams) {
796 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
800 st = s->streams[pkt->stream_index];
802 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
803 // correct first time stamps to negative values
804 if (!is_relative(st->first_dts))
805 st->first_dts = wrap_timestamp(st, st->first_dts);
806 if (!is_relative(st->start_time))
807 st->start_time = wrap_timestamp(st, st->start_time);
808 if (!is_relative(st->cur_dts))
809 st->cur_dts = wrap_timestamp(st, st->cur_dts);
812 pkt->dts = wrap_timestamp(st, pkt->dts);
813 pkt->pts = wrap_timestamp(st, pkt->pts);
815 force_codec_ids(s, st);
817 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
818 if (s->use_wallclock_as_timestamps)
819 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
821 if (!pktl && st->request_probe <= 0)
824 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
825 &s->internal->raw_packet_buffer_end, 0);
828 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
830 if ((err = probe_codec(s, st, pkt)) < 0)
836 /**********************************************************/
838 static int determinable_frame_size(AVCodecContext *avctx)
840 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
841 avctx->codec_id == AV_CODEC_ID_MP1 ||
842 avctx->codec_id == AV_CODEC_ID_MP2 ||
843 avctx->codec_id == AV_CODEC_ID_MP3/* ||
844 avctx->codec_id == AV_CODEC_ID_CELT*/)
850 * Return the frame duration in seconds. Return 0 if not available.
852 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
853 AVCodecParserContext *pc, AVPacket *pkt)
855 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
856 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
857 int frame_size, sample_rate;
859 #if FF_API_LAVF_AVCTX
860 FF_DISABLE_DEPRECATION_WARNINGS
861 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
862 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
863 FF_ENABLE_DEPRECATION_WARNINGS
868 switch (st->codecpar->codec_type) {
869 case AVMEDIA_TYPE_VIDEO:
870 if (st->r_frame_rate.num && !pc && s->iformat) {
871 *pnum = st->r_frame_rate.den;
872 *pden = st->r_frame_rate.num;
873 } else if (st->time_base.num * 1000LL > st->time_base.den) {
874 *pnum = st->time_base.num;
875 *pden = st->time_base.den;
876 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
877 av_assert0(st->internal->avctx->ticks_per_frame);
878 av_reduce(pnum, pden,
880 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
883 if (pc && pc->repeat_pict) {
884 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
885 av_reduce(pnum, pden,
886 (*pnum) * (1LL + pc->repeat_pict),
890 /* If this codec can be interlaced or progressive then we need
891 * a parser to compute duration of a packet. Thus if we have
892 * no parser in such case leave duration undefined. */
893 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
897 case AVMEDIA_TYPE_AUDIO:
898 if (st->internal->avctx_inited) {
899 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
900 sample_rate = st->internal->avctx->sample_rate;
902 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
903 sample_rate = st->codecpar->sample_rate;
905 if (frame_size <= 0 || sample_rate <= 0)
915 static int is_intra_only(enum AVCodecID id)
917 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
920 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
925 static int has_decode_delay_been_guessed(AVStream *st)
927 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
928 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
930 #if CONFIG_H264_DECODER
931 if (st->internal->avctx->has_b_frames &&
932 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
935 if (st->internal->avctx->has_b_frames<3)
936 return st->nb_decoded_frames >= 7;
937 else if (st->internal->avctx->has_b_frames<4)
938 return st->nb_decoded_frames >= 18;
940 return st->nb_decoded_frames >= 20;
943 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
947 if (pktl == s->internal->packet_buffer_end)
948 return s->internal->parse_queue;
952 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
953 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
954 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
957 int delay = st->internal->avctx->has_b_frames;
960 if (dts == AV_NOPTS_VALUE) {
961 int64_t best_score = INT64_MAX;
962 for (i = 0; i<delay; i++) {
963 if (st->pts_reorder_error_count[i]) {
964 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
965 if (score < best_score) {
972 for (i = 0; i<delay; i++) {
973 if (pts_buffer[i] != AV_NOPTS_VALUE) {
974 int64_t diff = FFABS(pts_buffer[i] - dts)
975 + (uint64_t)st->pts_reorder_error[i];
976 diff = FFMAX(diff, st->pts_reorder_error[i]);
977 st->pts_reorder_error[i] = diff;
978 st->pts_reorder_error_count[i]++;
979 if (st->pts_reorder_error_count[i] > 250) {
980 st->pts_reorder_error[i] >>= 1;
981 st->pts_reorder_error_count[i] >>= 1;
988 if (dts == AV_NOPTS_VALUE)
995 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
996 * of the packets in a window.
998 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
999 AVPacketList *pkt_buffer)
1001 AVStream *st = s->streams[stream_index];
1002 int delay = st->internal->avctx->has_b_frames;
1005 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1007 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1008 pts_buffer[i] = AV_NOPTS_VALUE;
1010 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1011 if (pkt_buffer->pkt.stream_index != stream_index)
1014 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1015 pts_buffer[0] = pkt_buffer->pkt.pts;
1016 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1017 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1019 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1024 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1025 int64_t dts, int64_t pts, AVPacket *pkt)
1027 AVStream *st = s->streams[stream_index];
1028 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1029 AVPacketList *pktl_it;
1033 if (st->first_dts != AV_NOPTS_VALUE ||
1034 dts == AV_NOPTS_VALUE ||
1035 st->cur_dts == AV_NOPTS_VALUE ||
1039 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1041 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1043 if (is_relative(pts))
1046 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1047 if (pktl_it->pkt.stream_index != stream_index)
1049 if (is_relative(pktl_it->pkt.pts))
1050 pktl_it->pkt.pts += shift;
1052 if (is_relative(pktl_it->pkt.dts))
1053 pktl_it->pkt.dts += shift;
1055 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1056 st->start_time = pktl_it->pkt.pts;
1057 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1058 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1062 if (has_decode_delay_been_guessed(st)) {
1063 update_dts_from_pts(s, stream_index, pktl);
1066 if (st->start_time == AV_NOPTS_VALUE) {
1067 st->start_time = pts;
1068 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1069 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1073 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1074 int stream_index, int duration)
1076 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1077 int64_t cur_dts = RELATIVE_TS_BASE;
1079 if (st->first_dts != AV_NOPTS_VALUE) {
1080 if (st->update_initial_durations_done)
1082 st->update_initial_durations_done = 1;
1083 cur_dts = st->first_dts;
1084 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1085 if (pktl->pkt.stream_index == stream_index) {
1086 if (pktl->pkt.pts != pktl->pkt.dts ||
1087 pktl->pkt.dts != AV_NOPTS_VALUE ||
1090 cur_dts -= duration;
1093 if (pktl && pktl->pkt.dts != st->first_dts) {
1094 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1095 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1099 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1102 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1103 st->first_dts = cur_dts;
1104 } else if (st->cur_dts != RELATIVE_TS_BASE)
1107 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1108 if (pktl->pkt.stream_index != stream_index)
1110 if (pktl->pkt.pts == pktl->pkt.dts &&
1111 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1112 !pktl->pkt.duration) {
1113 pktl->pkt.dts = cur_dts;
1114 if (!st->internal->avctx->has_b_frames)
1115 pktl->pkt.pts = cur_dts;
1116 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1117 pktl->pkt.duration = duration;
1120 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1123 st->cur_dts = cur_dts;
1126 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1127 AVCodecParserContext *pc, AVPacket *pkt,
1128 int64_t next_dts, int64_t next_pts)
1130 int num, den, presentation_delayed, delay, i;
1132 AVRational duration;
1133 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1134 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1136 if (s->flags & AVFMT_FLAG_NOFILLIN)
1139 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1140 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1141 if (st->last_dts_for_order_check <= pkt->dts) {
1144 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1145 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1147 st->last_dts_for_order_check);
1148 st->dts_misordered++;
1150 if (st->dts_ordered + st->dts_misordered > 250) {
1151 st->dts_ordered >>= 1;
1152 st->dts_misordered >>= 1;
1156 st->last_dts_for_order_check = pkt->dts;
1157 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1158 pkt->dts = AV_NOPTS_VALUE;
1161 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1162 pkt->dts = AV_NOPTS_VALUE;
1164 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1165 && !st->internal->avctx->has_b_frames)
1166 //FIXME Set low_delay = 0 when has_b_frames = 1
1167 st->internal->avctx->has_b_frames = 1;
1169 /* do we have a video B-frame ? */
1170 delay = st->internal->avctx->has_b_frames;
1171 presentation_delayed = 0;
1173 /* XXX: need has_b_frame, but cannot get it if the codec is
1174 * not initialized */
1176 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1177 presentation_delayed = 1;
1179 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1180 st->pts_wrap_bits < 63 &&
1181 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1182 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1183 pkt->dts -= 1LL << st->pts_wrap_bits;
1185 pkt->pts += 1LL << st->pts_wrap_bits;
1188 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1189 * We take the conservative approach and discard both.
1190 * Note: If this is misbehaving for an H.264 file, then possibly
1191 * presentation_delayed is not set correctly. */
1192 if (delay == 1 && pkt->dts == pkt->pts &&
1193 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1194 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1195 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1196 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1197 pkt->dts = AV_NOPTS_VALUE;
1200 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1201 if (pkt->duration == 0) {
1202 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1204 duration = (AVRational) {num, den};
1205 pkt->duration = av_rescale_rnd(1,
1206 num * (int64_t) st->time_base.den,
1207 den * (int64_t) st->time_base.num,
1212 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1213 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1215 /* Correct timestamps with byte offset if demuxers only have timestamps
1216 * on packet boundaries */
1217 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1218 /* this will estimate bitrate based on this frame's duration and size */
1219 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1220 if (pkt->pts != AV_NOPTS_VALUE)
1222 if (pkt->dts != AV_NOPTS_VALUE)
1226 /* This may be redundant, but it should not hurt. */
1227 if (pkt->dts != AV_NOPTS_VALUE &&
1228 pkt->pts != AV_NOPTS_VALUE &&
1229 pkt->pts > pkt->dts)
1230 presentation_delayed = 1;
1232 if (s->debug & FF_FDEBUG_TS)
1233 av_log(s, AV_LOG_TRACE,
1234 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1235 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1236 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1238 /* Interpolate PTS and DTS if they are not present. We skip H264
1239 * currently because delay and has_b_frames are not reliably set. */
1240 if ((delay == 0 || (delay == 1 && pc)) &&
1242 if (presentation_delayed) {
1243 /* DTS = decompression timestamp */
1244 /* PTS = presentation timestamp */
1245 if (pkt->dts == AV_NOPTS_VALUE)
1246 pkt->dts = st->last_IP_pts;
1247 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1248 if (pkt->dts == AV_NOPTS_VALUE)
1249 pkt->dts = st->cur_dts;
1251 /* This is tricky: the dts must be incremented by the duration
1252 * of the frame we are displaying, i.e. the last I- or P-frame. */
1253 if (st->last_IP_duration == 0)
1254 st->last_IP_duration = pkt->duration;
1255 if (pkt->dts != AV_NOPTS_VALUE)
1256 st->cur_dts = pkt->dts + st->last_IP_duration;
1257 if (pkt->dts != AV_NOPTS_VALUE &&
1258 pkt->pts == AV_NOPTS_VALUE &&
1259 st->last_IP_duration > 0 &&
1260 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1261 next_dts != next_pts &&
1262 next_pts != AV_NOPTS_VALUE)
1263 pkt->pts = next_dts;
1265 st->last_IP_duration = pkt->duration;
1266 st->last_IP_pts = pkt->pts;
1267 /* Cannot compute PTS if not present (we can compute it only
1268 * by knowing the future. */
1269 } else if (pkt->pts != AV_NOPTS_VALUE ||
1270 pkt->dts != AV_NOPTS_VALUE ||
1273 /* presentation is not delayed : PTS and DTS are the same */
1274 if (pkt->pts == AV_NOPTS_VALUE)
1275 pkt->pts = pkt->dts;
1276 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1278 if (pkt->pts == AV_NOPTS_VALUE)
1279 pkt->pts = st->cur_dts;
1280 pkt->dts = pkt->pts;
1281 if (pkt->pts != AV_NOPTS_VALUE)
1282 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1286 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1287 st->pts_buffer[0] = pkt->pts;
1288 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1289 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1291 if(has_decode_delay_been_guessed(st))
1292 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1294 // We skipped it above so we try here.
1296 // This should happen on the first packet
1297 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1298 if (pkt->dts > st->cur_dts)
1299 st->cur_dts = pkt->dts;
1301 if (s->debug & FF_FDEBUG_TS)
1302 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1303 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1306 if (is_intra_only(st->codecpar->codec_id))
1307 pkt->flags |= AV_PKT_FLAG_KEY;
1308 #if FF_API_CONVERGENCE_DURATION
1309 FF_DISABLE_DEPRECATION_WARNINGS
1311 pkt->convergence_duration = pc->convergence_duration;
1312 FF_ENABLE_DEPRECATION_WARNINGS
1316 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1319 AVPacketList *pktl = *pkt_buf;
1320 *pkt_buf = pktl->next;
1321 av_packet_unref(&pktl->pkt);
1324 *pkt_buf_end = NULL;
1328 * Parse a packet, add all split parts to parse_queue.
1330 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1332 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1334 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1335 AVStream *st = s->streams[stream_index];
1336 uint8_t *data = pkt ? pkt->data : NULL;
1337 int size = pkt ? pkt->size : 0;
1338 int ret = 0, got_output = 0;
1341 av_init_packet(&flush_pkt);
1344 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1345 // preserve 0-size sync packets
1346 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1349 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1351 int64_t next_pts = pkt->pts;
1352 int64_t next_dts = pkt->dts;
1354 av_init_packet(&out_pkt);
1355 len = av_parser_parse2(st->parser, st->internal->avctx,
1356 &out_pkt.data, &out_pkt.size, data, size,
1357 pkt->pts, pkt->dts, pkt->pos);
1359 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1361 /* increment read pointer */
1365 got_output = !!out_pkt.size;
1370 if (pkt->side_data) {
1371 out_pkt.side_data = pkt->side_data;
1372 out_pkt.side_data_elems = pkt->side_data_elems;
1373 pkt->side_data = NULL;
1374 pkt->side_data_elems = 0;
1377 /* set the duration */
1378 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1379 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1380 if (st->internal->avctx->sample_rate > 0) {
1382 av_rescale_q_rnd(st->parser->duration,
1383 (AVRational) { 1, st->internal->avctx->sample_rate },
1389 out_pkt.stream_index = st->index;
1390 out_pkt.pts = st->parser->pts;
1391 out_pkt.dts = st->parser->dts;
1392 out_pkt.pos = st->parser->pos;
1394 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1395 out_pkt.pos = st->parser->frame_offset;
1397 if (st->parser->key_frame == 1 ||
1398 (st->parser->key_frame == -1 &&
1399 st->parser->pict_type == AV_PICTURE_TYPE_I))
1400 out_pkt.flags |= AV_PKT_FLAG_KEY;
1402 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1403 out_pkt.flags |= AV_PKT_FLAG_KEY;
1405 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1407 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1408 &s->internal->parse_queue_end, 1);
1409 av_packet_unref(&out_pkt);
1414 /* end of the stream => close and free the parser */
1415 if (pkt == &flush_pkt) {
1416 av_parser_close(st->parser);
1421 av_packet_unref(pkt);
1425 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1426 AVPacketList **pkt_buffer_end,
1430 av_assert0(*pkt_buffer);
1433 *pkt_buffer = pktl->next;
1435 *pkt_buffer_end = NULL;
1440 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1442 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1445 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1447 int ret = 0, i, got_packet = 0;
1448 AVDictionary *metadata = NULL;
1450 av_init_packet(pkt);
1452 while (!got_packet && !s->internal->parse_queue) {
1456 /* read next packet */
1457 ret = ff_read_packet(s, &cur_pkt);
1459 if (ret == AVERROR(EAGAIN))
1461 /* flush the parsers */
1462 for (i = 0; i < s->nb_streams; i++) {
1464 if (st->parser && st->need_parsing)
1465 parse_packet(s, NULL, st->index);
1467 /* all remaining packets are now in parse_queue =>
1468 * really terminate parsing */
1472 st = s->streams[cur_pkt.stream_index];
1474 /* update context if required */
1475 if (st->internal->need_context_update) {
1476 if (avcodec_is_open(st->internal->avctx)) {
1477 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1478 avcodec_close(st->internal->avctx);
1479 st->info->found_decoder = 0;
1482 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1486 #if FF_API_LAVF_AVCTX
1487 FF_DISABLE_DEPRECATION_WARNINGS
1488 /* update deprecated public codec context */
1489 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1492 FF_ENABLE_DEPRECATION_WARNINGS
1495 st->internal->need_context_update = 0;
1498 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1499 cur_pkt.dts != AV_NOPTS_VALUE &&
1500 cur_pkt.pts < cur_pkt.dts) {
1501 av_log(s, AV_LOG_WARNING,
1502 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1503 cur_pkt.stream_index,
1504 av_ts2str(cur_pkt.pts),
1505 av_ts2str(cur_pkt.dts),
1508 if (s->debug & FF_FDEBUG_TS)
1509 av_log(s, AV_LOG_DEBUG,
1510 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1511 cur_pkt.stream_index,
1512 av_ts2str(cur_pkt.pts),
1513 av_ts2str(cur_pkt.dts),
1514 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1516 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1517 st->parser = av_parser_init(st->codecpar->codec_id);
1519 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1520 "%s, packets or times may be invalid.\n",
1521 avcodec_get_name(st->codecpar->codec_id));
1522 /* no parser available: just output the raw packets */
1523 st->need_parsing = AVSTREAM_PARSE_NONE;
1524 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1525 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1526 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1527 st->parser->flags |= PARSER_FLAG_ONCE;
1528 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1529 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1532 if (!st->need_parsing || !st->parser) {
1533 /* no parsing needed: we just output the packet as is */
1535 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1536 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1537 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1538 ff_reduce_index(s, st->index);
1539 av_add_index_entry(st, pkt->pos, pkt->dts,
1540 0, 0, AVINDEX_KEYFRAME);
1543 } else if (st->discard < AVDISCARD_ALL) {
1544 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1546 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1547 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1548 st->codecpar->channels = st->internal->avctx->channels;
1549 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1550 st->codecpar->codec_id = st->internal->avctx->codec_id;
1553 av_packet_unref(&cur_pkt);
1555 if (pkt->flags & AV_PKT_FLAG_KEY)
1556 st->skip_to_keyframe = 0;
1557 if (st->skip_to_keyframe) {
1558 av_packet_unref(&cur_pkt);
1566 if (!got_packet && s->internal->parse_queue)
1567 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1570 AVStream *st = s->streams[pkt->stream_index];
1571 int discard_padding = 0;
1572 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1573 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1574 int64_t sample = ts_to_samples(st, pts);
1575 int duration = ts_to_samples(st, pkt->duration);
1576 int64_t end_sample = sample + duration;
1577 if (duration > 0 && end_sample >= st->first_discard_sample &&
1578 sample < st->last_discard_sample)
1579 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1581 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1582 st->skip_samples = st->start_skip_samples;
1583 if (st->skip_samples || discard_padding) {
1584 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1586 AV_WL32(p, st->skip_samples);
1587 AV_WL32(p + 4, discard_padding);
1588 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1590 st->skip_samples = 0;
1593 if (st->inject_global_side_data) {
1594 for (i = 0; i < st->nb_side_data; i++) {
1595 AVPacketSideData *src_sd = &st->side_data[i];
1598 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1601 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1603 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1607 memcpy(dst_data, src_sd->data, src_sd->size);
1609 st->inject_global_side_data = 0;
1612 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1613 av_packet_merge_side_data(pkt);
1616 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1618 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1619 av_dict_copy(&s->metadata, metadata, 0);
1620 av_dict_free(&metadata);
1621 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1624 #if FF_API_LAVF_AVCTX
1625 update_stream_avctx(s);
1628 if (s->debug & FF_FDEBUG_TS)
1629 av_log(s, AV_LOG_DEBUG,
1630 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1631 "size=%d, duration=%"PRId64", flags=%d\n",
1633 av_ts2str(pkt->pts),
1634 av_ts2str(pkt->dts),
1635 pkt->size, pkt->duration, pkt->flags);
1640 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1642 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1648 ret = s->internal->packet_buffer
1649 ? read_from_packet_buffer(&s->internal->packet_buffer,
1650 &s->internal->packet_buffer_end, pkt)
1651 : read_frame_internal(s, pkt);
1658 AVPacketList *pktl = s->internal->packet_buffer;
1661 AVPacket *next_pkt = &pktl->pkt;
1663 if (next_pkt->dts != AV_NOPTS_VALUE) {
1664 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1665 // last dts seen for this stream. if any of packets following
1666 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1667 int64_t last_dts = next_pkt->dts;
1668 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1669 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1670 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1671 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1673 next_pkt->pts = pktl->pkt.dts;
1675 if (last_dts != AV_NOPTS_VALUE) {
1676 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1677 last_dts = pktl->pkt.dts;
1682 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1683 // Fixing the last reference frame had none pts issue (For MXF etc).
1684 // We only do this when
1686 // 2. we are not able to resolve a pts value for current packet.
1687 // 3. the packets for this stream at the end of the files had valid dts.
1688 next_pkt->pts = last_dts + next_pkt->duration;
1690 pktl = s->internal->packet_buffer;
1693 /* read packet from packet buffer, if there is data */
1694 st = s->streams[next_pkt->stream_index];
1695 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1696 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1697 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1698 &s->internal->packet_buffer_end, pkt);
1703 ret = read_frame_internal(s, pkt);
1705 if (pktl && ret != AVERROR(EAGAIN)) {
1712 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1713 &s->internal->packet_buffer_end, 1);
1714 av_packet_unref(pkt);
1721 st = s->streams[pkt->stream_index];
1722 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1723 ff_reduce_index(s, st->index);
1724 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1727 if (is_relative(pkt->dts))
1728 pkt->dts -= RELATIVE_TS_BASE;
1729 if (is_relative(pkt->pts))
1730 pkt->pts -= RELATIVE_TS_BASE;
1735 /* XXX: suppress the packet queue */
1736 static void flush_packet_queue(AVFormatContext *s)
1740 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1741 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1742 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1744 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1747 /*******************************************************/
1750 int av_find_default_stream_index(AVFormatContext *s)
1754 int best_stream = 0;
1755 int best_score = INT_MIN;
1757 if (s->nb_streams <= 0)
1759 for (i = 0; i < s->nb_streams; i++) {
1762 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1763 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1765 if (st->codecpar->width && st->codecpar->height)
1769 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1770 if (st->codecpar->sample_rate)
1773 if (st->codec_info_nb_frames)
1776 if (st->discard != AVDISCARD_ALL)
1779 if (score > best_score) {
1787 /** Flush the frame reader. */
1788 void ff_read_frame_flush(AVFormatContext *s)
1793 flush_packet_queue(s);
1795 /* Reset read state for each stream. */
1796 for (i = 0; i < s->nb_streams; i++) {
1800 av_parser_close(st->parser);
1803 st->last_IP_pts = AV_NOPTS_VALUE;
1804 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1805 if (st->first_dts == AV_NOPTS_VALUE)
1806 st->cur_dts = RELATIVE_TS_BASE;
1808 /* We set the current DTS to an unspecified origin. */
1809 st->cur_dts = AV_NOPTS_VALUE;
1811 st->probe_packets = MAX_PROBE_PACKETS;
1813 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1814 st->pts_buffer[j] = AV_NOPTS_VALUE;
1816 if (s->internal->inject_global_side_data)
1817 st->inject_global_side_data = 1;
1819 st->skip_samples = 0;
1823 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1827 for (i = 0; i < s->nb_streams; i++) {
1828 AVStream *st = s->streams[i];
1831 av_rescale(timestamp,
1832 st->time_base.den * (int64_t) ref_st->time_base.num,
1833 st->time_base.num * (int64_t) ref_st->time_base.den);
1837 void ff_reduce_index(AVFormatContext *s, int stream_index)
1839 AVStream *st = s->streams[stream_index];
1840 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1842 if ((unsigned) st->nb_index_entries >= max_entries) {
1844 for (i = 0; 2 * i < st->nb_index_entries; i++)
1845 st->index_entries[i] = st->index_entries[2 * i];
1846 st->nb_index_entries = i;
1850 int ff_add_index_entry(AVIndexEntry **index_entries,
1851 int *nb_index_entries,
1852 unsigned int *index_entries_allocated_size,
1853 int64_t pos, int64_t timestamp,
1854 int size, int distance, int flags)
1856 AVIndexEntry *entries, *ie;
1859 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1862 if (timestamp == AV_NOPTS_VALUE)
1863 return AVERROR(EINVAL);
1865 if (size < 0 || size > 0x3FFFFFFF)
1866 return AVERROR(EINVAL);
1868 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1869 timestamp -= RELATIVE_TS_BASE;
1871 entries = av_fast_realloc(*index_entries,
1872 index_entries_allocated_size,
1873 (*nb_index_entries + 1) *
1874 sizeof(AVIndexEntry));
1878 *index_entries = entries;
1880 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1881 timestamp, AVSEEK_FLAG_ANY);
1884 index = (*nb_index_entries)++;
1885 ie = &entries[index];
1886 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1888 ie = &entries[index];
1889 if (ie->timestamp != timestamp) {
1890 if (ie->timestamp <= timestamp)
1892 memmove(entries + index + 1, entries + index,
1893 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1894 (*nb_index_entries)++;
1895 } else if (ie->pos == pos && distance < ie->min_distance)
1896 // do not reduce the distance
1897 distance = ie->min_distance;
1901 ie->timestamp = timestamp;
1902 ie->min_distance = distance;
1909 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1910 int size, int distance, int flags)
1912 timestamp = wrap_timestamp(st, timestamp);
1913 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1914 &st->index_entries_allocated_size, pos,
1915 timestamp, size, distance, flags);
1918 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1919 int64_t wanted_timestamp, int flags)
1927 // Optimize appending index entries at the end.
1928 if (b && entries[b - 1].timestamp < wanted_timestamp)
1933 timestamp = entries[m].timestamp;
1934 if (timestamp >= wanted_timestamp)
1936 if (timestamp <= wanted_timestamp)
1939 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1941 if (!(flags & AVSEEK_FLAG_ANY))
1942 while (m >= 0 && m < nb_entries &&
1943 !(entries[m].flags & AVINDEX_KEYFRAME))
1944 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1946 if (m == nb_entries)
1951 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1954 int64_t pos_delta = 0;
1956 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1957 const char *proto = avio_find_protocol_name(s->filename);
1960 av_log(s, AV_LOG_INFO,
1961 "Protocol name not provided, cannot determine if input is local or "
1962 "a network protocol, buffers and access patterns cannot be configured "
1963 "optimally without knowing the protocol\n");
1966 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1969 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1970 AVStream *st1 = s->streams[ist1];
1971 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1972 AVStream *st2 = s->streams[ist2];
1978 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1979 AVIndexEntry *e1 = &st1->index_entries[i1];
1980 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1982 skip = FFMAX(skip, e1->size);
1983 for (; i2 < st2->nb_index_entries; i2++) {
1984 AVIndexEntry *e2 = &st2->index_entries[i2];
1985 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1986 if (e2_pts - e1_pts < time_tolerance)
1988 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1996 /* XXX This could be adjusted depending on protocol*/
1997 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1998 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1999 ffio_set_buf_size(s->pb, pos_delta);
2000 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2003 if (skip < (1<<23)) {
2004 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2008 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2010 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2011 wanted_timestamp, flags);
2014 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2015 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2017 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2018 if (stream_index >= 0)
2019 ts = wrap_timestamp(s->streams[stream_index], ts);
2023 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2024 int64_t target_ts, int flags)
2026 AVInputFormat *avif = s->iformat;
2027 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2028 int64_t ts_min, ts_max, ts;
2033 if (stream_index < 0)
2036 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2039 ts_min = AV_NOPTS_VALUE;
2040 pos_limit = -1; // GCC falsely says it may be uninitialized.
2042 st = s->streams[stream_index];
2043 if (st->index_entries) {
2046 /* FIXME: Whole function must be checked for non-keyframe entries in
2047 * index case, especially read_timestamp(). */
2048 index = av_index_search_timestamp(st, target_ts,
2049 flags | AVSEEK_FLAG_BACKWARD);
2050 index = FFMAX(index, 0);
2051 e = &st->index_entries[index];
2053 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2055 ts_min = e->timestamp;
2056 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2057 pos_min, av_ts2str(ts_min));
2059 av_assert1(index == 0);
2062 index = av_index_search_timestamp(st, target_ts,
2063 flags & ~AVSEEK_FLAG_BACKWARD);
2064 av_assert0(index < st->nb_index_entries);
2066 e = &st->index_entries[index];
2067 av_assert1(e->timestamp >= target_ts);
2069 ts_max = e->timestamp;
2070 pos_limit = pos_max - e->min_distance;
2071 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2072 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2076 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2077 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2082 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2085 ff_read_frame_flush(s);
2086 ff_update_cur_dts(s, st, ts);
2091 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2092 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2094 int64_t step = 1024;
2095 int64_t limit, ts_max;
2096 int64_t filesize = avio_size(s->pb);
2097 int64_t pos_max = filesize - 1;
2100 pos_max = FFMAX(0, (pos_max) - step);
2101 ts_max = ff_read_timestamp(s, stream_index,
2102 &pos_max, limit, read_timestamp);
2104 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2105 if (ts_max == AV_NOPTS_VALUE)
2109 int64_t tmp_pos = pos_max + 1;
2110 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2111 &tmp_pos, INT64_MAX, read_timestamp);
2112 if (tmp_ts == AV_NOPTS_VALUE)
2114 av_assert0(tmp_pos > pos_max);
2117 if (tmp_pos >= filesize)
2129 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2130 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2131 int64_t ts_min, int64_t ts_max,
2132 int flags, int64_t *ts_ret,
2133 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2134 int64_t *, int64_t))
2141 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2143 if (ts_min == AV_NOPTS_VALUE) {
2144 pos_min = s->internal->data_offset;
2145 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2146 if (ts_min == AV_NOPTS_VALUE)
2150 if (ts_min >= target_ts) {
2155 if (ts_max == AV_NOPTS_VALUE) {
2156 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2158 pos_limit = pos_max;
2161 if (ts_max <= target_ts) {
2166 av_assert0(ts_min < ts_max);
2169 while (pos_min < pos_limit) {
2170 av_log(s, AV_LOG_TRACE,
2171 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2172 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2173 av_assert0(pos_limit <= pos_max);
2175 if (no_change == 0) {
2176 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2177 // interpolate position (better than dichotomy)
2178 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2180 pos_min - approximate_keyframe_distance;
2181 } else if (no_change == 1) {
2182 // bisection if interpolation did not change min / max pos last time
2183 pos = (pos_min + pos_limit) >> 1;
2185 /* linear search if bisection failed, can only happen if there
2186 * are very few or no keyframes between min/max */
2191 else if (pos > pos_limit)
2195 // May pass pos_limit instead of -1.
2196 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2201 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2202 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2203 pos_min, pos, pos_max,
2204 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2205 pos_limit, start_pos, no_change);
2206 if (ts == AV_NOPTS_VALUE) {
2207 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2210 if (target_ts <= ts) {
2211 pos_limit = start_pos - 1;
2215 if (target_ts >= ts) {
2221 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2222 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2225 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2227 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2228 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2229 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2235 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2236 int64_t pos, int flags)
2238 int64_t pos_min, pos_max;
2240 pos_min = s->internal->data_offset;
2241 pos_max = avio_size(s->pb) - 1;
2245 else if (pos > pos_max)
2248 avio_seek(s->pb, pos, SEEK_SET);
2250 s->io_repositioned = 1;
2255 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2256 int64_t timestamp, int flags)
2263 st = s->streams[stream_index];
2265 index = av_index_search_timestamp(st, timestamp, flags);
2267 if (index < 0 && st->nb_index_entries &&
2268 timestamp < st->index_entries[0].timestamp)
2271 if (index < 0 || index == st->nb_index_entries - 1) {
2275 if (st->nb_index_entries) {
2276 av_assert0(st->index_entries);
2277 ie = &st->index_entries[st->nb_index_entries - 1];
2278 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2280 ff_update_cur_dts(s, st, ie->timestamp);
2282 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2288 read_status = av_read_frame(s, &pkt);
2289 } while (read_status == AVERROR(EAGAIN));
2290 if (read_status < 0)
2292 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2293 if (pkt.flags & AV_PKT_FLAG_KEY) {
2294 av_packet_unref(&pkt);
2297 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2298 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);
2299 av_packet_unref(&pkt);
2303 av_packet_unref(&pkt);
2305 index = av_index_search_timestamp(st, timestamp, flags);
2310 ff_read_frame_flush(s);
2311 if (s->iformat->read_seek)
2312 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2314 ie = &st->index_entries[index];
2315 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2317 ff_update_cur_dts(s, st, ie->timestamp);
2322 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2323 int64_t timestamp, int flags)
2328 if (flags & AVSEEK_FLAG_BYTE) {
2329 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2331 ff_read_frame_flush(s);
2332 return seek_frame_byte(s, stream_index, timestamp, flags);
2335 if (stream_index < 0) {
2336 stream_index = av_find_default_stream_index(s);
2337 if (stream_index < 0)
2340 st = s->streams[stream_index];
2341 /* timestamp for default must be expressed in AV_TIME_BASE units */
2342 timestamp = av_rescale(timestamp, st->time_base.den,
2343 AV_TIME_BASE * (int64_t) st->time_base.num);
2346 /* first, we try the format specific seek */
2347 if (s->iformat->read_seek) {
2348 ff_read_frame_flush(s);
2349 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2355 if (s->iformat->read_timestamp &&
2356 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2357 ff_read_frame_flush(s);
2358 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2359 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2360 ff_read_frame_flush(s);
2361 return seek_frame_generic(s, stream_index, timestamp, flags);
2366 int av_seek_frame(AVFormatContext *s, int stream_index,
2367 int64_t timestamp, int flags)
2371 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2372 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2373 if ((flags & AVSEEK_FLAG_BACKWARD))
2377 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2378 flags & ~AVSEEK_FLAG_BACKWARD);
2381 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2384 ret = avformat_queue_attached_pictures(s);
2389 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2390 int64_t ts, int64_t max_ts, int flags)
2392 if (min_ts > ts || max_ts < ts)
2394 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2395 return AVERROR(EINVAL);
2398 flags |= AVSEEK_FLAG_ANY;
2399 flags &= ~AVSEEK_FLAG_BACKWARD;
2401 if (s->iformat->read_seek2) {
2403 ff_read_frame_flush(s);
2405 if (stream_index == -1 && s->nb_streams == 1) {
2406 AVRational time_base = s->streams[0]->time_base;
2407 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2408 min_ts = av_rescale_rnd(min_ts, time_base.den,
2409 time_base.num * (int64_t)AV_TIME_BASE,
2410 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2411 max_ts = av_rescale_rnd(max_ts, time_base.den,
2412 time_base.num * (int64_t)AV_TIME_BASE,
2413 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2416 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2420 ret = avformat_queue_attached_pictures(s);
2424 if (s->iformat->read_timestamp) {
2425 // try to seek via read_timestamp()
2428 // Fall back on old API if new is not implemented but old is.
2429 // Note the old API has somewhat different semantics.
2430 if (s->iformat->read_seek || 1) {
2431 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2432 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2433 if (ret<0 && ts != min_ts && max_ts != ts) {
2434 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2436 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2441 // try some generic seek like seek_frame_generic() but with new ts semantics
2442 return -1; //unreachable
2445 int avformat_flush(AVFormatContext *s)
2447 ff_read_frame_flush(s);
2451 /*******************************************************/
2454 * Return TRUE if the stream has accurate duration in any stream.
2456 * @return TRUE if the stream has accurate duration for at least one component.
2458 static int has_duration(AVFormatContext *ic)
2463 for (i = 0; i < ic->nb_streams; i++) {
2464 st = ic->streams[i];
2465 if (st->duration != AV_NOPTS_VALUE)
2468 if (ic->duration != AV_NOPTS_VALUE)
2474 * Estimate the stream timings from the one of each components.
2476 * Also computes the global bitrate if possible.
2478 static void update_stream_timings(AVFormatContext *ic)
2480 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2481 int64_t duration, duration1, filesize;
2486 start_time = INT64_MAX;
2487 start_time_text = INT64_MAX;
2488 end_time = INT64_MIN;
2489 duration = INT64_MIN;
2490 for (i = 0; i < ic->nb_streams; i++) {
2491 st = ic->streams[i];
2492 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2493 start_time1 = av_rescale_q(st->start_time, st->time_base,
2495 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2496 if (start_time1 < start_time_text)
2497 start_time_text = start_time1;
2499 start_time = FFMIN(start_time, start_time1);
2500 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2502 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2503 if (end_time1 != AV_NOPTS_VALUE && start_time1 <= INT64_MAX - end_time1) {
2504 end_time1 += start_time1;
2505 end_time = FFMAX(end_time, end_time1);
2507 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2508 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2509 p->start_time = start_time1;
2510 if (p->end_time < end_time1)
2511 p->end_time = end_time1;
2514 if (st->duration != AV_NOPTS_VALUE) {
2515 duration1 = av_rescale_q(st->duration, st->time_base,
2517 duration = FFMAX(duration, duration1);
2520 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2521 start_time = start_time_text;
2522 else if (start_time > start_time_text)
2523 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2525 if (start_time != INT64_MAX) {
2526 ic->start_time = start_time;
2527 if (end_time != INT64_MIN) {
2528 if (ic->nb_programs) {
2529 for (i = 0; i < ic->nb_programs; i++) {
2530 p = ic->programs[i];
2531 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2532 duration = FFMAX(duration, p->end_time - p->start_time);
2535 duration = FFMAX(duration, end_time - start_time);
2538 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2539 ic->duration = duration;
2541 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2542 /* compute the bitrate */
2543 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2544 (double) ic->duration;
2545 if (bitrate >= 0 && bitrate <= INT64_MAX)
2546 ic->bit_rate = bitrate;
2550 static void fill_all_stream_timings(AVFormatContext *ic)
2555 update_stream_timings(ic);
2556 for (i = 0; i < ic->nb_streams; i++) {
2557 st = ic->streams[i];
2558 if (st->start_time == AV_NOPTS_VALUE) {
2559 if (ic->start_time != AV_NOPTS_VALUE)
2560 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2562 if (ic->duration != AV_NOPTS_VALUE)
2563 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2569 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2571 int64_t filesize, duration;
2572 int i, show_warning = 0;
2575 /* if bit_rate is already set, we believe it */
2576 if (ic->bit_rate <= 0) {
2577 int64_t bit_rate = 0;
2578 for (i = 0; i < ic->nb_streams; i++) {
2579 st = ic->streams[i];
2580 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2581 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2582 if (st->codecpar->bit_rate > 0) {
2583 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2587 bit_rate += st->codecpar->bit_rate;
2588 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2589 // If we have a videostream with packets but without a bitrate
2590 // then consider the sum not known
2595 ic->bit_rate = bit_rate;
2598 /* if duration is already set, we believe it */
2599 if (ic->duration == AV_NOPTS_VALUE &&
2600 ic->bit_rate != 0) {
2601 filesize = ic->pb ? avio_size(ic->pb) : 0;
2602 if (filesize > ic->internal->data_offset) {
2603 filesize -= ic->internal->data_offset;
2604 for (i = 0; i < ic->nb_streams; i++) {
2605 st = ic->streams[i];
2606 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2607 && st->duration == AV_NOPTS_VALUE) {
2608 duration = av_rescale(8 * filesize, st->time_base.den,
2610 (int64_t) st->time_base.num);
2611 st->duration = duration;
2618 av_log(ic, AV_LOG_WARNING,
2619 "Estimating duration from bitrate, this may be inaccurate\n");
2622 #define DURATION_MAX_READ_SIZE 250000LL
2623 #define DURATION_MAX_RETRY 6
2625 /* only usable for MPEG-PS streams */
2626 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2628 AVPacket pkt1, *pkt = &pkt1;
2630 int num, den, read_size, i, ret;
2631 int found_duration = 0;
2633 int64_t filesize, offset, duration;
2636 /* flush packet queue */
2637 flush_packet_queue(ic);
2639 for (i = 0; i < ic->nb_streams; i++) {
2640 st = ic->streams[i];
2641 if (st->start_time == AV_NOPTS_VALUE &&
2642 st->first_dts == AV_NOPTS_VALUE &&
2643 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2644 av_log(ic, AV_LOG_WARNING,
2645 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2648 av_parser_close(st->parser);
2653 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2654 /* estimate the end time (duration) */
2655 /* XXX: may need to support wrapping */
2656 filesize = ic->pb ? avio_size(ic->pb) : 0;
2658 is_end = found_duration;
2659 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2663 avio_seek(ic->pb, offset, SEEK_SET);
2666 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2670 ret = ff_read_packet(ic, pkt);
2671 } while (ret == AVERROR(EAGAIN));
2674 read_size += pkt->size;
2675 st = ic->streams[pkt->stream_index];
2676 if (pkt->pts != AV_NOPTS_VALUE &&
2677 (st->start_time != AV_NOPTS_VALUE ||
2678 st->first_dts != AV_NOPTS_VALUE)) {
2679 if (pkt->duration == 0) {
2680 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2682 pkt->duration = av_rescale_rnd(1,
2683 num * (int64_t) st->time_base.den,
2684 den * (int64_t) st->time_base.num,
2688 duration = pkt->pts + pkt->duration;
2690 if (st->start_time != AV_NOPTS_VALUE)
2691 duration -= st->start_time;
2693 duration -= st->first_dts;
2695 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2696 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2697 st->duration = duration;
2698 st->info->last_duration = duration;
2701 av_packet_unref(pkt);
2704 /* check if all audio/video streams have valid duration */
2707 for (i = 0; i < ic->nb_streams; i++) {
2708 st = ic->streams[i];
2709 switch (st->codecpar->codec_type) {
2710 case AVMEDIA_TYPE_VIDEO:
2711 case AVMEDIA_TYPE_AUDIO:
2712 if (st->duration == AV_NOPTS_VALUE)
2719 ++retry <= DURATION_MAX_RETRY);
2721 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2723 /* warn about audio/video streams which duration could not be estimated */
2724 for (i = 0; i < ic->nb_streams; i++) {
2725 st = ic->streams[i];
2726 if (st->duration == AV_NOPTS_VALUE) {
2727 switch (st->codecpar->codec_type) {
2728 case AVMEDIA_TYPE_VIDEO:
2729 case AVMEDIA_TYPE_AUDIO:
2730 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2731 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2733 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2737 fill_all_stream_timings(ic);
2739 avio_seek(ic->pb, old_offset, SEEK_SET);
2740 for (i = 0; i < ic->nb_streams; i++) {
2743 st = ic->streams[i];
2744 st->cur_dts = st->first_dts;
2745 st->last_IP_pts = AV_NOPTS_VALUE;
2746 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2747 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2748 st->pts_buffer[j] = AV_NOPTS_VALUE;
2752 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2756 /* get the file size, if possible */
2757 if (ic->iformat->flags & AVFMT_NOFILE) {
2760 file_size = avio_size(ic->pb);
2761 file_size = FFMAX(0, file_size);
2764 if ((!strcmp(ic->iformat->name, "mpeg") ||
2765 !strcmp(ic->iformat->name, "mpegts")) &&
2766 file_size && ic->pb->seekable) {
2767 /* get accurate estimate from the PTSes */
2768 estimate_timings_from_pts(ic, old_offset);
2769 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2770 } else if (has_duration(ic)) {
2771 /* at least one component has timings - we use them for all
2773 fill_all_stream_timings(ic);
2774 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2776 /* less precise: use bitrate info */
2777 estimate_timings_from_bit_rate(ic);
2778 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2780 update_stream_timings(ic);
2784 AVStream av_unused *st;
2785 for (i = 0; i < ic->nb_streams; i++) {
2786 st = ic->streams[i];
2787 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2788 (double) st->start_time * av_q2d(st->time_base),
2789 (double) st->duration * av_q2d(st->time_base));
2791 av_log(ic, AV_LOG_TRACE,
2792 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2793 (double) ic->start_time / AV_TIME_BASE,
2794 (double) ic->duration / AV_TIME_BASE,
2795 (int64_t)ic->bit_rate / 1000);
2799 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2801 AVCodecContext *avctx = st->internal->avctx;
2803 #define FAIL(errmsg) do { \
2805 *errmsg_ptr = errmsg; \
2809 if ( avctx->codec_id == AV_CODEC_ID_NONE
2810 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2811 FAIL("unknown codec");
2812 switch (avctx->codec_type) {
2813 case AVMEDIA_TYPE_AUDIO:
2814 if (!avctx->frame_size && determinable_frame_size(avctx))
2815 FAIL("unspecified frame size");
2816 if (st->info->found_decoder >= 0 &&
2817 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2818 FAIL("unspecified sample format");
2819 if (!avctx->sample_rate)
2820 FAIL("unspecified sample rate");
2821 if (!avctx->channels)
2822 FAIL("unspecified number of channels");
2823 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2824 FAIL("no decodable DTS frames");
2826 case AVMEDIA_TYPE_VIDEO:
2828 FAIL("unspecified size");
2829 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2830 FAIL("unspecified pixel format");
2831 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2832 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2833 FAIL("no frame in rv30/40 and no sar");
2835 case AVMEDIA_TYPE_SUBTITLE:
2836 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2837 FAIL("unspecified size");
2839 case AVMEDIA_TYPE_DATA:
2840 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2846 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2847 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2848 AVDictionary **options)
2850 AVCodecContext *avctx = st->internal->avctx;
2851 const AVCodec *codec;
2852 int got_picture = 1, ret = 0;
2853 AVFrame *frame = av_frame_alloc();
2854 AVSubtitle subtitle;
2855 AVPacket pkt = *avpkt;
2856 int do_skip_frame = 0;
2857 enum AVDiscard skip_frame;
2860 return AVERROR(ENOMEM);
2862 if (!avcodec_is_open(avctx) &&
2863 st->info->found_decoder <= 0 &&
2864 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2865 AVDictionary *thread_opt = NULL;
2867 codec = find_decoder(s, st, st->codecpar->codec_id);
2870 st->info->found_decoder = -st->codecpar->codec_id;
2875 /* Force thread count to 1 since the H.264 decoder will not extract
2876 * SPS and PPS to extradata during multi-threaded decoding. */
2877 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2878 if (s->codec_whitelist)
2879 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2880 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2882 av_dict_free(&thread_opt);
2884 st->info->found_decoder = -avctx->codec_id;
2887 st->info->found_decoder = 1;
2888 } else if (!st->info->found_decoder)
2889 st->info->found_decoder = 1;
2891 if (st->info->found_decoder < 0) {
2896 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2898 skip_frame = avctx->skip_frame;
2899 avctx->skip_frame = AVDISCARD_ALL;
2902 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2904 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2905 (!st->codec_info_nb_frames &&
2906 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2908 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2909 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2910 ret = avcodec_send_packet(avctx, &pkt);
2911 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2915 ret = avcodec_receive_frame(avctx, frame);
2918 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2920 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2921 ret = avcodec_decode_subtitle2(avctx, &subtitle,
2922 &got_picture, &pkt);
2928 st->nb_decoded_frames++;
2933 if (!pkt.data && !got_picture)
2937 if (do_skip_frame) {
2938 avctx->skip_frame = skip_frame;
2941 av_frame_free(&frame);
2945 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2947 while (tags->id != AV_CODEC_ID_NONE) {
2955 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2958 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2959 if (tag == tags[i].tag)
2961 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2962 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2964 return AV_CODEC_ID_NONE;
2967 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2969 if (bps <= 0 || bps > 64)
2970 return AV_CODEC_ID_NONE;
2975 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2977 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2979 return AV_CODEC_ID_NONE;
2984 if (sflags & (1 << (bps - 1))) {
2987 return AV_CODEC_ID_PCM_S8;
2989 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2991 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2993 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2995 return AV_CODEC_ID_NONE;
3000 return AV_CODEC_ID_PCM_U8;
3002 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3004 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3006 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3008 return AV_CODEC_ID_NONE;
3014 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3017 if (!av_codec_get_tag2(tags, id, &tag))
3022 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3026 for (i = 0; tags && tags[i]; i++) {
3027 const AVCodecTag *codec_tags = tags[i];
3028 while (codec_tags->id != AV_CODEC_ID_NONE) {
3029 if (codec_tags->id == id) {
3030 *tag = codec_tags->tag;
3039 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3042 for (i = 0; tags && tags[i]; i++) {
3043 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3044 if (id != AV_CODEC_ID_NONE)
3047 return AV_CODEC_ID_NONE;
3050 static void compute_chapters_end(AVFormatContext *s)
3053 int64_t max_time = 0;
3055 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3056 max_time = s->duration +
3057 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3059 for (i = 0; i < s->nb_chapters; i++)
3060 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3061 AVChapter *ch = s->chapters[i];
3062 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3066 for (j = 0; j < s->nb_chapters; j++) {
3067 AVChapter *ch1 = s->chapters[j];
3068 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3070 if (j != i && next_start > ch->start && next_start < end)
3073 ch->end = (end == INT64_MAX) ? ch->start : end;
3077 static int get_std_framerate(int i)
3080 return (i + 1) * 1001;
3084 return (i + 31) * 1001 * 12;
3088 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3092 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3095 /* Is the time base unreliable?
3096 * This is a heuristic to balance between quick acceptance of the values in
3097 * the headers vs. some extra checks.
3098 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3099 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3100 * And there are "variable" fps files this needs to detect as well. */
3101 static int tb_unreliable(AVCodecContext *c)
3103 if (c->time_base.den >= 101LL * c->time_base.num ||
3104 c->time_base.den < 5LL * c->time_base.num ||
3105 // c->codec_tag == AV_RL32("DIVX") ||
3106 // c->codec_tag == AV_RL32("XVID") ||
3107 c->codec_tag == AV_RL32("mp4v") ||
3108 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3109 c->codec_id == AV_CODEC_ID_GIF ||
3110 c->codec_id == AV_CODEC_ID_HEVC ||
3111 c->codec_id == AV_CODEC_ID_H264)
3116 int ff_alloc_extradata(AVCodecParameters *par, int size)
3120 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3121 par->extradata = NULL;
3122 par->extradata_size = 0;
3123 return AVERROR(EINVAL);
3125 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3126 if (par->extradata) {
3127 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3128 par->extradata_size = size;
3131 par->extradata_size = 0;
3132 ret = AVERROR(ENOMEM);
3137 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3139 int ret = ff_alloc_extradata(par, size);
3142 ret = avio_read(pb, par->extradata, size);
3144 av_freep(&par->extradata);
3145 par->extradata_size = 0;
3146 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3147 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3153 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3156 int64_t last = st->info->last_dts;
3158 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3159 && ts - (uint64_t)last < INT64_MAX) {
3160 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3161 int64_t duration = ts - last;
3163 if (!st->info->duration_error)
3164 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3165 if (!st->info->duration_error)
3166 return AVERROR(ENOMEM);
3168 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3169 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3170 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3171 if (st->info->duration_error[0][1][i] < 1e10) {
3172 int framerate = get_std_framerate(i);
3173 double sdts = dts*framerate/(1001*12);
3174 for (j= 0; j<2; j++) {
3175 int64_t ticks = llrint(sdts+j*0.5);
3176 double error= sdts - ticks + j*0.5;
3177 st->info->duration_error[j][0][i] += error;
3178 st->info->duration_error[j][1][i] += error*error;
3182 st->info->duration_count++;
3183 st->info->rfps_duration_sum += duration;
3185 if (st->info->duration_count % 10 == 0) {
3186 int n = st->info->duration_count;
3187 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3188 if (st->info->duration_error[0][1][i] < 1e10) {
3189 double a0 = st->info->duration_error[0][0][i] / n;
3190 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3191 double a1 = st->info->duration_error[1][0][i] / n;
3192 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3193 if (error0 > 0.04 && error1 > 0.04) {
3194 st->info->duration_error[0][1][i] = 2e10;
3195 st->info->duration_error[1][1][i] = 2e10;
3201 // ignore the first 4 values, they might have some random jitter
3202 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3203 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3205 if (ts != AV_NOPTS_VALUE)
3206 st->info->last_dts = ts;
3211 void ff_rfps_calculate(AVFormatContext *ic)
3215 for (i = 0; i < ic->nb_streams; i++) {
3216 AVStream *st = ic->streams[i];
3218 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3220 // the check for tb_unreliable() is not completely correct, since this is not about handling
3221 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3222 // ipmovie.c produces.
3223 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)
3224 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);
3225 if (st->info->duration_count>1 && !st->r_frame_rate.num
3226 && tb_unreliable(st->internal->avctx)) {
3228 double best_error= 0.01;
3229 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3231 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3234 if (st->info->codec_info_duration &&
3235 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3237 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3240 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3243 for (k= 0; k<2; k++) {
3244 int n = st->info->duration_count;
3245 double a= st->info->duration_error[k][0][j] / n;
3246 double error= st->info->duration_error[k][1][j]/n - a*a;
3248 if (error < best_error && best_error> 0.000000001) {
3250 num = get_std_framerate(j);
3253 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3256 // do not increase frame rate by more than 1 % in order to match a standard rate.
3257 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3258 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3260 if ( !st->avg_frame_rate.num
3261 && st->r_frame_rate.num && st->info->rfps_duration_sum
3262 && st->info->codec_info_duration <= 0
3263 && st->info->duration_count > 2
3264 && 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
3266 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3267 st->avg_frame_rate = st->r_frame_rate;
3270 av_freep(&st->info->duration_error);
3271 st->info->last_dts = AV_NOPTS_VALUE;
3272 st->info->duration_count = 0;
3273 st->info->rfps_duration_sum = 0;
3277 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3279 int i, count = 0, ret = 0, j;
3282 AVCodecContext *avctx;
3283 AVPacket pkt1, *pkt;
3284 int64_t old_offset = avio_tell(ic->pb);
3285 // new streams might appear, no options for those
3286 int orig_nb_streams = ic->nb_streams;
3288 int64_t max_analyze_duration = ic->max_analyze_duration;
3289 int64_t max_stream_analyze_duration;
3290 int64_t max_subtitle_analyze_duration;
3291 int64_t probesize = ic->probesize;
3292 int eof_reached = 0;
3294 flush_codecs = probesize > 0;
3296 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3298 max_stream_analyze_duration = max_analyze_duration;
3299 max_subtitle_analyze_duration = max_analyze_duration;
3300 if (!max_analyze_duration) {
3301 max_stream_analyze_duration =
3302 max_analyze_duration = 5*AV_TIME_BASE;
3303 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3304 if (!strcmp(ic->iformat->name, "flv"))
3305 max_stream_analyze_duration = 90*AV_TIME_BASE;
3306 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3307 max_stream_analyze_duration = 7*AV_TIME_BASE;
3311 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3312 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3314 for (i = 0; i < ic->nb_streams; i++) {
3315 const AVCodec *codec;
3316 AVDictionary *thread_opt = NULL;
3317 st = ic->streams[i];
3318 avctx = st->internal->avctx;
3320 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3321 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3322 /* if (!st->time_base.num)
3324 if (!avctx->time_base.num)
3325 avctx->time_base = st->time_base;
3327 // only for the split stuff
3328 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3329 st->parser = av_parser_init(st->codecpar->codec_id);
3331 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3332 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3333 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3334 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3336 } else if (st->need_parsing) {
3337 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3338 "%s, packets or times may be invalid.\n",
3339 avcodec_get_name(st->codecpar->codec_id));
3343 /* check if the caller has overridden the codec id */
3344 #if FF_API_LAVF_AVCTX
3345 FF_DISABLE_DEPRECATION_WARNINGS
3346 if (st->codec->codec_id != st->internal->orig_codec_id) {
3347 st->codecpar->codec_id = st->codec->codec_id;
3348 st->codecpar->codec_type = st->codec->codec_type;
3349 st->internal->orig_codec_id = st->codec->codec_id;
3351 FF_ENABLE_DEPRECATION_WARNINGS
3353 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3354 st->internal->orig_codec_id = st->codecpar->codec_id;
3356 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3358 goto find_stream_info_err;
3359 if (st->request_probe <= 0)
3360 st->internal->avctx_inited = 1;
3362 codec = find_decoder(ic, st, st->codecpar->codec_id);
3364 /* Force thread count to 1 since the H.264 decoder will not extract
3365 * SPS and PPS to extradata during multi-threaded decoding. */
3366 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3368 if (ic->codec_whitelist)
3369 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3371 /* Ensure that subtitle_header is properly set. */
3372 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3373 && codec && !avctx->codec) {
3374 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3375 av_log(ic, AV_LOG_WARNING,
3376 "Failed to open codec in av_find_stream_info\n");
3379 // Try to just open decoders, in case this is enough to get parameters.
3380 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3381 if (codec && !avctx->codec)
3382 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3383 av_log(ic, AV_LOG_WARNING,
3384 "Failed to open codec in av_find_stream_info\n");
3387 av_dict_free(&thread_opt);
3390 for (i = 0; i < ic->nb_streams; i++) {
3391 #if FF_API_R_FRAME_RATE
3392 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3394 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3395 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3400 int analyzed_all_streams;
3401 if (ff_check_interrupt(&ic->interrupt_callback)) {
3403 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3407 /* check if one codec still needs to be handled */
3408 for (i = 0; i < ic->nb_streams; i++) {
3409 int fps_analyze_framecount = 20;
3411 st = ic->streams[i];
3412 if (!has_codec_parameters(st, NULL))
3414 /* If the timebase is coarse (like the usual millisecond precision
3415 * of mkv), we need to analyze more frames to reliably arrive at
3416 * the correct fps. */
3417 if (av_q2d(st->time_base) > 0.0005)
3418 fps_analyze_framecount *= 2;
3419 if (!tb_unreliable(st->internal->avctx))
3420 fps_analyze_framecount = 0;
3421 if (ic->fps_probe_size >= 0)
3422 fps_analyze_framecount = ic->fps_probe_size;
3423 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3424 fps_analyze_framecount = 0;
3425 /* variable fps and no guess at the real fps */
3426 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3427 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3428 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3429 st->info->codec_info_duration_fields/2 :
3430 st->info->duration_count;
3431 if (count < fps_analyze_framecount)
3434 if (st->parser && st->parser->parser->split &&
3435 !st->internal->avctx->extradata)
3437 if (st->first_dts == AV_NOPTS_VALUE &&
3438 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3439 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3440 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3441 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3444 analyzed_all_streams = 0;
3445 if (i == ic->nb_streams) {
3446 analyzed_all_streams = 1;
3447 /* NOTE: If the format has no header, then we need to read some
3448 * packets to get most of the streams, so we cannot stop here. */
3449 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3450 /* If we found the info for all the codecs, we can stop. */
3452 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3457 /* We did not get all the codec info, but we read too much data. */
3458 if (read_size >= probesize) {
3460 av_log(ic, AV_LOG_DEBUG,
3461 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3462 for (i = 0; i < ic->nb_streams; i++)
3463 if (!ic->streams[i]->r_frame_rate.num &&
3464 ic->streams[i]->info->duration_count <= 1 &&
3465 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3466 strcmp(ic->iformat->name, "image2"))
3467 av_log(ic, AV_LOG_WARNING,
3468 "Stream #%d: not enough frames to estimate rate; "
3469 "consider increasing probesize\n", i);
3473 /* NOTE: A new stream can be added there if no header in file
3474 * (AVFMTCTX_NOHEADER). */
3475 ret = read_frame_internal(ic, &pkt1);
3476 if (ret == AVERROR(EAGAIN))
3487 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3488 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3489 &ic->internal->packet_buffer_end, 0);
3491 goto find_stream_info_err;
3494 st = ic->streams[pkt->stream_index];
3495 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3496 read_size += pkt->size;
3498 avctx = st->internal->avctx;
3499 if (!st->internal->avctx_inited) {
3500 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3502 goto find_stream_info_err;
3503 st->internal->avctx_inited = 1;
3506 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3507 /* check for non-increasing dts */
3508 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3509 st->info->fps_last_dts >= pkt->dts) {
3510 av_log(ic, AV_LOG_DEBUG,
3511 "Non-increasing DTS in stream %d: packet %d with DTS "
3512 "%"PRId64", packet %d with DTS %"PRId64"\n",
3513 st->index, st->info->fps_last_dts_idx,
3514 st->info->fps_last_dts, st->codec_info_nb_frames,
3516 st->info->fps_first_dts =
3517 st->info->fps_last_dts = AV_NOPTS_VALUE;
3519 /* Check for a discontinuity in dts. If the difference in dts
3520 * is more than 1000 times the average packet duration in the
3521 * sequence, we treat it as a discontinuity. */
3522 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3523 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3524 (pkt->dts - st->info->fps_last_dts) / 1000 >
3525 (st->info->fps_last_dts - st->info->fps_first_dts) /
3526 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3527 av_log(ic, AV_LOG_WARNING,
3528 "DTS discontinuity in stream %d: packet %d with DTS "
3529 "%"PRId64", packet %d with DTS %"PRId64"\n",
3530 st->index, st->info->fps_last_dts_idx,
3531 st->info->fps_last_dts, st->codec_info_nb_frames,
3533 st->info->fps_first_dts =
3534 st->info->fps_last_dts = AV_NOPTS_VALUE;
3537 /* update stored dts values */
3538 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3539 st->info->fps_first_dts = pkt->dts;
3540 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3542 st->info->fps_last_dts = pkt->dts;
3543 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3545 if (st->codec_info_nb_frames>1) {
3549 if (st->time_base.den > 0)
3550 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3551 if (st->avg_frame_rate.num > 0)
3552 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3555 && st->codec_info_nb_frames>30
3556 && st->info->fps_first_dts != AV_NOPTS_VALUE
3557 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3558 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3560 if (analyzed_all_streams) limit = max_analyze_duration;
3561 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3562 else limit = max_stream_analyze_duration;
3565 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3567 t, pkt->stream_index);
3568 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3569 av_packet_unref(pkt);
3572 if (pkt->duration) {
3573 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3574 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3576 st->info->codec_info_duration += pkt->duration;
3577 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3580 #if FF_API_R_FRAME_RATE
3581 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3582 ff_rfps_add_frame(ic, st, pkt->dts);
3584 if (st->parser && st->parser->parser->split && !avctx->extradata) {
3585 int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3586 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3587 avctx->extradata_size = i;
3588 avctx->extradata = av_mallocz(avctx->extradata_size +
3589 AV_INPUT_BUFFER_PADDING_SIZE);
3590 if (!avctx->extradata)
3591 return AVERROR(ENOMEM);
3592 memcpy(avctx->extradata, pkt->data,
3593 avctx->extradata_size);
3597 /* If still no information, we try to open the codec and to
3598 * decompress the frame. We try to avoid that in most cases as
3599 * it takes longer and uses more memory. For MPEG-4, we need to
3600 * decompress for QuickTime.
3602 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3603 * least one frame of codec data, this makes sure the codec initializes
3604 * the channel configuration and does not only trust the values from
3606 try_decode_frame(ic, st, pkt,
3607 (options && i < orig_nb_streams) ? &options[i] : NULL);
3609 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3610 av_packet_unref(pkt);
3612 st->codec_info_nb_frames++;
3618 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3619 st = ic->streams[stream_index];
3620 avctx = st->internal->avctx;
3621 if (!has_codec_parameters(st, NULL)) {
3622 const AVCodec *codec = find_decoder(ic, st, st->codecpar->codec_id);
3623 if (codec && !avctx->codec) {
3624 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : NULL) < 0)
3625 av_log(ic, AV_LOG_WARNING,
3626 "Failed to open codec in av_find_stream_info\n");
3630 // EOF already reached while reading the stream above.
3631 // So continue with reoordering DTS with whatever delay we have.
3632 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3633 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3639 AVPacket empty_pkt = { 0 };
3641 av_init_packet(&empty_pkt);
3643 for (i = 0; i < ic->nb_streams; i++) {
3645 st = ic->streams[i];
3647 /* flush the decoders */
3648 if (st->info->found_decoder == 1) {
3650 err = try_decode_frame(ic, st, &empty_pkt,
3651 (options && i < orig_nb_streams)
3652 ? &options[i] : NULL);
3653 } while (err > 0 && !has_codec_parameters(st, NULL));
3656 av_log(ic, AV_LOG_INFO,
3657 "decoding for stream %d failed\n", st->index);
3663 // close codecs which were opened in try_decode_frame()
3664 for (i = 0; i < ic->nb_streams; i++) {
3665 st = ic->streams[i];
3666 avcodec_close(st->internal->avctx);
3669 ff_rfps_calculate(ic);
3671 for (i = 0; i < ic->nb_streams; i++) {
3672 st = ic->streams[i];
3673 avctx = st->internal->avctx;
3674 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3675 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3676 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3677 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3678 avctx->codec_tag= tag;
3681 /* estimate average framerate if not set by demuxer */
3682 if (st->info->codec_info_duration_fields &&
3683 !st->avg_frame_rate.num &&
3684 st->info->codec_info_duration) {
3686 double best_error = 0.01;
3688 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3689 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3690 st->info->codec_info_duration < 0)
3692 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3693 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3694 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3696 /* Round guessed framerate to a "standard" framerate if it's
3697 * within 1% of the original estimate. */
3698 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3699 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3700 double error = fabs(av_q2d(st->avg_frame_rate) /
3701 av_q2d(std_fps) - 1);
3703 if (error < best_error) {
3705 best_fps = std_fps.num;
3709 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3710 best_fps, 12 * 1001, INT_MAX);
3713 if (!st->r_frame_rate.num) {
3714 if ( avctx->time_base.den * (int64_t) st->time_base.num
3715 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3716 st->r_frame_rate.num = avctx->time_base.den;
3717 st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3719 st->r_frame_rate.num = st->time_base.den;
3720 st->r_frame_rate.den = st->time_base.num;
3723 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3724 AVRational hw_ratio = { avctx->height, avctx->width };
3725 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3728 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3729 if (!avctx->bits_per_coded_sample)
3730 avctx->bits_per_coded_sample =
3731 av_get_bits_per_sample(avctx->codec_id);
3732 // set stream disposition based on audio service type
3733 switch (avctx->audio_service_type) {
3734 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3735 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3737 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3738 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3740 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3741 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3743 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3744 st->disposition = AV_DISPOSITION_COMMENT;
3746 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3747 st->disposition = AV_DISPOSITION_KARAOKE;
3754 estimate_timings(ic, old_offset);
3756 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3758 if (ret >= 0 && ic->nb_streams)
3759 /* We could not have all the codec parameters before EOF. */
3761 for (i = 0; i < ic->nb_streams; i++) {
3763 st = ic->streams[i];
3765 /* if no packet was ever seen, update context now for has_codec_parameters */
3766 if (!st->internal->avctx_inited) {
3767 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3768 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3769 st->codecpar->format = st->internal->avctx->sample_fmt;
3770 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3772 goto find_stream_info_err;
3774 if (!has_codec_parameters(st, &errmsg)) {
3776 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3777 av_log(ic, AV_LOG_WARNING,
3778 "Could not find codec parameters for stream %d (%s): %s\n"
3779 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3786 compute_chapters_end(ic);
3788 /* update the stream parameters from the internal codec contexts */
3789 for (i = 0; i < ic->nb_streams; i++) {
3790 st = ic->streams[i];
3792 if (st->internal->avctx_inited) {
3793 int orig_w = st->codecpar->width;
3794 int orig_h = st->codecpar->height;
3795 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
3797 goto find_stream_info_err;
3798 // The decoder might reduce the video size by the lowres factor.
3799 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3800 st->codecpar->width = orig_w;
3801 st->codecpar->height = orig_h;
3805 #if FF_API_LAVF_AVCTX
3806 FF_DISABLE_DEPRECATION_WARNINGS
3807 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3809 goto find_stream_info_err;
3811 // The old API (AVStream.codec) "requires" the resolution to be adjusted
3812 // by the lowres factor.
3813 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3814 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
3815 st->codec->width = st->internal->avctx->width;
3816 st->codec->height = st->internal->avctx->height;
3819 if (st->codec->codec_tag != MKTAG('t','m','c','d'))
3820 st->codec->time_base = st->internal->avctx->time_base;
3821 st->codec->framerate = st->avg_frame_rate;
3823 if (st->internal->avctx->subtitle_header) {
3824 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3825 if (!st->codec->subtitle_header)
3826 goto find_stream_info_err;
3827 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3828 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3829 st->codec->subtitle_header_size);
3832 // Fields unavailable in AVCodecParameters
3833 st->codec->coded_width = st->internal->avctx->coded_width;
3834 st->codec->coded_height = st->internal->avctx->coded_height;
3835 st->codec->properties = st->internal->avctx->properties;
3836 FF_ENABLE_DEPRECATION_WARNINGS
3839 st->internal->avctx_inited = 0;
3842 find_stream_info_err:
3843 for (i = 0; i < ic->nb_streams; i++) {
3844 st = ic->streams[i];
3846 av_freep(&st->info->duration_error);
3847 av_freep(&ic->streams[i]->info);
3850 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3851 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3855 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3859 for (i = 0; i < ic->nb_programs; i++) {
3860 if (ic->programs[i] == last) {
3864 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3865 if (ic->programs[i]->stream_index[j] == s)
3866 return ic->programs[i];
3872 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3873 int wanted_stream_nb, int related_stream,
3874 AVCodec **decoder_ret, int flags)
3876 int i, nb_streams = ic->nb_streams;
3877 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3878 unsigned *program = NULL;
3879 const AVCodec *decoder = NULL, *best_decoder = NULL;
3881 if (related_stream >= 0 && wanted_stream_nb < 0) {
3882 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3884 program = p->stream_index;
3885 nb_streams = p->nb_stream_indexes;
3888 for (i = 0; i < nb_streams; i++) {
3889 int real_stream_index = program ? program[i] : i;
3890 AVStream *st = ic->streams[real_stream_index];
3891 AVCodecParameters *par = st->codecpar;
3892 if (par->codec_type != type)
3894 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3896 if (wanted_stream_nb != real_stream_index &&
3897 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3898 AV_DISPOSITION_VISUAL_IMPAIRED))
3900 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
3903 decoder = find_decoder(ic, st, par->codec_id);
3906 ret = AVERROR_DECODER_NOT_FOUND;
3910 count = st->codec_info_nb_frames;
3911 bitrate = par->bit_rate;
3912 multiframe = FFMIN(5, count);
3913 if ((best_multiframe > multiframe) ||
3914 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3915 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3918 best_bitrate = bitrate;
3919 best_multiframe = multiframe;
3920 ret = real_stream_index;
3921 best_decoder = decoder;
3922 if (program && i == nb_streams - 1 && ret < 0) {
3924 nb_streams = ic->nb_streams;
3925 /* no related stream found, try again with everything */
3930 *decoder_ret = (AVCodec*)best_decoder;
3934 /*******************************************************/
3936 int av_read_play(AVFormatContext *s)
3938 if (s->iformat->read_play)
3939 return s->iformat->read_play(s);
3941 return avio_pause(s->pb, 0);
3942 return AVERROR(ENOSYS);
3945 int av_read_pause(AVFormatContext *s)
3947 if (s->iformat->read_pause)
3948 return s->iformat->read_pause(s);
3950 return avio_pause(s->pb, 1);
3951 return AVERROR(ENOSYS);
3954 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
3959 dst->time_base = src->time_base;
3960 dst->nb_frames = src->nb_frames;
3961 dst->disposition = src->disposition;
3962 dst->sample_aspect_ratio = src->sample_aspect_ratio;
3963 dst->avg_frame_rate = src->avg_frame_rate;
3964 dst->r_frame_rate = src->r_frame_rate;
3966 av_dict_free(&dst->metadata);
3967 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
3971 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
3975 /* Free existing side data*/
3976 for (i = 0; i < dst->nb_side_data; i++)
3977 av_free(dst->side_data[i].data);
3978 av_freep(&dst->side_data);
3979 dst->nb_side_data = 0;
3981 /* Copy side data if present */
3982 if (src->nb_side_data) {
3983 dst->side_data = av_mallocz_array(src->nb_side_data,
3984 sizeof(AVPacketSideData));
3985 if (!dst->side_data)
3986 return AVERROR(ENOMEM);
3987 dst->nb_side_data = src->nb_side_data;
3989 for (i = 0; i < src->nb_side_data; i++) {
3990 uint8_t *data = av_memdup(src->side_data[i].data,
3991 src->side_data[i].size);
3993 return AVERROR(ENOMEM);
3994 dst->side_data[i].type = src->side_data[i].type;
3995 dst->side_data[i].size = src->side_data[i].size;
3996 dst->side_data[i].data = data;
4000 av_freep(&dst->recommended_encoder_configuration);
4001 if (src->recommended_encoder_configuration) {
4002 const char *conf_str = src->recommended_encoder_configuration;
4003 dst->recommended_encoder_configuration = av_strdup(conf_str);
4004 if (!dst->recommended_encoder_configuration)
4005 return AVERROR(ENOMEM);
4011 static void free_stream(AVStream **pst)
4013 AVStream *st = *pst;
4019 for (i = 0; i < st->nb_side_data; i++)
4020 av_freep(&st->side_data[i].data);
4021 av_freep(&st->side_data);
4024 av_parser_close(st->parser);
4026 if (st->attached_pic.data)
4027 av_packet_unref(&st->attached_pic);
4030 avcodec_free_context(&st->internal->avctx);
4031 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4032 av_bsf_free(&st->internal->bsfcs[i]);
4033 av_freep(&st->internal->bsfcs);
4036 av_freep(&st->internal);
4038 av_dict_free(&st->metadata);
4039 avcodec_parameters_free(&st->codecpar);
4040 av_freep(&st->probe_data.buf);
4041 av_freep(&st->index_entries);
4042 #if FF_API_LAVF_AVCTX
4043 FF_DISABLE_DEPRECATION_WARNINGS
4044 av_freep(&st->codec->extradata);
4045 av_freep(&st->codec->subtitle_header);
4046 av_freep(&st->codec);
4047 FF_ENABLE_DEPRECATION_WARNINGS
4049 av_freep(&st->priv_data);
4051 av_freep(&st->info->duration_error);
4052 av_freep(&st->info);
4053 av_freep(&st->recommended_encoder_configuration);
4054 av_freep(&st->priv_pts);
4059 void ff_free_stream(AVFormatContext *s, AVStream *st)
4061 av_assert0(s->nb_streams>0);
4062 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4064 free_stream(&s->streams[ --s->nb_streams ]);
4067 void avformat_free_context(AVFormatContext *s)
4075 if (s->iformat && s->iformat->priv_class && s->priv_data)
4076 av_opt_free(s->priv_data);
4077 if (s->oformat && s->oformat->priv_class && s->priv_data)
4078 av_opt_free(s->priv_data);
4080 for (i = s->nb_streams - 1; i >= 0; i--)
4081 ff_free_stream(s, s->streams[i]);
4084 for (i = s->nb_programs - 1; i >= 0; i--) {
4085 av_dict_free(&s->programs[i]->metadata);
4086 av_freep(&s->programs[i]->stream_index);
4087 av_freep(&s->programs[i]);
4089 av_freep(&s->programs);
4090 av_freep(&s->priv_data);
4091 while (s->nb_chapters--) {
4092 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4093 av_freep(&s->chapters[s->nb_chapters]);
4095 av_freep(&s->chapters);
4096 av_dict_free(&s->metadata);
4097 av_freep(&s->streams);
4098 av_freep(&s->internal);
4099 flush_packet_queue(s);
4103 void avformat_close_input(AVFormatContext **ps)
4114 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4115 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4118 flush_packet_queue(s);
4121 if (s->iformat->read_close)
4122 s->iformat->read_close(s);
4124 avformat_free_context(s);
4131 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4137 if (s->nb_streams >= INT_MAX/sizeof(*streams))
4139 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4142 s->streams = streams;
4144 st = av_mallocz(sizeof(AVStream));
4147 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4151 st->info->last_dts = AV_NOPTS_VALUE;
4153 #if FF_API_LAVF_AVCTX
4154 FF_DISABLE_DEPRECATION_WARNINGS
4155 st->codec = avcodec_alloc_context3(c);
4161 FF_ENABLE_DEPRECATION_WARNINGS
4164 st->internal = av_mallocz(sizeof(*st->internal));
4168 st->codecpar = avcodec_parameters_alloc();
4172 st->internal->avctx = avcodec_alloc_context3(NULL);
4173 if (!st->internal->avctx)
4177 #if FF_API_LAVF_AVCTX
4178 FF_DISABLE_DEPRECATION_WARNINGS
4179 /* no default bitrate if decoding */
4180 st->codec->bit_rate = 0;
4181 FF_ENABLE_DEPRECATION_WARNINGS
4184 /* default pts setting is MPEG-like */
4185 avpriv_set_pts_info(st, 33, 1, 90000);
4186 /* we set the current DTS to 0 so that formats without any timestamps
4187 * but durations get some timestamps, formats with some unknown
4188 * timestamps have their first few packets buffered and the
4189 * timestamps corrected before they are returned to the user */
4190 st->cur_dts = RELATIVE_TS_BASE;
4192 st->cur_dts = AV_NOPTS_VALUE;
4195 st->index = s->nb_streams;
4196 st->start_time = AV_NOPTS_VALUE;
4197 st->duration = AV_NOPTS_VALUE;
4198 st->first_dts = AV_NOPTS_VALUE;
4199 st->probe_packets = MAX_PROBE_PACKETS;
4200 st->pts_wrap_reference = AV_NOPTS_VALUE;
4201 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4203 st->last_IP_pts = AV_NOPTS_VALUE;
4204 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4205 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4206 st->pts_buffer[i] = AV_NOPTS_VALUE;
4208 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4210 #if FF_API_R_FRAME_RATE
4211 st->info->last_dts = AV_NOPTS_VALUE;
4213 st->info->fps_first_dts = AV_NOPTS_VALUE;
4214 st->info->fps_last_dts = AV_NOPTS_VALUE;
4216 st->inject_global_side_data = s->internal->inject_global_side_data;
4218 st->internal->need_context_update = 1;
4220 s->streams[s->nb_streams++] = st;
4227 AVProgram *av_new_program(AVFormatContext *ac, int id)
4229 AVProgram *program = NULL;
4232 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4234 for (i = 0; i < ac->nb_programs; i++)
4235 if (ac->programs[i]->id == id)
4236 program = ac->programs[i];
4239 program = av_mallocz(sizeof(AVProgram));
4242 dynarray_add(&ac->programs, &ac->nb_programs, program);
4243 program->discard = AVDISCARD_NONE;
4246 program->pts_wrap_reference = AV_NOPTS_VALUE;
4247 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4249 program->start_time =
4250 program->end_time = AV_NOPTS_VALUE;
4255 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4256 int64_t start, int64_t end, const char *title)
4258 AVChapter *chapter = NULL;
4261 if (end != AV_NOPTS_VALUE && start > end) {
4262 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4266 for (i = 0; i < s->nb_chapters; i++)
4267 if (s->chapters[i]->id == id)
4268 chapter = s->chapters[i];
4271 chapter = av_mallocz(sizeof(AVChapter));
4274 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4276 av_dict_set(&chapter->metadata, "title", title, 0);
4278 chapter->time_base = time_base;
4279 chapter->start = start;
4285 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4288 AVProgram *program = NULL;
4291 if (idx >= ac->nb_streams) {
4292 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4296 for (i = 0; i < ac->nb_programs; i++) {
4297 if (ac->programs[i]->id != progid)
4299 program = ac->programs[i];
4300 for (j = 0; j < program->nb_stream_indexes; j++)
4301 if (program->stream_index[j] == idx)
4304 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4307 program->stream_index = tmp;
4308 program->stream_index[program->nb_stream_indexes++] = idx;
4313 uint64_t ff_ntp_time(void)
4315 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4318 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4321 char *q, buf1[20], c;
4322 int nd, len, percentd_found;
4334 while (av_isdigit(*p))
4335 nd = nd * 10 + *p++ - '0';
4337 } while (av_isdigit(c));
4348 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4350 if ((q - buf + len) > buf_size - 1)
4352 memcpy(q, buf1, len);
4360 if ((q - buf) < buf_size - 1)
4364 if (!percentd_found)
4373 void av_url_split(char *proto, int proto_size,
4374 char *authorization, int authorization_size,
4375 char *hostname, int hostname_size,
4376 int *port_ptr, char *path, int path_size, const char *url)
4378 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4384 if (authorization_size > 0)
4385 authorization[0] = 0;
4386 if (hostname_size > 0)
4391 /* parse protocol */
4392 if ((p = strchr(url, ':'))) {
4393 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4400 /* no protocol means plain filename */
4401 av_strlcpy(path, url, path_size);
4405 /* separate path from hostname */
4406 ls = strchr(p, '/');
4407 ls2 = strchr(p, '?');
4411 ls = FFMIN(ls, ls2);
4413 av_strlcpy(path, ls, path_size);
4415 ls = &p[strlen(p)]; // XXX
4417 /* the rest is hostname, use that to parse auth/port */
4419 /* authorization (user[:pass]@hostname) */
4421 while ((at = strchr(p, '@')) && at < ls) {
4422 av_strlcpy(authorization, at2,
4423 FFMIN(authorization_size, at + 1 - at2));
4424 p = at + 1; /* skip '@' */
4427 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4429 av_strlcpy(hostname, p + 1,
4430 FFMIN(hostname_size, brk - p));
4431 if (brk[1] == ':' && port_ptr)
4432 *port_ptr = atoi(brk + 2);
4433 } else if ((col = strchr(p, ':')) && col < ls) {
4434 av_strlcpy(hostname, p,
4435 FFMIN(col + 1 - p, hostname_size));
4437 *port_ptr = atoi(col + 1);
4439 av_strlcpy(hostname, p,
4440 FFMIN(ls + 1 - p, hostname_size));
4444 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4447 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4450 'C', 'D', 'E', 'F' };
4451 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4454 'c', 'd', 'e', 'f' };
4455 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4457 for (i = 0; i < s; i++) {
4458 buff[i * 2] = hex_table[src[i] >> 4];
4459 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4465 int ff_hex_to_data(uint8_t *data, const char *p)
4472 p += strspn(p, SPACE_CHARS);
4475 c = av_toupper((unsigned char) *p++);
4476 if (c >= '0' && c <= '9')
4478 else if (c >= 'A' && c <= 'F')
4493 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4494 unsigned int pts_num, unsigned int pts_den)
4497 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4498 if (new_tb.num != pts_num)
4499 av_log(NULL, AV_LOG_DEBUG,
4500 "st:%d removing common factor %d from timebase\n",
4501 s->index, pts_num / new_tb.num);
4503 av_log(NULL, AV_LOG_WARNING,
4504 "st:%d has too large timebase, reducing\n", s->index);
4506 if (new_tb.num <= 0 || new_tb.den <= 0) {
4507 av_log(NULL, AV_LOG_ERROR,
4508 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4509 new_tb.num, new_tb.den,
4513 s->time_base = new_tb;
4514 #if FF_API_LAVF_AVCTX
4515 FF_DISABLE_DEPRECATION_WARNINGS
4516 av_codec_set_pkt_timebase(s->codec, new_tb);
4517 FF_ENABLE_DEPRECATION_WARNINGS
4519 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4520 s->pts_wrap_bits = pts_wrap_bits;
4523 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4526 const char *ptr = str;
4528 /* Parse key=value pairs. */
4531 char *dest = NULL, *dest_end;
4532 int key_len, dest_len = 0;
4534 /* Skip whitespace and potential commas. */
4535 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4542 if (!(ptr = strchr(key, '=')))
4545 key_len = ptr - key;
4547 callback_get_buf(context, key, key_len, &dest, &dest_len);
4548 dest_end = dest + dest_len - 1;
4552 while (*ptr && *ptr != '\"') {
4556 if (dest && dest < dest_end)
4560 if (dest && dest < dest_end)
4568 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4569 if (dest && dest < dest_end)
4577 int ff_find_stream_index(AVFormatContext *s, int id)
4580 for (i = 0; i < s->nb_streams; i++)
4581 if (s->streams[i]->id == id)
4586 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4590 unsigned int codec_tag;
4591 if (ofmt->query_codec)
4592 return ofmt->query_codec(codec_id, std_compliance);
4593 else if (ofmt->codec_tag)
4594 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4595 else if (codec_id == ofmt->video_codec ||
4596 codec_id == ofmt->audio_codec ||
4597 codec_id == ofmt->subtitle_codec)
4600 return AVERROR_PATCHWELCOME;
4603 int avformat_network_init(void)
4607 ff_network_inited_globally = 1;
4608 if ((ret = ff_network_init()) < 0)
4610 if ((ret = ff_tls_init()) < 0)
4616 int avformat_network_deinit(void)
4621 ff_network_inited_globally = 0;
4626 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4627 uint64_t channel_layout, int32_t sample_rate,
4628 int32_t width, int32_t height)
4634 return AVERROR(EINVAL);
4637 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4639 if (channel_layout) {
4641 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4645 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4647 if (width || height) {
4649 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4651 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4653 return AVERROR(ENOMEM);
4654 bytestream_put_le32(&data, flags);
4656 bytestream_put_le32(&data, channels);
4658 bytestream_put_le64(&data, channel_layout);
4660 bytestream_put_le32(&data, sample_rate);
4661 if (width || height) {
4662 bytestream_put_le32(&data, width);
4663 bytestream_put_le32(&data, height);
4668 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4670 AVRational undef = {0, 1};
4671 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4672 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4673 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4675 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4676 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4677 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4678 stream_sample_aspect_ratio = undef;
4680 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4681 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4682 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4683 frame_sample_aspect_ratio = undef;
4685 if (stream_sample_aspect_ratio.num)
4686 return stream_sample_aspect_ratio;
4688 return frame_sample_aspect_ratio;
4691 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4693 AVRational fr = st->r_frame_rate;
4694 AVRational codec_fr = st->internal->avctx->framerate;
4695 AVRational avg_fr = st->avg_frame_rate;
4697 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4698 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4703 if (st->internal->avctx->ticks_per_frame > 1) {
4704 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4705 (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))
4712 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4715 if (*spec <= '9' && *spec >= '0') /* opt:index */
4716 return strtol(spec, NULL, 0) == st->index;
4717 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4718 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4719 enum AVMediaType type;
4723 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4724 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4725 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4726 case 'd': type = AVMEDIA_TYPE_DATA; break;
4727 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4728 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4729 default: av_assert0(0);
4731 #if FF_API_LAVF_AVCTX
4732 FF_DISABLE_DEPRECATION_WARNINGS
4733 if (type != st->codecpar->codec_type
4734 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4736 FF_ENABLE_DEPRECATION_WARNINGS
4738 if (type != st->codecpar->codec_type)
4741 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4743 if (*spec++ == ':') { /* possibly followed by :index */
4744 int i, index = strtol(spec, NULL, 0);
4745 for (i = 0; i < s->nb_streams; i++) {
4746 #if FF_API_LAVF_AVCTX
4747 FF_DISABLE_DEPRECATION_WARNINGS
4748 if ((s->streams[i]->codecpar->codec_type == type
4749 || s->streams[i]->codec->codec_type == type
4751 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4753 return i == st->index;
4754 FF_ENABLE_DEPRECATION_WARNINGS
4756 if ((s->streams[i]->codecpar->codec_type == type) &&
4757 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4759 return i == st->index;
4765 } else if (*spec == 'p' && *(spec + 1) == ':') {
4769 prog_id = strtol(spec, &endptr, 0);
4770 for (i = 0; i < s->nb_programs; i++) {
4771 if (s->programs[i]->id != prog_id)
4774 if (*endptr++ == ':') {
4775 int stream_idx = strtol(endptr, NULL, 0);
4776 return stream_idx >= 0 &&
4777 stream_idx < s->programs[i]->nb_stream_indexes &&
4778 st->index == s->programs[i]->stream_index[stream_idx];
4781 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4782 if (st->index == s->programs[i]->stream_index[j])
4786 } else if (*spec == '#' ||
4787 (*spec == 'i' && *(spec + 1) == ':')) {
4790 spec += 1 + (*spec == 'i');
4791 stream_id = strtol(spec, &endptr, 0);
4793 return stream_id == st->id;
4794 } else if (*spec == 'm' && *(spec + 1) == ':') {
4795 AVDictionaryEntry *tag;
4800 val = strchr(spec, ':');
4802 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4804 return AVERROR(ENOMEM);
4806 tag = av_dict_get(st->metadata, key, NULL, 0);
4808 if (!val || !strcmp(tag->value, val + 1))
4817 } else if (*spec == 'u') {
4818 AVCodecParameters *par = st->codecpar;
4819 #if FF_API_LAVF_AVCTX
4820 FF_DISABLE_DEPRECATION_WARNINGS
4821 AVCodecContext *codec = st->codec;
4822 FF_ENABLE_DEPRECATION_WARNINGS
4825 switch (par->codec_type) {
4826 case AVMEDIA_TYPE_AUDIO:
4827 val = par->sample_rate && par->channels;
4828 #if FF_API_LAVF_AVCTX
4829 val = val || (codec->sample_rate && codec->channels);
4831 if (par->format == AV_SAMPLE_FMT_NONE
4832 #if FF_API_LAVF_AVCTX
4833 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4838 case AVMEDIA_TYPE_VIDEO:
4839 val = par->width && par->height;
4840 #if FF_API_LAVF_AVCTX
4841 val = val || (codec->width && codec->height);
4843 if (par->format == AV_PIX_FMT_NONE
4844 #if FF_API_LAVF_AVCTX
4845 && codec->pix_fmt == AV_PIX_FMT_NONE
4850 case AVMEDIA_TYPE_UNKNOWN:
4857 #if FF_API_LAVF_AVCTX
4858 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4860 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4862 } else if (!*spec) /* empty specifier, matches everything */
4865 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4866 return AVERROR(EINVAL);
4869 int ff_generate_avci_extradata(AVStream *st)
4871 static const uint8_t avci100_1080p_extradata[] = {
4873 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4874 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4875 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4876 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4877 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4878 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4879 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4880 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4881 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4883 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4886 static const uint8_t avci100_1080i_extradata[] = {
4888 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4889 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4890 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4891 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4892 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4893 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4894 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4895 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4896 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4897 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4898 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4900 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4903 static const uint8_t avci50_1080p_extradata[] = {
4905 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4906 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4907 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4908 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4909 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4910 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4911 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4912 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4913 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4915 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4918 static const uint8_t avci50_1080i_extradata[] = {
4920 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4921 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4922 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4923 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4924 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4925 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4926 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4927 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4928 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4929 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4930 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4932 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4935 static const uint8_t avci100_720p_extradata[] = {
4937 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4938 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4939 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4940 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4941 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4942 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4943 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4944 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4945 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4946 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4948 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4951 static const uint8_t avci50_720p_extradata[] = {
4953 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4954 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4955 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4956 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4957 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4958 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4959 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4960 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4961 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4963 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4967 const uint8_t *data = NULL;
4970 if (st->codecpar->width == 1920) {
4971 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
4972 data = avci100_1080p_extradata;
4973 size = sizeof(avci100_1080p_extradata);
4975 data = avci100_1080i_extradata;
4976 size = sizeof(avci100_1080i_extradata);
4978 } else if (st->codecpar->width == 1440) {
4979 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
4980 data = avci50_1080p_extradata;
4981 size = sizeof(avci50_1080p_extradata);
4983 data = avci50_1080i_extradata;
4984 size = sizeof(avci50_1080i_extradata);
4986 } else if (st->codecpar->width == 1280) {
4987 data = avci100_720p_extradata;
4988 size = sizeof(avci100_720p_extradata);
4989 } else if (st->codecpar->width == 960) {
4990 data = avci50_720p_extradata;
4991 size = sizeof(avci50_720p_extradata);
4997 av_freep(&st->codecpar->extradata);
4998 if (ff_alloc_extradata(st->codecpar, size))
4999 return AVERROR(ENOMEM);
5000 memcpy(st->codecpar->extradata, data, size);
5005 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
5010 for (i = 0; i < st->nb_side_data; i++) {
5011 if (st->side_data[i].type == type) {
5013 *size = st->side_data[i].size;
5014 return st->side_data[i].data;
5020 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5023 AVPacketSideData *sd, *tmp;
5025 uint8_t *data = av_malloc(size);
5030 for (i = 0; i < st->nb_side_data; i++) {
5031 sd = &st->side_data[i];
5033 if (sd->type == type) {
5034 av_freep(&sd->data);
5041 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
5047 st->side_data = tmp;
5050 sd = &st->side_data[st->nb_side_data - 1];
5057 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5060 const AVBitStreamFilter *bsf;
5062 AVCodecParameters *in_par;
5064 if (!(bsf = av_bsf_get_by_name(name))) {
5065 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5066 return AVERROR_BSF_NOT_FOUND;
5069 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5072 if (st->internal->nb_bsfcs) {
5073 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5074 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5076 in_par = st->codecpar;
5077 bsfc->time_base_in = st->time_base;
5080 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5085 if (args && bsfc->filter->priv_class) {
5086 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5087 const char * shorthand[2] = {NULL};
5090 shorthand[0] = opt->name;
5092 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5098 if ((ret = av_bsf_init(bsfc)) < 0) {
5103 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5108 av_log(NULL, AV_LOG_VERBOSE,
5109 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5110 name, args ? args : "");
5115 FF_DISABLE_DEPRECATION_WARNINGS
5116 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5117 AVBitStreamFilterContext *bsfc)
5121 AVPacket new_pkt = *pkt;
5122 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5123 &new_pkt.data, &new_pkt.size,
5124 pkt->data, pkt->size,
5125 pkt->flags & AV_PKT_FLAG_KEY);
5126 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5127 av_packet_unref(pkt);
5128 memset(pkt, 0, sizeof(*pkt));
5131 if(a == 0 && new_pkt.data != pkt->data) {
5132 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
5134 memcpy(t, new_pkt.data, new_pkt.size);
5135 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5140 a = AVERROR(ENOMEM);
5144 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5145 av_buffer_default_free, NULL, 0);
5147 pkt->side_data = NULL;
5148 pkt->side_data_elems = 0;
5149 av_packet_unref(pkt);
5151 av_freep(&new_pkt.data);
5152 a = AVERROR(ENOMEM);
5156 av_log(codec, AV_LOG_ERROR,
5157 "Failed to open bitstream filter %s for stream %d with codec %s",
5158 bsfc->filter->name, pkt->stream_index,
5159 codec->codec ? codec->codec->name : "copy");
5169 FF_ENABLE_DEPRECATION_WARNINGS
5172 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5175 return AVERROR(EINVAL);
5177 if (!(s->oformat->flags & AVFMT_NOFILE))
5178 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5182 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5185 s->io_close(s, *pb);
5189 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5191 AVDictionaryEntry *entry;
5192 int64_t parsed_timestamp;
5194 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5195 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5196 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5199 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5206 int ff_standardize_creation_time(AVFormatContext *s)
5209 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5211 time_t seconds = timestamp / 1000000;
5212 struct tm *ptm, tmbuf;
5213 ptm = gmtime_r(&seconds, &tmbuf);
5216 if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
5217 return AVERROR_EXTERNAL;
5218 av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
5219 av_dict_set(&s->metadata, "creation_time", buf, 0);
5221 return AVERROR_EXTERNAL;
5227 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5232 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5234 if (size != AVPALETTE_SIZE) {
5235 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5236 return AVERROR_INVALIDDATA;
5238 memcpy(palette, side_data, AVPALETTE_SIZE);
5242 if (ret == CONTAINS_PAL) {
5244 for (i = 0; i < AVPALETTE_COUNT; i++)
5245 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5252 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5257 ret = av_bprint_finalize(buf, &str);
5260 if (!av_bprint_is_complete(buf)) {
5262 return AVERROR(ENOMEM);
5265 par->extradata = str;
5266 /* Note: the string is NUL terminated (so extradata can be read as a
5267 * string), but the ending character is not accounted in the size (in
5268 * binary formats you are likely not supposed to mux that character). When
5269 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5271 par->extradata_size = buf->len;