2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/raw.h"
42 #include "audiointerleave.h"
44 #include "avio_internal.h"
54 #include "libavutil/ffversion.h"
55 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
59 * various utility functions for use within FFmpeg
62 unsigned avformat_version(void)
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
68 const char *avformat_configuration(void)
70 return FFMPEG_CONFIGURATION;
73 const char *avformat_license(void)
75 #define LICENSE_PREFIX "libavformat license: "
76 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
79 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
81 static int is_relative(int64_t ts) {
82 return ts > (RELATIVE_TS_BASE - (1LL<<48));
86 * Wrap a given time stamp, if there is an indication for an overflow
89 * @param timestamp the time stamp to wrap
90 * @return resulting time stamp
92 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
94 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
95 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
96 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
97 timestamp < st->pts_wrap_reference)
98 return timestamp + (1ULL << st->pts_wrap_bits);
99 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
100 timestamp >= st->pts_wrap_reference)
101 return timestamp - (1ULL << st->pts_wrap_bits);
106 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
107 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
113 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
114 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
115 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
117 int64_t av_stream_get_end_pts(const AVStream *st)
120 return st->priv_pts->val;
122 return AV_NOPTS_VALUE;
125 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
130 void av_format_inject_global_side_data(AVFormatContext *s)
133 s->internal->inject_global_side_data = 1;
134 for (i = 0; i < s->nb_streams; i++) {
135 AVStream *st = s->streams[i];
136 st->inject_global_side_data = 1;
140 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
142 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
143 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
144 dst->format_whitelist = av_strdup(src->format_whitelist);
145 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
146 || (src->format_whitelist && !dst->format_whitelist)) {
147 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
148 return AVERROR(ENOMEM);
153 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
155 if (st->codec->codec)
156 return st->codec->codec;
158 switch (st->codec->codec_type) {
159 case AVMEDIA_TYPE_VIDEO:
160 if (s->video_codec) return s->video_codec;
162 case AVMEDIA_TYPE_AUDIO:
163 if (s->audio_codec) return s->audio_codec;
165 case AVMEDIA_TYPE_SUBTITLE:
166 if (s->subtitle_codec) return s->subtitle_codec;
170 return avcodec_find_decoder(codec_id);
173 int av_format_get_probe_score(const AVFormatContext *s)
175 return s->probe_score;
178 /* an arbitrarily chosen "sane" max packet size -- 50M */
179 #define SANE_CHUNK_SIZE (50000000)
181 int ffio_limit(AVIOContext *s, int size)
183 if (s->maxsize>= 0) {
184 int64_t remaining= s->maxsize - avio_tell(s);
185 if (remaining < size) {
186 int64_t newsize = avio_size(s);
187 if (!s->maxsize || s->maxsize<newsize)
188 s->maxsize = newsize - !newsize;
189 remaining= s->maxsize - avio_tell(s);
190 remaining= FFMAX(remaining, 0);
193 if (s->maxsize>= 0 && remaining+1 < size) {
194 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
201 /* Read the data in sane-sized chunks and append to pkt.
202 * Return the number of bytes read or an error. */
203 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
205 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
206 int orig_size = pkt->size;
210 int prev_size = pkt->size;
213 /* When the caller requests a lot of data, limit it to the amount
214 * left in file or SANE_CHUNK_SIZE when it is not known. */
216 if (read_size > SANE_CHUNK_SIZE/10) {
217 read_size = ffio_limit(s, read_size);
218 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
220 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
223 ret = av_grow_packet(pkt, read_size);
227 ret = avio_read(s, pkt->data + prev_size, read_size);
228 if (ret != read_size) {
229 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
236 pkt->flags |= AV_PKT_FLAG_CORRUPT;
240 av_packet_unref(pkt);
241 return pkt->size > orig_size ? pkt->size - orig_size : ret;
244 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
249 pkt->pos = avio_tell(s);
251 return append_packet_chunked(s, pkt, size);
254 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
257 return av_get_packet(s, pkt, size);
258 return append_packet_chunked(s, pkt, size);
261 int av_filename_number_test(const char *filename)
265 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
268 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
271 static const struct {
274 enum AVMediaType type;
276 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
277 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
278 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
279 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
280 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
281 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
282 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
283 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
284 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
285 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
286 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
290 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
292 if (fmt && st->request_probe <= score) {
294 av_log(s, AV_LOG_DEBUG,
295 "Probe with size=%d, packets=%d detected %s with score=%d\n",
296 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
298 for (i = 0; fmt_id_type[i].name; i++) {
299 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
300 st->codec->codec_id = fmt_id_type[i].id;
301 st->codec->codec_type = fmt_id_type[i].type;
309 /************************************************************/
310 /* input media file */
312 int av_demuxer_open(AVFormatContext *ic) {
315 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
316 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
317 return AVERROR(EINVAL);
320 if (ic->iformat->read_header) {
321 err = ic->iformat->read_header(ic);
326 if (ic->pb && !ic->internal->data_offset)
327 ic->internal->data_offset = avio_tell(ic->pb);
332 /* Open input file and probe the format if necessary. */
333 static int init_input(AVFormatContext *s, const char *filename,
334 AVDictionary **options)
337 AVProbeData pd = { filename, NULL, 0 };
338 int score = AVPROBE_SCORE_RETRY;
341 s->flags |= AVFMT_FLAG_CUSTOM_IO;
343 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
344 s, 0, s->format_probesize);
345 else if (s->iformat->flags & AVFMT_NOFILE)
346 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
347 "will be ignored with AVFMT_NOFILE format.\n");
351 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
352 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
355 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
356 &s->interrupt_callback, options)) < 0)
360 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
361 s, 0, s->format_probesize);
364 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
365 AVPacketList **plast_pktl, int ref)
367 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
371 return AVERROR(ENOMEM);
374 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
383 (*plast_pktl)->next = pktl;
385 *packet_buffer = pktl;
387 /* Add the packet in the buffered packet list. */
392 int avformat_queue_attached_pictures(AVFormatContext *s)
395 for (i = 0; i < s->nb_streams; i++)
396 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
397 s->streams[i]->discard < AVDISCARD_ALL) {
398 if (s->streams[i]->attached_pic.size <= 0) {
399 av_log(s, AV_LOG_WARNING,
400 "Attached picture on stream %d has invalid size, "
405 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
406 &s->streams[i]->attached_pic,
407 &s->internal->raw_packet_buffer_end, 1);
414 int avformat_open_input(AVFormatContext **ps, const char *filename,
415 AVInputFormat *fmt, AVDictionary **options)
417 AVFormatContext *s = *ps;
419 AVDictionary *tmp = NULL;
420 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
422 if (!s && !(s = avformat_alloc_context()))
423 return AVERROR(ENOMEM);
425 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
426 return AVERROR(EINVAL);
432 av_dict_copy(&tmp, *options, 0);
434 if (s->pb) // must be before any goto fail
435 s->flags |= AVFMT_FLAG_CUSTOM_IO;
437 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
440 if ((ret = init_input(s, filename, &tmp)) < 0)
442 s->probe_score = ret;
444 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
445 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
446 ret = AVERROR(EINVAL);
450 avio_skip(s->pb, s->skip_initial_bytes);
452 /* Check filename in case an image number is expected. */
453 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
454 if (!av_filename_number_test(filename)) {
455 ret = AVERROR(EINVAL);
460 s->duration = s->start_time = AV_NOPTS_VALUE;
461 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
463 /* Allocate private data. */
464 if (s->iformat->priv_data_size > 0) {
465 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
466 ret = AVERROR(ENOMEM);
469 if (s->iformat->priv_class) {
470 *(const AVClass **) s->priv_data = s->iformat->priv_class;
471 av_opt_set_defaults(s->priv_data);
472 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
477 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
479 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
481 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
482 if ((ret = s->iformat->read_header(s)) < 0)
485 if (id3v2_extra_meta) {
486 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
487 !strcmp(s->iformat->name, "tta")) {
488 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
491 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
493 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
495 if ((ret = avformat_queue_attached_pictures(s)) < 0)
498 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
499 s->internal->data_offset = avio_tell(s->pb);
501 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504 av_dict_free(options);
511 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
513 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
515 avformat_free_context(s);
520 /*******************************************************/
522 static void force_codec_ids(AVFormatContext *s, AVStream *st)
524 switch (st->codec->codec_type) {
525 case AVMEDIA_TYPE_VIDEO:
526 if (s->video_codec_id)
527 st->codec->codec_id = s->video_codec_id;
529 case AVMEDIA_TYPE_AUDIO:
530 if (s->audio_codec_id)
531 st->codec->codec_id = s->audio_codec_id;
533 case AVMEDIA_TYPE_SUBTITLE:
534 if (s->subtitle_codec_id)
535 st->codec->codec_id = s->subtitle_codec_id;
540 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
542 if (st->request_probe>0) {
543 AVProbeData *pd = &st->probe_data;
545 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
549 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
551 av_log(s, AV_LOG_WARNING,
552 "Failed to reallocate probe buffer for stream %d\n",
557 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
558 pd->buf_size += pkt->size;
559 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
562 st->probe_packets = 0;
564 av_log(s, AV_LOG_WARNING,
565 "nothing to probe for stream %d\n", st->index);
569 end= s->internal->raw_packet_buffer_remaining_size <= 0
570 || st->probe_packets<= 0;
572 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
573 int score = set_codec_from_probe_data(s, st, pd);
574 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
578 st->request_probe = -1;
579 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
580 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
582 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
584 force_codec_ids(s, st);
590 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
592 int64_t ref = pkt->dts;
593 int i, pts_wrap_behavior;
594 int64_t pts_wrap_reference;
595 AVProgram *first_program;
597 if (ref == AV_NOPTS_VALUE)
599 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
601 ref &= (1LL << st->pts_wrap_bits)-1;
603 // reference time stamp should be 60 s before first time stamp
604 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
605 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
606 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
607 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
608 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
610 first_program = av_find_program_from_stream(s, NULL, stream_index);
612 if (!first_program) {
613 int default_stream_index = av_find_default_stream_index(s);
614 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
615 for (i = 0; i < s->nb_streams; i++) {
616 if (av_find_program_from_stream(s, NULL, i))
618 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
619 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
623 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
624 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
628 AVProgram *program = first_program;
630 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
631 pts_wrap_reference = program->pts_wrap_reference;
632 pts_wrap_behavior = program->pts_wrap_behavior;
635 program = av_find_program_from_stream(s, program, stream_index);
638 // update every program with differing pts_wrap_reference
639 program = first_program;
641 if (program->pts_wrap_reference != pts_wrap_reference) {
642 for (i = 0; i<program->nb_stream_indexes; i++) {
643 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
644 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
647 program->pts_wrap_reference = pts_wrap_reference;
648 program->pts_wrap_behavior = pts_wrap_behavior;
650 program = av_find_program_from_stream(s, program, stream_index);
656 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
662 AVPacketList *pktl = s->internal->raw_packet_buffer;
666 st = s->streams[pkt->stream_index];
667 if (s->internal->raw_packet_buffer_remaining_size <= 0)
668 if ((err = probe_codec(s, st, NULL)) < 0)
670 if (st->request_probe <= 0) {
671 s->internal->raw_packet_buffer = pktl->next;
672 s->internal->raw_packet_buffer_remaining_size += pkt->size;
681 ret = s->iformat->read_packet(s, pkt);
683 /* Some demuxers return FFERROR_REDO when they consume
684 data and discard it (ignored streams, junk, extradata).
685 We must re-call the demuxer to get the real packet. */
686 if (ret == FFERROR_REDO)
688 if (!pktl || ret == AVERROR(EAGAIN))
690 for (i = 0; i < s->nb_streams; i++) {
692 if (st->probe_packets)
693 if ((err = probe_codec(s, st, NULL)) < 0)
695 av_assert0(st->request_probe <= 0);
701 AVPacket tmp = { 0 };
702 ret = av_packet_ref(&tmp, pkt);
708 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
709 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
710 av_log(s, AV_LOG_WARNING,
711 "Dropped corrupted packet (stream = %d)\n",
713 av_packet_unref(pkt);
717 if (pkt->stream_index >= (unsigned)s->nb_streams) {
718 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
722 st = s->streams[pkt->stream_index];
724 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
725 // correct first time stamps to negative values
726 if (!is_relative(st->first_dts))
727 st->first_dts = wrap_timestamp(st, st->first_dts);
728 if (!is_relative(st->start_time))
729 st->start_time = wrap_timestamp(st, st->start_time);
730 if (!is_relative(st->cur_dts))
731 st->cur_dts = wrap_timestamp(st, st->cur_dts);
734 pkt->dts = wrap_timestamp(st, pkt->dts);
735 pkt->pts = wrap_timestamp(st, pkt->pts);
737 force_codec_ids(s, st);
739 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
740 if (s->use_wallclock_as_timestamps)
741 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
743 if (!pktl && st->request_probe <= 0)
746 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
747 &s->internal->raw_packet_buffer_end, 0);
750 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
752 if ((err = probe_codec(s, st, pkt)) < 0)
758 /**********************************************************/
760 static int determinable_frame_size(AVCodecContext *avctx)
762 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
763 avctx->codec_id == AV_CODEC_ID_MP1 ||
764 avctx->codec_id == AV_CODEC_ID_MP2 ||
765 avctx->codec_id == AV_CODEC_ID_MP3/* ||
766 avctx->codec_id == AV_CODEC_ID_CELT*/)
772 * Return the frame duration in seconds. Return 0 if not available.
774 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
775 AVCodecParserContext *pc, AVPacket *pkt)
777 AVRational codec_framerate = s->iformat ? st->codec->framerate :
778 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
783 switch (st->codec->codec_type) {
784 case AVMEDIA_TYPE_VIDEO:
785 if (st->r_frame_rate.num && !pc && s->iformat) {
786 *pnum = st->r_frame_rate.den;
787 *pden = st->r_frame_rate.num;
788 } else if (st->time_base.num * 1000LL > st->time_base.den) {
789 *pnum = st->time_base.num;
790 *pden = st->time_base.den;
791 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
792 av_assert0(st->codec->ticks_per_frame);
793 av_reduce(pnum, pden,
795 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
798 if (pc && pc->repeat_pict) {
799 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
800 av_reduce(pnum, pden,
801 (*pnum) * (1LL + pc->repeat_pict),
805 /* If this codec can be interlaced or progressive then we need
806 * a parser to compute duration of a packet. Thus if we have
807 * no parser in such case leave duration undefined. */
808 if (st->codec->ticks_per_frame > 1 && !pc)
812 case AVMEDIA_TYPE_AUDIO:
813 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
814 if (frame_size <= 0 || st->codec->sample_rate <= 0)
817 *pden = st->codec->sample_rate;
824 static int is_intra_only(AVCodecContext *enc) {
825 const AVCodecDescriptor *desc;
827 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
830 desc = av_codec_get_codec_descriptor(enc);
832 desc = avcodec_descriptor_get(enc->codec_id);
833 av_codec_set_codec_descriptor(enc, desc);
836 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
840 static int has_decode_delay_been_guessed(AVStream *st)
842 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
843 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
845 #if CONFIG_H264_DECODER
846 if (st->codec->has_b_frames &&
847 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
850 if (st->codec->has_b_frames<3)
851 return st->nb_decoded_frames >= 7;
852 else if (st->codec->has_b_frames<4)
853 return st->nb_decoded_frames >= 18;
855 return st->nb_decoded_frames >= 20;
858 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
862 if (pktl == s->internal->packet_buffer_end)
863 return s->internal->parse_queue;
867 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
868 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
869 st->codec->codec_id != AV_CODEC_ID_HEVC;
872 int delay = st->codec->has_b_frames;
875 if (dts == AV_NOPTS_VALUE) {
876 int64_t best_score = INT64_MAX;
877 for (i = 0; i<delay; i++) {
878 if (st->pts_reorder_error_count[i]) {
879 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
880 if (score < best_score) {
887 for (i = 0; i<delay; i++) {
888 if (pts_buffer[i] != AV_NOPTS_VALUE) {
889 int64_t diff = FFABS(pts_buffer[i] - dts)
890 + (uint64_t)st->pts_reorder_error[i];
891 diff = FFMAX(diff, st->pts_reorder_error[i]);
892 st->pts_reorder_error[i] = diff;
893 st->pts_reorder_error_count[i]++;
894 if (st->pts_reorder_error_count[i] > 250) {
895 st->pts_reorder_error[i] >>= 1;
896 st->pts_reorder_error_count[i] >>= 1;
903 if (dts == AV_NOPTS_VALUE)
909 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
910 int64_t dts, int64_t pts, AVPacket *pkt)
912 AVStream *st = s->streams[stream_index];
913 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
914 int64_t pts_buffer[MAX_REORDER_DELAY+1];
918 if (st->first_dts != AV_NOPTS_VALUE ||
919 dts == AV_NOPTS_VALUE ||
920 st->cur_dts == AV_NOPTS_VALUE ||
924 delay = st->codec->has_b_frames;
925 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
927 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
929 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
930 pts_buffer[i] = AV_NOPTS_VALUE;
932 if (is_relative(pts))
935 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
936 if (pktl->pkt.stream_index != stream_index)
938 if (is_relative(pktl->pkt.pts))
939 pktl->pkt.pts += shift;
941 if (is_relative(pktl->pkt.dts))
942 pktl->pkt.dts += shift;
944 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
945 st->start_time = pktl->pkt.pts;
947 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
948 pts_buffer[0] = pktl->pkt.pts;
949 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
950 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
952 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
956 if (st->start_time == AV_NOPTS_VALUE)
957 st->start_time = pts;
960 static void update_initial_durations(AVFormatContext *s, AVStream *st,
961 int stream_index, int duration)
963 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
964 int64_t cur_dts = RELATIVE_TS_BASE;
966 if (st->first_dts != AV_NOPTS_VALUE) {
967 if (st->update_initial_durations_done)
969 st->update_initial_durations_done = 1;
970 cur_dts = st->first_dts;
971 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
972 if (pktl->pkt.stream_index == stream_index) {
973 if (pktl->pkt.pts != pktl->pkt.dts ||
974 pktl->pkt.dts != AV_NOPTS_VALUE ||
980 if (pktl && pktl->pkt.dts != st->first_dts) {
981 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
982 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
986 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
989 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
990 st->first_dts = cur_dts;
991 } else if (st->cur_dts != RELATIVE_TS_BASE)
994 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
995 if (pktl->pkt.stream_index != stream_index)
997 if (pktl->pkt.pts == pktl->pkt.dts &&
998 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
999 !pktl->pkt.duration) {
1000 pktl->pkt.dts = cur_dts;
1001 if (!st->codec->has_b_frames)
1002 pktl->pkt.pts = cur_dts;
1003 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1004 pktl->pkt.duration = duration;
1007 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1010 st->cur_dts = cur_dts;
1013 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1014 AVCodecParserContext *pc, AVPacket *pkt,
1015 int64_t next_dts, int64_t next_pts)
1017 int num, den, presentation_delayed, delay, i;
1019 AVRational duration;
1020 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1021 st->codec->codec_id != AV_CODEC_ID_HEVC;
1023 if (s->flags & AVFMT_FLAG_NOFILLIN)
1026 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1027 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1028 if (st->last_dts_for_order_check <= pkt->dts) {
1031 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1032 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1034 st->last_dts_for_order_check);
1035 st->dts_misordered++;
1037 if (st->dts_ordered + st->dts_misordered > 250) {
1038 st->dts_ordered >>= 1;
1039 st->dts_misordered >>= 1;
1043 st->last_dts_for_order_check = pkt->dts;
1044 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1045 pkt->dts = AV_NOPTS_VALUE;
1048 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1049 pkt->dts = AV_NOPTS_VALUE;
1051 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1052 && !st->codec->has_b_frames)
1053 //FIXME Set low_delay = 0 when has_b_frames = 1
1054 st->codec->has_b_frames = 1;
1056 /* do we have a video B-frame ? */
1057 delay = st->codec->has_b_frames;
1058 presentation_delayed = 0;
1060 /* XXX: need has_b_frame, but cannot get it if the codec is
1061 * not initialized */
1063 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1064 presentation_delayed = 1;
1066 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1067 st->pts_wrap_bits < 63 &&
1068 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1069 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1070 pkt->dts -= 1LL << st->pts_wrap_bits;
1072 pkt->pts += 1LL << st->pts_wrap_bits;
1075 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1076 * We take the conservative approach and discard both.
1077 * Note: If this is misbehaving for an H.264 file, then possibly
1078 * presentation_delayed is not set correctly. */
1079 if (delay == 1 && pkt->dts == pkt->pts &&
1080 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1081 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1082 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1083 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1084 pkt->dts = AV_NOPTS_VALUE;
1087 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1088 if (pkt->duration == 0) {
1089 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1091 duration = (AVRational) {num, den};
1092 pkt->duration = av_rescale_rnd(1,
1093 num * (int64_t) st->time_base.den,
1094 den * (int64_t) st->time_base.num,
1099 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1100 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1102 /* Correct timestamps with byte offset if demuxers only have timestamps
1103 * on packet boundaries */
1104 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1105 /* this will estimate bitrate based on this frame's duration and size */
1106 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1107 if (pkt->pts != AV_NOPTS_VALUE)
1109 if (pkt->dts != AV_NOPTS_VALUE)
1113 /* This may be redundant, but it should not hurt. */
1114 if (pkt->dts != AV_NOPTS_VALUE &&
1115 pkt->pts != AV_NOPTS_VALUE &&
1116 pkt->pts > pkt->dts)
1117 presentation_delayed = 1;
1119 if (s->debug & FF_FDEBUG_TS)
1120 av_log(s, AV_LOG_TRACE,
1121 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1122 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1123 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1125 /* Interpolate PTS and DTS if they are not present. We skip H264
1126 * currently because delay and has_b_frames are not reliably set. */
1127 if ((delay == 0 || (delay == 1 && pc)) &&
1129 if (presentation_delayed) {
1130 /* DTS = decompression timestamp */
1131 /* PTS = presentation timestamp */
1132 if (pkt->dts == AV_NOPTS_VALUE)
1133 pkt->dts = st->last_IP_pts;
1134 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1135 if (pkt->dts == AV_NOPTS_VALUE)
1136 pkt->dts = st->cur_dts;
1138 /* This is tricky: the dts must be incremented by the duration
1139 * of the frame we are displaying, i.e. the last I- or P-frame. */
1140 if (st->last_IP_duration == 0)
1141 st->last_IP_duration = pkt->duration;
1142 if (pkt->dts != AV_NOPTS_VALUE)
1143 st->cur_dts = pkt->dts + st->last_IP_duration;
1144 if (pkt->dts != AV_NOPTS_VALUE &&
1145 pkt->pts == AV_NOPTS_VALUE &&
1146 st->last_IP_duration > 0 &&
1147 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1148 next_dts != next_pts &&
1149 next_pts != AV_NOPTS_VALUE)
1150 pkt->pts = next_dts;
1152 st->last_IP_duration = pkt->duration;
1153 st->last_IP_pts = pkt->pts;
1154 /* Cannot compute PTS if not present (we can compute it only
1155 * by knowing the future. */
1156 } else if (pkt->pts != AV_NOPTS_VALUE ||
1157 pkt->dts != AV_NOPTS_VALUE ||
1160 /* presentation is not delayed : PTS and DTS are the same */
1161 if (pkt->pts == AV_NOPTS_VALUE)
1162 pkt->pts = pkt->dts;
1163 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1165 if (pkt->pts == AV_NOPTS_VALUE)
1166 pkt->pts = st->cur_dts;
1167 pkt->dts = pkt->pts;
1168 if (pkt->pts != AV_NOPTS_VALUE)
1169 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1173 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1174 st->pts_buffer[0] = pkt->pts;
1175 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1176 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1178 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1180 // We skipped it above so we try here.
1182 // This should happen on the first packet
1183 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1184 if (pkt->dts > st->cur_dts)
1185 st->cur_dts = pkt->dts;
1187 if (s->debug & FF_FDEBUG_TS)
1188 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1189 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1192 if (is_intra_only(st->codec))
1193 pkt->flags |= AV_PKT_FLAG_KEY;
1194 #if FF_API_CONVERGENCE_DURATION
1195 FF_DISABLE_DEPRECATION_WARNINGS
1197 pkt->convergence_duration = pc->convergence_duration;
1198 FF_ENABLE_DEPRECATION_WARNINGS
1202 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1205 AVPacketList *pktl = *pkt_buf;
1206 *pkt_buf = pktl->next;
1207 av_packet_unref(&pktl->pkt);
1210 *pkt_buf_end = NULL;
1214 * Parse a packet, add all split parts to parse_queue.
1216 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1218 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1220 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1221 AVStream *st = s->streams[stream_index];
1222 uint8_t *data = pkt ? pkt->data : NULL;
1223 int size = pkt ? pkt->size : 0;
1224 int ret = 0, got_output = 0;
1227 av_init_packet(&flush_pkt);
1230 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1231 // preserve 0-size sync packets
1232 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1235 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1237 int64_t next_pts = pkt->pts;
1238 int64_t next_dts = pkt->dts;
1240 av_init_packet(&out_pkt);
1241 len = av_parser_parse2(st->parser, st->codec,
1242 &out_pkt.data, &out_pkt.size, data, size,
1243 pkt->pts, pkt->dts, pkt->pos);
1245 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1247 /* increment read pointer */
1251 got_output = !!out_pkt.size;
1256 if (pkt->side_data) {
1257 out_pkt.side_data = pkt->side_data;
1258 out_pkt.side_data_elems = pkt->side_data_elems;
1259 pkt->side_data = NULL;
1260 pkt->side_data_elems = 0;
1263 /* set the duration */
1264 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1265 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1266 if (st->codec->sample_rate > 0) {
1268 av_rescale_q_rnd(st->parser->duration,
1269 (AVRational) { 1, st->codec->sample_rate },
1275 out_pkt.stream_index = st->index;
1276 out_pkt.pts = st->parser->pts;
1277 out_pkt.dts = st->parser->dts;
1278 out_pkt.pos = st->parser->pos;
1280 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1281 out_pkt.pos = st->parser->frame_offset;
1283 if (st->parser->key_frame == 1 ||
1284 (st->parser->key_frame == -1 &&
1285 st->parser->pict_type == AV_PICTURE_TYPE_I))
1286 out_pkt.flags |= AV_PKT_FLAG_KEY;
1288 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1289 out_pkt.flags |= AV_PKT_FLAG_KEY;
1291 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1293 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1294 &s->internal->parse_queue_end, 1);
1295 av_packet_unref(&out_pkt);
1300 /* end of the stream => close and free the parser */
1301 if (pkt == &flush_pkt) {
1302 av_parser_close(st->parser);
1307 av_packet_unref(pkt);
1311 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1312 AVPacketList **pkt_buffer_end,
1316 av_assert0(*pkt_buffer);
1319 *pkt_buffer = pktl->next;
1321 *pkt_buffer_end = NULL;
1326 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1328 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1331 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1333 int ret = 0, i, got_packet = 0;
1334 AVDictionary *metadata = NULL;
1336 av_init_packet(pkt);
1338 while (!got_packet && !s->internal->parse_queue) {
1342 /* read next packet */
1343 ret = ff_read_packet(s, &cur_pkt);
1345 if (ret == AVERROR(EAGAIN))
1347 /* flush the parsers */
1348 for (i = 0; i < s->nb_streams; i++) {
1350 if (st->parser && st->need_parsing)
1351 parse_packet(s, NULL, st->index);
1353 /* all remaining packets are now in parse_queue =>
1354 * really terminate parsing */
1358 st = s->streams[cur_pkt.stream_index];
1360 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1361 cur_pkt.dts != AV_NOPTS_VALUE &&
1362 cur_pkt.pts < cur_pkt.dts) {
1363 av_log(s, AV_LOG_WARNING,
1364 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1365 cur_pkt.stream_index,
1366 av_ts2str(cur_pkt.pts),
1367 av_ts2str(cur_pkt.dts),
1370 if (s->debug & FF_FDEBUG_TS)
1371 av_log(s, AV_LOG_DEBUG,
1372 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1373 cur_pkt.stream_index,
1374 av_ts2str(cur_pkt.pts),
1375 av_ts2str(cur_pkt.dts),
1376 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1378 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1379 st->parser = av_parser_init(st->codec->codec_id);
1381 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1382 "%s, packets or times may be invalid.\n",
1383 avcodec_get_name(st->codec->codec_id));
1384 /* no parser available: just output the raw packets */
1385 st->need_parsing = AVSTREAM_PARSE_NONE;
1386 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1387 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1388 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1389 st->parser->flags |= PARSER_FLAG_ONCE;
1390 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1391 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1394 if (!st->need_parsing || !st->parser) {
1395 /* no parsing needed: we just output the packet as is */
1397 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1398 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1399 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1400 ff_reduce_index(s, st->index);
1401 av_add_index_entry(st, pkt->pos, pkt->dts,
1402 0, 0, AVINDEX_KEYFRAME);
1405 } else if (st->discard < AVDISCARD_ALL) {
1406 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1410 av_packet_unref(&cur_pkt);
1412 if (pkt->flags & AV_PKT_FLAG_KEY)
1413 st->skip_to_keyframe = 0;
1414 if (st->skip_to_keyframe) {
1415 av_packet_unref(&cur_pkt);
1423 if (!got_packet && s->internal->parse_queue)
1424 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1427 AVStream *st = s->streams[pkt->stream_index];
1428 int discard_padding = 0;
1429 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1430 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1431 int64_t sample = ts_to_samples(st, pts);
1432 int duration = ts_to_samples(st, pkt->duration);
1433 int64_t end_sample = sample + duration;
1434 if (duration > 0 && end_sample >= st->first_discard_sample &&
1435 sample < st->last_discard_sample)
1436 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1438 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1439 st->skip_samples = st->start_skip_samples;
1440 if (st->skip_samples || discard_padding) {
1441 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1443 AV_WL32(p, st->skip_samples);
1444 AV_WL32(p + 4, discard_padding);
1445 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1447 st->skip_samples = 0;
1450 if (st->inject_global_side_data) {
1451 for (i = 0; i < st->nb_side_data; i++) {
1452 AVPacketSideData *src_sd = &st->side_data[i];
1455 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1458 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1460 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1464 memcpy(dst_data, src_sd->data, src_sd->size);
1466 st->inject_global_side_data = 0;
1469 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1470 av_packet_merge_side_data(pkt);
1473 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1475 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1476 av_dict_copy(&s->metadata, metadata, 0);
1477 av_dict_free(&metadata);
1478 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1481 if (s->debug & FF_FDEBUG_TS)
1482 av_log(s, AV_LOG_DEBUG,
1483 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1484 "size=%d, duration=%"PRId64", flags=%d\n",
1486 av_ts2str(pkt->pts),
1487 av_ts2str(pkt->dts),
1488 pkt->size, pkt->duration, pkt->flags);
1493 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1495 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1501 ret = s->internal->packet_buffer
1502 ? read_from_packet_buffer(&s->internal->packet_buffer,
1503 &s->internal->packet_buffer_end, pkt)
1504 : read_frame_internal(s, pkt);
1511 AVPacketList *pktl = s->internal->packet_buffer;
1514 AVPacket *next_pkt = &pktl->pkt;
1516 if (next_pkt->dts != AV_NOPTS_VALUE) {
1517 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1518 // last dts seen for this stream. if any of packets following
1519 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1520 int64_t last_dts = next_pkt->dts;
1521 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1522 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1523 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1524 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1526 next_pkt->pts = pktl->pkt.dts;
1528 if (last_dts != AV_NOPTS_VALUE) {
1529 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1530 last_dts = pktl->pkt.dts;
1535 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1536 // Fixing the last reference frame had none pts issue (For MXF etc).
1537 // We only do this when
1539 // 2. we are not able to resolve a pts value for current packet.
1540 // 3. the packets for this stream at the end of the files had valid dts.
1541 next_pkt->pts = last_dts + next_pkt->duration;
1543 pktl = s->internal->packet_buffer;
1546 /* read packet from packet buffer, if there is data */
1547 st = s->streams[next_pkt->stream_index];
1548 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1549 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1550 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1551 &s->internal->packet_buffer_end, pkt);
1556 ret = read_frame_internal(s, pkt);
1558 if (pktl && ret != AVERROR(EAGAIN)) {
1565 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1566 &s->internal->packet_buffer_end, 1);
1567 av_packet_unref(pkt);
1574 st = s->streams[pkt->stream_index];
1575 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1576 ff_reduce_index(s, st->index);
1577 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1580 if (is_relative(pkt->dts))
1581 pkt->dts -= RELATIVE_TS_BASE;
1582 if (is_relative(pkt->pts))
1583 pkt->pts -= RELATIVE_TS_BASE;
1588 /* XXX: suppress the packet queue */
1589 static void flush_packet_queue(AVFormatContext *s)
1593 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1594 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1595 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1597 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1600 /*******************************************************/
1603 int av_find_default_stream_index(AVFormatContext *s)
1607 int best_stream = 0;
1608 int best_score = INT_MIN;
1610 if (s->nb_streams <= 0)
1612 for (i = 0; i < s->nb_streams; i++) {
1615 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1616 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1618 if (st->codec->width && st->codec->height)
1622 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1623 if (st->codec->sample_rate)
1626 if (st->codec_info_nb_frames)
1629 if (st->discard != AVDISCARD_ALL)
1632 if (score > best_score) {
1640 /** Flush the frame reader. */
1641 void ff_read_frame_flush(AVFormatContext *s)
1646 flush_packet_queue(s);
1648 /* Reset read state for each stream. */
1649 for (i = 0; i < s->nb_streams; i++) {
1653 av_parser_close(st->parser);
1656 st->last_IP_pts = AV_NOPTS_VALUE;
1657 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1658 if (st->first_dts == AV_NOPTS_VALUE)
1659 st->cur_dts = RELATIVE_TS_BASE;
1661 /* We set the current DTS to an unspecified origin. */
1662 st->cur_dts = AV_NOPTS_VALUE;
1664 st->probe_packets = MAX_PROBE_PACKETS;
1666 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1667 st->pts_buffer[j] = AV_NOPTS_VALUE;
1669 if (s->internal->inject_global_side_data)
1670 st->inject_global_side_data = 1;
1672 st->skip_samples = 0;
1676 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1680 for (i = 0; i < s->nb_streams; i++) {
1681 AVStream *st = s->streams[i];
1684 av_rescale(timestamp,
1685 st->time_base.den * (int64_t) ref_st->time_base.num,
1686 st->time_base.num * (int64_t) ref_st->time_base.den);
1690 void ff_reduce_index(AVFormatContext *s, int stream_index)
1692 AVStream *st = s->streams[stream_index];
1693 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1695 if ((unsigned) st->nb_index_entries >= max_entries) {
1697 for (i = 0; 2 * i < st->nb_index_entries; i++)
1698 st->index_entries[i] = st->index_entries[2 * i];
1699 st->nb_index_entries = i;
1703 int ff_add_index_entry(AVIndexEntry **index_entries,
1704 int *nb_index_entries,
1705 unsigned int *index_entries_allocated_size,
1706 int64_t pos, int64_t timestamp,
1707 int size, int distance, int flags)
1709 AVIndexEntry *entries, *ie;
1712 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1715 if (timestamp == AV_NOPTS_VALUE)
1716 return AVERROR(EINVAL);
1718 if (size < 0 || size > 0x3FFFFFFF)
1719 return AVERROR(EINVAL);
1721 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1722 timestamp -= RELATIVE_TS_BASE;
1724 entries = av_fast_realloc(*index_entries,
1725 index_entries_allocated_size,
1726 (*nb_index_entries + 1) *
1727 sizeof(AVIndexEntry));
1731 *index_entries = entries;
1733 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1734 timestamp, AVSEEK_FLAG_ANY);
1737 index = (*nb_index_entries)++;
1738 ie = &entries[index];
1739 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1741 ie = &entries[index];
1742 if (ie->timestamp != timestamp) {
1743 if (ie->timestamp <= timestamp)
1745 memmove(entries + index + 1, entries + index,
1746 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1747 (*nb_index_entries)++;
1748 } else if (ie->pos == pos && distance < ie->min_distance)
1749 // do not reduce the distance
1750 distance = ie->min_distance;
1754 ie->timestamp = timestamp;
1755 ie->min_distance = distance;
1762 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1763 int size, int distance, int flags)
1765 timestamp = wrap_timestamp(st, timestamp);
1766 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1767 &st->index_entries_allocated_size, pos,
1768 timestamp, size, distance, flags);
1771 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1772 int64_t wanted_timestamp, int flags)
1780 // Optimize appending index entries at the end.
1781 if (b && entries[b - 1].timestamp < wanted_timestamp)
1786 timestamp = entries[m].timestamp;
1787 if (timestamp >= wanted_timestamp)
1789 if (timestamp <= wanted_timestamp)
1792 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1794 if (!(flags & AVSEEK_FLAG_ANY))
1795 while (m >= 0 && m < nb_entries &&
1796 !(entries[m].flags & AVINDEX_KEYFRAME))
1797 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1799 if (m == nb_entries)
1804 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1807 int64_t pos_delta = 0;
1809 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1810 const char *proto = avio_find_protocol_name(s->filename);
1813 av_log(s, AV_LOG_INFO,
1814 "Protocol name not provided, cannot determine if input is local or "
1815 "a network protocol, buffers and access patterns cannot be configured "
1816 "optimally without knowing the protocol\n");
1819 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1822 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1823 AVStream *st1 = s->streams[ist1];
1824 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1825 AVStream *st2 = s->streams[ist2];
1831 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1832 AVIndexEntry *e1 = &st1->index_entries[i1];
1833 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1835 skip = FFMAX(skip, e1->size);
1836 for (; i2 < st2->nb_index_entries; i2++) {
1837 AVIndexEntry *e2 = &st2->index_entries[i2];
1838 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1839 if (e2_pts - e1_pts < time_tolerance)
1841 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1849 /* XXX This could be adjusted depending on protocol*/
1850 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1851 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1852 ffio_set_buf_size(s->pb, pos_delta);
1853 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1856 if (skip < (1<<23)) {
1857 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1861 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1863 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1864 wanted_timestamp, flags);
1867 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1868 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1870 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1871 if (stream_index >= 0)
1872 ts = wrap_timestamp(s->streams[stream_index], ts);
1876 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1877 int64_t target_ts, int flags)
1879 AVInputFormat *avif = s->iformat;
1880 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1881 int64_t ts_min, ts_max, ts;
1886 if (stream_index < 0)
1889 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1892 ts_min = AV_NOPTS_VALUE;
1893 pos_limit = -1; // GCC falsely says it may be uninitialized.
1895 st = s->streams[stream_index];
1896 if (st->index_entries) {
1899 /* FIXME: Whole function must be checked for non-keyframe entries in
1900 * index case, especially read_timestamp(). */
1901 index = av_index_search_timestamp(st, target_ts,
1902 flags | AVSEEK_FLAG_BACKWARD);
1903 index = FFMAX(index, 0);
1904 e = &st->index_entries[index];
1906 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1908 ts_min = e->timestamp;
1909 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1910 pos_min, av_ts2str(ts_min));
1912 av_assert1(index == 0);
1915 index = av_index_search_timestamp(st, target_ts,
1916 flags & ~AVSEEK_FLAG_BACKWARD);
1917 av_assert0(index < st->nb_index_entries);
1919 e = &st->index_entries[index];
1920 av_assert1(e->timestamp >= target_ts);
1922 ts_max = e->timestamp;
1923 pos_limit = pos_max - e->min_distance;
1924 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1925 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1929 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1930 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1935 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1938 ff_read_frame_flush(s);
1939 ff_update_cur_dts(s, st, ts);
1944 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1945 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1947 int64_t step = 1024;
1948 int64_t limit, ts_max;
1949 int64_t filesize = avio_size(s->pb);
1950 int64_t pos_max = filesize - 1;
1953 pos_max = FFMAX(0, (pos_max) - step);
1954 ts_max = ff_read_timestamp(s, stream_index,
1955 &pos_max, limit, read_timestamp);
1957 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1958 if (ts_max == AV_NOPTS_VALUE)
1962 int64_t tmp_pos = pos_max + 1;
1963 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1964 &tmp_pos, INT64_MAX, read_timestamp);
1965 if (tmp_ts == AV_NOPTS_VALUE)
1967 av_assert0(tmp_pos > pos_max);
1970 if (tmp_pos >= filesize)
1982 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1983 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1984 int64_t ts_min, int64_t ts_max,
1985 int flags, int64_t *ts_ret,
1986 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1987 int64_t *, int64_t))
1994 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1996 if (ts_min == AV_NOPTS_VALUE) {
1997 pos_min = s->internal->data_offset;
1998 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1999 if (ts_min == AV_NOPTS_VALUE)
2003 if (ts_min >= target_ts) {
2008 if (ts_max == AV_NOPTS_VALUE) {
2009 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2011 pos_limit = pos_max;
2014 if (ts_max <= target_ts) {
2019 av_assert0(ts_min < ts_max);
2022 while (pos_min < pos_limit) {
2023 av_log(s, AV_LOG_TRACE,
2024 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2025 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2026 av_assert0(pos_limit <= pos_max);
2028 if (no_change == 0) {
2029 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2030 // interpolate position (better than dichotomy)
2031 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2033 pos_min - approximate_keyframe_distance;
2034 } else if (no_change == 1) {
2035 // bisection if interpolation did not change min / max pos last time
2036 pos = (pos_min + pos_limit) >> 1;
2038 /* linear search if bisection failed, can only happen if there
2039 * are very few or no keyframes between min/max */
2044 else if (pos > pos_limit)
2048 // May pass pos_limit instead of -1.
2049 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2054 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2055 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2056 pos_min, pos, pos_max,
2057 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2058 pos_limit, start_pos, no_change);
2059 if (ts == AV_NOPTS_VALUE) {
2060 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2063 if (target_ts <= ts) {
2064 pos_limit = start_pos - 1;
2068 if (target_ts >= ts) {
2074 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2075 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2078 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2080 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2081 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2082 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2088 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2089 int64_t pos, int flags)
2091 int64_t pos_min, pos_max;
2093 pos_min = s->internal->data_offset;
2094 pos_max = avio_size(s->pb) - 1;
2098 else if (pos > pos_max)
2101 avio_seek(s->pb, pos, SEEK_SET);
2103 s->io_repositioned = 1;
2108 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2109 int64_t timestamp, int flags)
2116 st = s->streams[stream_index];
2118 index = av_index_search_timestamp(st, timestamp, flags);
2120 if (index < 0 && st->nb_index_entries &&
2121 timestamp < st->index_entries[0].timestamp)
2124 if (index < 0 || index == st->nb_index_entries - 1) {
2128 if (st->nb_index_entries) {
2129 av_assert0(st->index_entries);
2130 ie = &st->index_entries[st->nb_index_entries - 1];
2131 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2133 ff_update_cur_dts(s, st, ie->timestamp);
2135 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2141 read_status = av_read_frame(s, &pkt);
2142 } while (read_status == AVERROR(EAGAIN));
2143 if (read_status < 0)
2145 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2146 if (pkt.flags & AV_PKT_FLAG_KEY) {
2147 av_packet_unref(&pkt);
2150 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2151 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);
2152 av_packet_unref(&pkt);
2156 av_packet_unref(&pkt);
2158 index = av_index_search_timestamp(st, timestamp, flags);
2163 ff_read_frame_flush(s);
2164 if (s->iformat->read_seek)
2165 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2167 ie = &st->index_entries[index];
2168 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2170 ff_update_cur_dts(s, st, ie->timestamp);
2175 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2176 int64_t timestamp, int flags)
2181 if (flags & AVSEEK_FLAG_BYTE) {
2182 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2184 ff_read_frame_flush(s);
2185 return seek_frame_byte(s, stream_index, timestamp, flags);
2188 if (stream_index < 0) {
2189 stream_index = av_find_default_stream_index(s);
2190 if (stream_index < 0)
2193 st = s->streams[stream_index];
2194 /* timestamp for default must be expressed in AV_TIME_BASE units */
2195 timestamp = av_rescale(timestamp, st->time_base.den,
2196 AV_TIME_BASE * (int64_t) st->time_base.num);
2199 /* first, we try the format specific seek */
2200 if (s->iformat->read_seek) {
2201 ff_read_frame_flush(s);
2202 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2208 if (s->iformat->read_timestamp &&
2209 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2210 ff_read_frame_flush(s);
2211 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2212 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2213 ff_read_frame_flush(s);
2214 return seek_frame_generic(s, stream_index, timestamp, flags);
2219 int av_seek_frame(AVFormatContext *s, int stream_index,
2220 int64_t timestamp, int flags)
2224 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2225 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2226 if ((flags & AVSEEK_FLAG_BACKWARD))
2230 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2231 flags & ~AVSEEK_FLAG_BACKWARD);
2234 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2237 ret = avformat_queue_attached_pictures(s);
2242 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2243 int64_t ts, int64_t max_ts, int flags)
2245 if (min_ts > ts || max_ts < ts)
2247 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2248 return AVERROR(EINVAL);
2251 flags |= AVSEEK_FLAG_ANY;
2252 flags &= ~AVSEEK_FLAG_BACKWARD;
2254 if (s->iformat->read_seek2) {
2256 ff_read_frame_flush(s);
2258 if (stream_index == -1 && s->nb_streams == 1) {
2259 AVRational time_base = s->streams[0]->time_base;
2260 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2261 min_ts = av_rescale_rnd(min_ts, time_base.den,
2262 time_base.num * (int64_t)AV_TIME_BASE,
2263 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2264 max_ts = av_rescale_rnd(max_ts, time_base.den,
2265 time_base.num * (int64_t)AV_TIME_BASE,
2266 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2269 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2273 ret = avformat_queue_attached_pictures(s);
2277 if (s->iformat->read_timestamp) {
2278 // try to seek via read_timestamp()
2281 // Fall back on old API if new is not implemented but old is.
2282 // Note the old API has somewhat different semantics.
2283 if (s->iformat->read_seek || 1) {
2284 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2285 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2286 if (ret<0 && ts != min_ts && max_ts != ts) {
2287 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2289 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2294 // try some generic seek like seek_frame_generic() but with new ts semantics
2295 return -1; //unreachable
2298 int avformat_flush(AVFormatContext *s)
2300 ff_read_frame_flush(s);
2304 /*******************************************************/
2307 * Return TRUE if the stream has accurate duration in any stream.
2309 * @return TRUE if the stream has accurate duration for at least one component.
2311 static int has_duration(AVFormatContext *ic)
2316 for (i = 0; i < ic->nb_streams; i++) {
2317 st = ic->streams[i];
2318 if (st->duration != AV_NOPTS_VALUE)
2321 if (ic->duration != AV_NOPTS_VALUE)
2327 * Estimate the stream timings from the one of each components.
2329 * Also computes the global bitrate if possible.
2331 static void update_stream_timings(AVFormatContext *ic)
2333 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2334 int64_t duration, duration1, filesize;
2339 start_time = INT64_MAX;
2340 start_time_text = INT64_MAX;
2341 end_time = INT64_MIN;
2342 duration = INT64_MIN;
2343 for (i = 0; i < ic->nb_streams; i++) {
2344 st = ic->streams[i];
2345 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2346 start_time1 = av_rescale_q(st->start_time, st->time_base,
2348 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2349 if (start_time1 < start_time_text)
2350 start_time_text = start_time1;
2352 start_time = FFMIN(start_time, start_time1);
2353 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2355 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2356 if (end_time1 != AV_NOPTS_VALUE) {
2357 end_time1 += start_time1;
2358 end_time = FFMAX(end_time, end_time1);
2360 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2361 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2362 p->start_time = start_time1;
2363 if (p->end_time < end_time1)
2364 p->end_time = end_time1;
2367 if (st->duration != AV_NOPTS_VALUE) {
2368 duration1 = av_rescale_q(st->duration, st->time_base,
2370 duration = FFMAX(duration, duration1);
2373 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2374 start_time = start_time_text;
2375 else if (start_time > start_time_text)
2376 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2378 if (start_time != INT64_MAX) {
2379 ic->start_time = start_time;
2380 if (end_time != INT64_MIN) {
2381 if (ic->nb_programs) {
2382 for (i = 0; i < ic->nb_programs; i++) {
2383 p = ic->programs[i];
2384 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2385 duration = FFMAX(duration, p->end_time - p->start_time);
2388 duration = FFMAX(duration, end_time - start_time);
2391 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2392 ic->duration = duration;
2394 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2395 /* compute the bitrate */
2396 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2397 (double) ic->duration;
2398 if (bitrate >= 0 && bitrate <= INT64_MAX)
2399 ic->bit_rate = bitrate;
2403 static void fill_all_stream_timings(AVFormatContext *ic)
2408 update_stream_timings(ic);
2409 for (i = 0; i < ic->nb_streams; i++) {
2410 st = ic->streams[i];
2411 if (st->start_time == AV_NOPTS_VALUE) {
2412 if (ic->start_time != AV_NOPTS_VALUE)
2413 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2415 if (ic->duration != AV_NOPTS_VALUE)
2416 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2422 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2424 int64_t filesize, duration;
2425 int i, show_warning = 0;
2428 /* if bit_rate is already set, we believe it */
2429 if (ic->bit_rate <= 0) {
2431 for (i = 0; i < ic->nb_streams; i++) {
2432 st = ic->streams[i];
2433 if (st->codec->bit_rate > 0) {
2434 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2438 bit_rate += st->codec->bit_rate;
2439 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2440 // If we have a videostream with packets but without a bitrate
2441 // then consider the sum not known
2446 ic->bit_rate = bit_rate;
2449 /* if duration is already set, we believe it */
2450 if (ic->duration == AV_NOPTS_VALUE &&
2451 ic->bit_rate != 0) {
2452 filesize = ic->pb ? avio_size(ic->pb) : 0;
2453 if (filesize > ic->internal->data_offset) {
2454 filesize -= ic->internal->data_offset;
2455 for (i = 0; i < ic->nb_streams; i++) {
2456 st = ic->streams[i];
2457 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2458 && st->duration == AV_NOPTS_VALUE) {
2459 duration = av_rescale(8 * filesize, st->time_base.den,
2461 (int64_t) st->time_base.num);
2462 st->duration = duration;
2469 av_log(ic, AV_LOG_WARNING,
2470 "Estimating duration from bitrate, this may be inaccurate\n");
2473 #define DURATION_MAX_READ_SIZE 250000LL
2474 #define DURATION_MAX_RETRY 6
2476 /* only usable for MPEG-PS streams */
2477 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2479 AVPacket pkt1, *pkt = &pkt1;
2481 int num, den, read_size, i, ret;
2482 int found_duration = 0;
2484 int64_t filesize, offset, duration;
2487 /* flush packet queue */
2488 flush_packet_queue(ic);
2490 for (i = 0; i < ic->nb_streams; i++) {
2491 st = ic->streams[i];
2492 if (st->start_time == AV_NOPTS_VALUE &&
2493 st->first_dts == AV_NOPTS_VALUE &&
2494 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2495 av_log(st->codec, AV_LOG_WARNING,
2496 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2499 av_parser_close(st->parser);
2504 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2505 /* estimate the end time (duration) */
2506 /* XXX: may need to support wrapping */
2507 filesize = ic->pb ? avio_size(ic->pb) : 0;
2509 is_end = found_duration;
2510 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2514 avio_seek(ic->pb, offset, SEEK_SET);
2517 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2521 ret = ff_read_packet(ic, pkt);
2522 } while (ret == AVERROR(EAGAIN));
2525 read_size += pkt->size;
2526 st = ic->streams[pkt->stream_index];
2527 if (pkt->pts != AV_NOPTS_VALUE &&
2528 (st->start_time != AV_NOPTS_VALUE ||
2529 st->first_dts != AV_NOPTS_VALUE)) {
2530 if (pkt->duration == 0) {
2531 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2533 pkt->duration = av_rescale_rnd(1,
2534 num * (int64_t) st->time_base.den,
2535 den * (int64_t) st->time_base.num,
2539 duration = pkt->pts + pkt->duration;
2541 if (st->start_time != AV_NOPTS_VALUE)
2542 duration -= st->start_time;
2544 duration -= st->first_dts;
2546 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2547 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2548 st->duration = duration;
2549 st->info->last_duration = duration;
2552 av_packet_unref(pkt);
2555 /* check if all audio/video streams have valid duration */
2558 for (i = 0; i < ic->nb_streams; i++) {
2559 st = ic->streams[i];
2560 switch (st->codec->codec_type) {
2561 case AVMEDIA_TYPE_VIDEO:
2562 case AVMEDIA_TYPE_AUDIO:
2563 if (st->duration == AV_NOPTS_VALUE)
2570 ++retry <= DURATION_MAX_RETRY);
2572 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2574 /* warn about audio/video streams which duration could not be estimated */
2575 for (i = 0; i < ic->nb_streams; i++) {
2576 st = ic->streams[i];
2577 if (st->duration == AV_NOPTS_VALUE) {
2578 switch (st->codec->codec_type) {
2579 case AVMEDIA_TYPE_VIDEO:
2580 case AVMEDIA_TYPE_AUDIO:
2581 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2582 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2584 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2588 fill_all_stream_timings(ic);
2590 avio_seek(ic->pb, old_offset, SEEK_SET);
2591 for (i = 0; i < ic->nb_streams; i++) {
2594 st = ic->streams[i];
2595 st->cur_dts = st->first_dts;
2596 st->last_IP_pts = AV_NOPTS_VALUE;
2597 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2598 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2599 st->pts_buffer[j] = AV_NOPTS_VALUE;
2603 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2607 /* get the file size, if possible */
2608 if (ic->iformat->flags & AVFMT_NOFILE) {
2611 file_size = avio_size(ic->pb);
2612 file_size = FFMAX(0, file_size);
2615 if ((!strcmp(ic->iformat->name, "mpeg") ||
2616 !strcmp(ic->iformat->name, "mpegts")) &&
2617 file_size && ic->pb->seekable) {
2618 /* get accurate estimate from the PTSes */
2619 estimate_timings_from_pts(ic, old_offset);
2620 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2621 } else if (has_duration(ic)) {
2622 /* at least one component has timings - we use them for all
2624 fill_all_stream_timings(ic);
2625 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2627 /* less precise: use bitrate info */
2628 estimate_timings_from_bit_rate(ic);
2629 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2631 update_stream_timings(ic);
2635 AVStream av_unused *st;
2636 for (i = 0; i < ic->nb_streams; i++) {
2637 st = ic->streams[i];
2638 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2639 (double) st->start_time / AV_TIME_BASE,
2640 (double) st->duration / AV_TIME_BASE);
2642 av_log(ic, AV_LOG_TRACE,
2643 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2644 (double) ic->start_time / AV_TIME_BASE,
2645 (double) ic->duration / AV_TIME_BASE,
2646 (int64_t)ic->bit_rate / 1000);
2650 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2652 AVCodecContext *avctx = st->codec;
2654 #define FAIL(errmsg) do { \
2656 *errmsg_ptr = errmsg; \
2660 if ( avctx->codec_id == AV_CODEC_ID_NONE
2661 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2662 FAIL("unknown codec");
2663 switch (avctx->codec_type) {
2664 case AVMEDIA_TYPE_AUDIO:
2665 if (!avctx->frame_size && determinable_frame_size(avctx))
2666 FAIL("unspecified frame size");
2667 if (st->info->found_decoder >= 0 &&
2668 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2669 FAIL("unspecified sample format");
2670 if (!avctx->sample_rate)
2671 FAIL("unspecified sample rate");
2672 if (!avctx->channels)
2673 FAIL("unspecified number of channels");
2674 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2675 FAIL("no decodable DTS frames");
2677 case AVMEDIA_TYPE_VIDEO:
2679 FAIL("unspecified size");
2680 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2681 FAIL("unspecified pixel format");
2682 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2683 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2684 FAIL("no frame in rv30/40 and no sar");
2686 case AVMEDIA_TYPE_SUBTITLE:
2687 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2688 FAIL("unspecified size");
2690 case AVMEDIA_TYPE_DATA:
2691 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2697 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2698 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2699 AVDictionary **options)
2701 const AVCodec *codec;
2702 int got_picture = 1, ret = 0;
2703 AVFrame *frame = av_frame_alloc();
2704 AVSubtitle subtitle;
2705 AVPacket pkt = *avpkt;
2706 int do_skip_frame = 0;
2707 enum AVDiscard skip_frame;
2710 return AVERROR(ENOMEM);
2712 if (!avcodec_is_open(st->codec) &&
2713 st->info->found_decoder <= 0 &&
2714 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2715 AVDictionary *thread_opt = NULL;
2717 codec = find_decoder(s, st, st->codec->codec_id);
2720 st->info->found_decoder = -st->codec->codec_id;
2725 /* Force thread count to 1 since the H.264 decoder will not extract
2726 * SPS and PPS to extradata during multi-threaded decoding. */
2727 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2728 if (s->codec_whitelist)
2729 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2730 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2732 av_dict_free(&thread_opt);
2734 st->info->found_decoder = -st->codec->codec_id;
2737 st->info->found_decoder = 1;
2738 } else if (!st->info->found_decoder)
2739 st->info->found_decoder = 1;
2741 if (st->info->found_decoder < 0) {
2746 if (st->codec->codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM) {
2748 skip_frame = st->codec->skip_frame;
2749 st->codec->skip_frame = AVDISCARD_ALL;
2752 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2754 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2755 (!st->codec_info_nb_frames &&
2756 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2758 switch (st->codec->codec_type) {
2759 case AVMEDIA_TYPE_VIDEO:
2760 ret = avcodec_decode_video2(st->codec, frame,
2761 &got_picture, &pkt);
2763 case AVMEDIA_TYPE_AUDIO:
2764 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2766 case AVMEDIA_TYPE_SUBTITLE:
2767 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2768 &got_picture, &pkt);
2776 st->nb_decoded_frames++;
2783 if (!pkt.data && !got_picture)
2787 if (do_skip_frame) {
2788 st->codec->skip_frame = skip_frame;
2791 av_frame_free(&frame);
2795 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2797 while (tags->id != AV_CODEC_ID_NONE) {
2805 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2808 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2809 if (tag == tags[i].tag)
2811 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2812 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2814 return AV_CODEC_ID_NONE;
2817 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2822 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2824 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2826 return AV_CODEC_ID_NONE;
2831 if (sflags & (1 << (bps - 1))) {
2834 return AV_CODEC_ID_PCM_S8;
2836 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2838 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2840 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2842 return AV_CODEC_ID_NONE;
2847 return AV_CODEC_ID_PCM_U8;
2849 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2851 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2853 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2855 return AV_CODEC_ID_NONE;
2861 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2864 if (!av_codec_get_tag2(tags, id, &tag))
2869 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2873 for (i = 0; tags && tags[i]; i++) {
2874 const AVCodecTag *codec_tags = tags[i];
2875 while (codec_tags->id != AV_CODEC_ID_NONE) {
2876 if (codec_tags->id == id) {
2877 *tag = codec_tags->tag;
2886 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2889 for (i = 0; tags && tags[i]; i++) {
2890 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2891 if (id != AV_CODEC_ID_NONE)
2894 return AV_CODEC_ID_NONE;
2897 static void compute_chapters_end(AVFormatContext *s)
2900 int64_t max_time = 0;
2902 if (s->duration > 0)
2903 max_time = s->duration +
2904 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2906 for (i = 0; i < s->nb_chapters; i++)
2907 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2908 AVChapter *ch = s->chapters[i];
2909 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2913 for (j = 0; j < s->nb_chapters; j++) {
2914 AVChapter *ch1 = s->chapters[j];
2915 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2917 if (j != i && next_start > ch->start && next_start < end)
2920 ch->end = (end == INT64_MAX) ? ch->start : end;
2924 static int get_std_framerate(int i)
2927 return (i + 1) * 1001;
2931 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2935 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2938 /* Is the time base unreliable?
2939 * This is a heuristic to balance between quick acceptance of the values in
2940 * the headers vs. some extra checks.
2941 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2942 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2943 * And there are "variable" fps files this needs to detect as well. */
2944 static int tb_unreliable(AVCodecContext *c)
2946 if (c->time_base.den >= 101LL * c->time_base.num ||
2947 c->time_base.den < 5LL * c->time_base.num ||
2948 // c->codec_tag == AV_RL32("DIVX") ||
2949 // c->codec_tag == AV_RL32("XVID") ||
2950 c->codec_tag == AV_RL32("mp4v") ||
2951 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2952 c->codec_id == AV_CODEC_ID_GIF ||
2953 c->codec_id == AV_CODEC_ID_HEVC ||
2954 c->codec_id == AV_CODEC_ID_H264)
2959 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2963 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2964 avctx->extradata = NULL;
2965 avctx->extradata_size = 0;
2966 return AVERROR(EINVAL);
2968 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2969 if (avctx->extradata) {
2970 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2971 avctx->extradata_size = size;
2974 avctx->extradata_size = 0;
2975 ret = AVERROR(ENOMEM);
2980 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2982 int ret = ff_alloc_extradata(avctx, size);
2985 ret = avio_read(pb, avctx->extradata, size);
2987 av_freep(&avctx->extradata);
2988 avctx->extradata_size = 0;
2989 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2990 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2996 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2999 int64_t last = st->info->last_dts;
3001 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3002 && ts - (uint64_t)last < INT64_MAX) {
3003 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3004 int64_t duration = ts - last;
3006 if (!st->info->duration_error)
3007 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3008 if (!st->info->duration_error)
3009 return AVERROR(ENOMEM);
3011 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3012 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3013 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3014 if (st->info->duration_error[0][1][i] < 1e10) {
3015 int framerate = get_std_framerate(i);
3016 double sdts = dts*framerate/(1001*12);
3017 for (j= 0; j<2; j++) {
3018 int64_t ticks = llrint(sdts+j*0.5);
3019 double error= sdts - ticks + j*0.5;
3020 st->info->duration_error[j][0][i] += error;
3021 st->info->duration_error[j][1][i] += error*error;
3025 st->info->duration_count++;
3026 st->info->rfps_duration_sum += duration;
3028 if (st->info->duration_count % 10 == 0) {
3029 int n = st->info->duration_count;
3030 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3031 if (st->info->duration_error[0][1][i] < 1e10) {
3032 double a0 = st->info->duration_error[0][0][i] / n;
3033 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3034 double a1 = st->info->duration_error[1][0][i] / n;
3035 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3036 if (error0 > 0.04 && error1 > 0.04) {
3037 st->info->duration_error[0][1][i] = 2e10;
3038 st->info->duration_error[1][1][i] = 2e10;
3044 // ignore the first 4 values, they might have some random jitter
3045 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3046 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3048 if (ts != AV_NOPTS_VALUE)
3049 st->info->last_dts = ts;
3054 void ff_rfps_calculate(AVFormatContext *ic)
3058 for (i = 0; i < ic->nb_streams; i++) {
3059 AVStream *st = ic->streams[i];
3061 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3063 // the check for tb_unreliable() is not completely correct, since this is not about handling
3064 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3065 // ipmovie.c produces.
3066 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3067 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);
3068 if (st->info->duration_count>1 && !st->r_frame_rate.num
3069 && tb_unreliable(st->codec)) {
3071 double best_error= 0.01;
3072 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3074 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3077 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3079 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3082 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3085 for (k= 0; k<2; k++) {
3086 int n = st->info->duration_count;
3087 double a= st->info->duration_error[k][0][j] / n;
3088 double error= st->info->duration_error[k][1][j]/n - a*a;
3090 if (error < best_error && best_error> 0.000000001) {
3092 num = get_std_framerate(j);
3095 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3098 // do not increase frame rate by more than 1 % in order to match a standard rate.
3099 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3100 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3102 if ( !st->avg_frame_rate.num
3103 && st->r_frame_rate.num && st->info->rfps_duration_sum
3104 && st->info->codec_info_duration <= 0
3105 && st->info->duration_count > 2
3106 && 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
3108 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3109 st->avg_frame_rate = st->r_frame_rate;
3112 av_freep(&st->info->duration_error);
3113 st->info->last_dts = AV_NOPTS_VALUE;
3114 st->info->duration_count = 0;
3115 st->info->rfps_duration_sum = 0;
3119 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3121 int i, count, ret = 0, j;
3124 AVPacket pkt1, *pkt;
3125 int64_t old_offset = avio_tell(ic->pb);
3126 // new streams might appear, no options for those
3127 int orig_nb_streams = ic->nb_streams;
3129 int64_t max_analyze_duration = ic->max_analyze_duration;
3130 int64_t max_stream_analyze_duration;
3131 int64_t max_subtitle_analyze_duration;
3132 int64_t probesize = ic->probesize;
3134 flush_codecs = probesize > 0;
3136 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3138 max_stream_analyze_duration = max_analyze_duration;
3139 max_subtitle_analyze_duration = max_analyze_duration;
3140 if (!max_analyze_duration) {
3141 max_stream_analyze_duration =
3142 max_analyze_duration = 5*AV_TIME_BASE;
3143 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3144 if (!strcmp(ic->iformat->name, "flv"))
3145 max_stream_analyze_duration = 90*AV_TIME_BASE;
3149 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3150 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3152 for (i = 0; i < ic->nb_streams; i++) {
3153 const AVCodec *codec;
3154 AVDictionary *thread_opt = NULL;
3155 st = ic->streams[i];
3157 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3158 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3159 /* if (!st->time_base.num)
3161 if (!st->codec->time_base.num)
3162 st->codec->time_base = st->time_base;
3164 // only for the split stuff
3165 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3166 st->parser = av_parser_init(st->codec->codec_id);
3168 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3169 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3170 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3171 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3173 } else if (st->need_parsing) {
3174 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3175 "%s, packets or times may be invalid.\n",
3176 avcodec_get_name(st->codec->codec_id));
3179 codec = find_decoder(ic, st, st->codec->codec_id);
3181 /* Force thread count to 1 since the H.264 decoder will not extract
3182 * SPS and PPS to extradata during multi-threaded decoding. */
3183 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3185 if (ic->codec_whitelist)
3186 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3188 /* Ensure that subtitle_header is properly set. */
3189 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3190 && codec && !st->codec->codec) {
3191 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3192 av_log(ic, AV_LOG_WARNING,
3193 "Failed to open codec in av_find_stream_info\n");
3196 // Try to just open decoders, in case this is enough to get parameters.
3197 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3198 if (codec && !st->codec->codec)
3199 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3200 av_log(ic, AV_LOG_WARNING,
3201 "Failed to open codec in av_find_stream_info\n");
3204 av_dict_free(&thread_opt);
3207 for (i = 0; i < ic->nb_streams; i++) {
3208 #if FF_API_R_FRAME_RATE
3209 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3211 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3212 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3218 int analyzed_all_streams;
3219 if (ff_check_interrupt(&ic->interrupt_callback)) {
3221 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3225 /* check if one codec still needs to be handled */
3226 for (i = 0; i < ic->nb_streams; i++) {
3227 int fps_analyze_framecount = 20;
3229 st = ic->streams[i];
3230 if (!has_codec_parameters(st, NULL))
3232 /* If the timebase is coarse (like the usual millisecond precision
3233 * of mkv), we need to analyze more frames to reliably arrive at
3234 * the correct fps. */
3235 if (av_q2d(st->time_base) > 0.0005)
3236 fps_analyze_framecount *= 2;
3237 if (!tb_unreliable(st->codec))
3238 fps_analyze_framecount = 0;
3239 if (ic->fps_probe_size >= 0)
3240 fps_analyze_framecount = ic->fps_probe_size;
3241 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3242 fps_analyze_framecount = 0;
3243 /* variable fps and no guess at the real fps */
3244 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3245 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3246 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3247 st->info->codec_info_duration_fields/2 :
3248 st->info->duration_count;
3249 if (count < fps_analyze_framecount)
3252 if (st->parser && st->parser->parser->split &&
3253 !st->codec->extradata)
3255 if (st->first_dts == AV_NOPTS_VALUE &&
3256 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3257 st->codec_info_nb_frames < ic->max_ts_probe &&
3258 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3259 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3262 analyzed_all_streams = 0;
3263 if (i == ic->nb_streams) {
3264 analyzed_all_streams = 1;
3265 /* NOTE: If the format has no header, then we need to read some
3266 * packets to get most of the streams, so we cannot stop here. */
3267 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3268 /* If we found the info for all the codecs, we can stop. */
3270 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3275 /* We did not get all the codec info, but we read too much data. */
3276 if (read_size >= probesize) {
3278 av_log(ic, AV_LOG_DEBUG,
3279 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3280 for (i = 0; i < ic->nb_streams; i++)
3281 if (!ic->streams[i]->r_frame_rate.num &&
3282 ic->streams[i]->info->duration_count <= 1 &&
3283 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3284 strcmp(ic->iformat->name, "image2"))
3285 av_log(ic, AV_LOG_WARNING,
3286 "Stream #%d: not enough frames to estimate rate; "
3287 "consider increasing probesize\n", i);
3291 /* NOTE: A new stream can be added there if no header in file
3292 * (AVFMTCTX_NOHEADER). */
3293 ret = read_frame_internal(ic, &pkt1);
3294 if (ret == AVERROR(EAGAIN))
3304 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3305 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3306 &ic->internal->packet_buffer_end, 0);
3308 goto find_stream_info_err;
3311 st = ic->streams[pkt->stream_index];
3312 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3313 read_size += pkt->size;
3315 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3316 /* check for non-increasing dts */
3317 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3318 st->info->fps_last_dts >= pkt->dts) {
3319 av_log(ic, AV_LOG_DEBUG,
3320 "Non-increasing DTS in stream %d: packet %d with DTS "
3321 "%"PRId64", packet %d with DTS %"PRId64"\n",
3322 st->index, st->info->fps_last_dts_idx,
3323 st->info->fps_last_dts, st->codec_info_nb_frames,
3325 st->info->fps_first_dts =
3326 st->info->fps_last_dts = AV_NOPTS_VALUE;
3328 /* Check for a discontinuity in dts. If the difference in dts
3329 * is more than 1000 times the average packet duration in the
3330 * sequence, we treat it as a discontinuity. */
3331 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3332 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3333 (pkt->dts - st->info->fps_last_dts) / 1000 >
3334 (st->info->fps_last_dts - st->info->fps_first_dts) /
3335 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3336 av_log(ic, AV_LOG_WARNING,
3337 "DTS discontinuity in stream %d: packet %d with DTS "
3338 "%"PRId64", packet %d with DTS %"PRId64"\n",
3339 st->index, st->info->fps_last_dts_idx,
3340 st->info->fps_last_dts, st->codec_info_nb_frames,
3342 st->info->fps_first_dts =
3343 st->info->fps_last_dts = AV_NOPTS_VALUE;
3346 /* update stored dts values */
3347 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3348 st->info->fps_first_dts = pkt->dts;
3349 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3351 st->info->fps_last_dts = pkt->dts;
3352 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3354 if (st->codec_info_nb_frames>1) {
3358 if (st->time_base.den > 0)
3359 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3360 if (st->avg_frame_rate.num > 0)
3361 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3364 && st->codec_info_nb_frames>30
3365 && st->info->fps_first_dts != AV_NOPTS_VALUE
3366 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3367 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3369 if (analyzed_all_streams) limit = max_analyze_duration;
3370 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3371 else limit = max_stream_analyze_duration;
3374 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3376 t, pkt->stream_index);
3377 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3378 av_packet_unref(pkt);
3381 if (pkt->duration) {
3382 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3383 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3385 st->info->codec_info_duration += pkt->duration;
3386 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3389 #if FF_API_R_FRAME_RATE
3390 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3391 ff_rfps_add_frame(ic, st, pkt->dts);
3393 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3394 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3395 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3396 if (ff_alloc_extradata(st->codec, i))
3397 return AVERROR(ENOMEM);
3398 memcpy(st->codec->extradata, pkt->data,
3399 st->codec->extradata_size);
3403 /* If still no information, we try to open the codec and to
3404 * decompress the frame. We try to avoid that in most cases as
3405 * it takes longer and uses more memory. For MPEG-4, we need to
3406 * decompress for QuickTime.
3408 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3409 * least one frame of codec data, this makes sure the codec initializes
3410 * the channel configuration and does not only trust the values from
3412 try_decode_frame(ic, st, pkt,
3413 (options && i < orig_nb_streams) ? &options[i] : NULL);
3415 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3416 av_packet_unref(pkt);
3418 st->codec_info_nb_frames++;
3423 AVPacket empty_pkt = { 0 };
3425 av_init_packet(&empty_pkt);
3427 for (i = 0; i < ic->nb_streams; i++) {
3429 st = ic->streams[i];
3431 /* flush the decoders */
3432 if (st->info->found_decoder == 1) {
3434 err = try_decode_frame(ic, st, &empty_pkt,
3435 (options && i < orig_nb_streams)
3436 ? &options[i] : NULL);
3437 } while (err > 0 && !has_codec_parameters(st, NULL));
3440 av_log(ic, AV_LOG_INFO,
3441 "decoding for stream %d failed\n", st->index);
3447 // close codecs which were opened in try_decode_frame()
3448 for (i = 0; i < ic->nb_streams; i++) {
3449 st = ic->streams[i];
3450 avcodec_close(st->codec);
3453 ff_rfps_calculate(ic);
3455 for (i = 0; i < ic->nb_streams; i++) {
3456 st = ic->streams[i];
3457 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3458 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3459 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3460 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3461 st->codec->codec_tag= tag;
3464 /* estimate average framerate if not set by demuxer */
3465 if (st->info->codec_info_duration_fields &&
3466 !st->avg_frame_rate.num &&
3467 st->info->codec_info_duration) {
3469 double best_error = 0.01;
3471 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3472 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3473 st->info->codec_info_duration < 0)
3475 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3476 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3477 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3479 /* Round guessed framerate to a "standard" framerate if it's
3480 * within 1% of the original estimate. */
3481 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3482 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3483 double error = fabs(av_q2d(st->avg_frame_rate) /
3484 av_q2d(std_fps) - 1);
3486 if (error < best_error) {
3488 best_fps = std_fps.num;
3492 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3493 best_fps, 12 * 1001, INT_MAX);
3496 if (!st->r_frame_rate.num) {
3497 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3498 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3499 st->r_frame_rate.num = st->codec->time_base.den;
3500 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3502 st->r_frame_rate.num = st->time_base.den;
3503 st->r_frame_rate.den = st->time_base.num;
3506 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3507 AVRational hw_ratio = { st->codec->height, st->codec->width };
3508 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3511 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3512 if (!st->codec->bits_per_coded_sample)
3513 st->codec->bits_per_coded_sample =
3514 av_get_bits_per_sample(st->codec->codec_id);
3515 // set stream disposition based on audio service type
3516 switch (st->codec->audio_service_type) {
3517 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3518 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3520 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3521 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3523 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3524 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3526 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3527 st->disposition = AV_DISPOSITION_COMMENT;
3529 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3530 st->disposition = AV_DISPOSITION_KARAOKE;
3537 estimate_timings(ic, old_offset);
3539 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3541 if (ret >= 0 && ic->nb_streams)
3542 /* We could not have all the codec parameters before EOF. */
3544 for (i = 0; i < ic->nb_streams; i++) {
3546 st = ic->streams[i];
3547 if (!has_codec_parameters(st, &errmsg)) {
3549 avcodec_string(buf, sizeof(buf), st->codec, 0);
3550 av_log(ic, AV_LOG_WARNING,
3551 "Could not find codec parameters for stream %d (%s): %s\n"
3552 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3559 compute_chapters_end(ic);
3561 find_stream_info_err:
3562 for (i = 0; i < ic->nb_streams; i++) {
3563 st = ic->streams[i];
3564 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3565 ic->streams[i]->codec->thread_count = 0;
3567 av_freep(&st->info->duration_error);
3568 av_freep(&ic->streams[i]->info);
3571 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3572 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3576 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3580 for (i = 0; i < ic->nb_programs; i++) {
3581 if (ic->programs[i] == last) {
3585 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3586 if (ic->programs[i]->stream_index[j] == s)
3587 return ic->programs[i];
3593 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3594 int wanted_stream_nb, int related_stream,
3595 AVCodec **decoder_ret, int flags)
3597 int i, nb_streams = ic->nb_streams;
3598 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3599 unsigned *program = NULL;
3600 const AVCodec *decoder = NULL, *best_decoder = NULL;
3602 if (related_stream >= 0 && wanted_stream_nb < 0) {
3603 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3605 program = p->stream_index;
3606 nb_streams = p->nb_stream_indexes;
3609 for (i = 0; i < nb_streams; i++) {
3610 int real_stream_index = program ? program[i] : i;
3611 AVStream *st = ic->streams[real_stream_index];
3612 AVCodecContext *avctx = st->codec;
3613 if (avctx->codec_type != type)
3615 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3617 if (wanted_stream_nb != real_stream_index &&
3618 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3619 AV_DISPOSITION_VISUAL_IMPAIRED))
3621 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3624 decoder = find_decoder(ic, st, st->codec->codec_id);
3627 ret = AVERROR_DECODER_NOT_FOUND;
3631 count = st->codec_info_nb_frames;
3632 bitrate = avctx->bit_rate;
3634 bitrate = avctx->rc_max_rate;
3635 multiframe = FFMIN(5, count);
3636 if ((best_multiframe > multiframe) ||
3637 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3638 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3641 best_bitrate = bitrate;
3642 best_multiframe = multiframe;
3643 ret = real_stream_index;
3644 best_decoder = decoder;
3645 if (program && i == nb_streams - 1 && ret < 0) {
3647 nb_streams = ic->nb_streams;
3648 /* no related stream found, try again with everything */
3653 *decoder_ret = (AVCodec*)best_decoder;
3657 /*******************************************************/
3659 int av_read_play(AVFormatContext *s)
3661 if (s->iformat->read_play)
3662 return s->iformat->read_play(s);
3664 return avio_pause(s->pb, 0);
3665 return AVERROR(ENOSYS);
3668 int av_read_pause(AVFormatContext *s)
3670 if (s->iformat->read_pause)
3671 return s->iformat->read_pause(s);
3673 return avio_pause(s->pb, 1);
3674 return AVERROR(ENOSYS);
3677 static void free_stream(AVStream **pst)
3679 AVStream *st = *pst;
3685 for (i = 0; i < st->nb_side_data; i++)
3686 av_freep(&st->side_data[i].data);
3687 av_freep(&st->side_data);
3690 av_parser_close(st->parser);
3692 if (st->attached_pic.data)
3693 av_packet_unref(&st->attached_pic);
3695 av_freep(&st->internal);
3697 av_dict_free(&st->metadata);
3698 av_freep(&st->probe_data.buf);
3699 av_freep(&st->index_entries);
3700 av_freep(&st->codec->extradata);
3701 av_freep(&st->codec->subtitle_header);
3702 av_freep(&st->codec);
3703 av_freep(&st->priv_data);
3705 av_freep(&st->info->duration_error);
3706 av_freep(&st->info);
3707 av_freep(&st->recommended_encoder_configuration);
3708 av_freep(&st->priv_pts);
3713 void ff_free_stream(AVFormatContext *s, AVStream *st)
3715 av_assert0(s->nb_streams>0);
3716 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3718 free_stream(&s->streams[ --s->nb_streams ]);
3721 void avformat_free_context(AVFormatContext *s)
3729 if (s->iformat && s->iformat->priv_class && s->priv_data)
3730 av_opt_free(s->priv_data);
3731 if (s->oformat && s->oformat->priv_class && s->priv_data)
3732 av_opt_free(s->priv_data);
3734 for (i = s->nb_streams - 1; i >= 0; i--)
3735 ff_free_stream(s, s->streams[i]);
3738 for (i = s->nb_programs - 1; i >= 0; i--) {
3739 av_dict_free(&s->programs[i]->metadata);
3740 av_freep(&s->programs[i]->stream_index);
3741 av_freep(&s->programs[i]);
3743 av_freep(&s->programs);
3744 av_freep(&s->priv_data);
3745 while (s->nb_chapters--) {
3746 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3747 av_freep(&s->chapters[s->nb_chapters]);
3749 av_freep(&s->chapters);
3750 av_dict_free(&s->metadata);
3751 av_freep(&s->streams);
3752 av_freep(&s->internal);
3753 flush_packet_queue(s);
3757 void avformat_close_input(AVFormatContext **ps)
3768 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3769 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3772 flush_packet_queue(s);
3775 if (s->iformat->read_close)
3776 s->iformat->read_close(s);
3778 avformat_free_context(s);
3785 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3791 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3793 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3796 s->streams = streams;
3798 st = av_mallocz(sizeof(AVStream));
3801 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3805 st->info->last_dts = AV_NOPTS_VALUE;
3807 st->codec = avcodec_alloc_context3(c);
3814 st->internal = av_mallocz(sizeof(*st->internal));
3819 /* no default bitrate if decoding */
3820 st->codec->bit_rate = 0;
3822 /* default pts setting is MPEG-like */
3823 avpriv_set_pts_info(st, 33, 1, 90000);
3824 /* we set the current DTS to 0 so that formats without any timestamps
3825 * but durations get some timestamps, formats with some unknown
3826 * timestamps have their first few packets buffered and the
3827 * timestamps corrected before they are returned to the user */
3828 st->cur_dts = RELATIVE_TS_BASE;
3830 st->cur_dts = AV_NOPTS_VALUE;
3833 st->index = s->nb_streams;
3834 st->start_time = AV_NOPTS_VALUE;
3835 st->duration = AV_NOPTS_VALUE;
3836 st->first_dts = AV_NOPTS_VALUE;
3837 st->probe_packets = MAX_PROBE_PACKETS;
3838 st->pts_wrap_reference = AV_NOPTS_VALUE;
3839 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3841 st->last_IP_pts = AV_NOPTS_VALUE;
3842 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3843 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3844 st->pts_buffer[i] = AV_NOPTS_VALUE;
3846 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3848 #if FF_API_R_FRAME_RATE
3849 st->info->last_dts = AV_NOPTS_VALUE;
3851 st->info->fps_first_dts = AV_NOPTS_VALUE;
3852 st->info->fps_last_dts = AV_NOPTS_VALUE;
3854 st->inject_global_side_data = s->internal->inject_global_side_data;
3856 s->streams[s->nb_streams++] = st;
3863 AVProgram *av_new_program(AVFormatContext *ac, int id)
3865 AVProgram *program = NULL;
3868 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3870 for (i = 0; i < ac->nb_programs; i++)
3871 if (ac->programs[i]->id == id)
3872 program = ac->programs[i];
3875 program = av_mallocz(sizeof(AVProgram));
3878 dynarray_add(&ac->programs, &ac->nb_programs, program);
3879 program->discard = AVDISCARD_NONE;
3882 program->pts_wrap_reference = AV_NOPTS_VALUE;
3883 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3885 program->start_time =
3886 program->end_time = AV_NOPTS_VALUE;
3891 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3892 int64_t start, int64_t end, const char *title)
3894 AVChapter *chapter = NULL;
3897 if (end != AV_NOPTS_VALUE && start > end) {
3898 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3902 for (i = 0; i < s->nb_chapters; i++)
3903 if (s->chapters[i]->id == id)
3904 chapter = s->chapters[i];
3907 chapter = av_mallocz(sizeof(AVChapter));
3910 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3912 av_dict_set(&chapter->metadata, "title", title, 0);
3914 chapter->time_base = time_base;
3915 chapter->start = start;
3921 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3924 AVProgram *program = NULL;
3927 if (idx >= ac->nb_streams) {
3928 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3932 for (i = 0; i < ac->nb_programs; i++) {
3933 if (ac->programs[i]->id != progid)
3935 program = ac->programs[i];
3936 for (j = 0; j < program->nb_stream_indexes; j++)
3937 if (program->stream_index[j] == idx)
3940 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3943 program->stream_index = tmp;
3944 program->stream_index[program->nb_stream_indexes++] = idx;
3949 uint64_t ff_ntp_time(void)
3951 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3954 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3957 char *q, buf1[20], c;
3958 int nd, len, percentd_found;
3970 while (av_isdigit(*p))
3971 nd = nd * 10 + *p++ - '0';
3973 } while (av_isdigit(c));
3984 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3986 if ((q - buf + len) > buf_size - 1)
3988 memcpy(q, buf1, len);
3996 if ((q - buf) < buf_size - 1)
4000 if (!percentd_found)
4009 void av_url_split(char *proto, int proto_size,
4010 char *authorization, int authorization_size,
4011 char *hostname, int hostname_size,
4012 int *port_ptr, char *path, int path_size, const char *url)
4014 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4020 if (authorization_size > 0)
4021 authorization[0] = 0;
4022 if (hostname_size > 0)
4027 /* parse protocol */
4028 if ((p = strchr(url, ':'))) {
4029 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4036 /* no protocol means plain filename */
4037 av_strlcpy(path, url, path_size);
4041 /* separate path from hostname */
4042 ls = strchr(p, '/');
4043 ls2 = strchr(p, '?');
4047 ls = FFMIN(ls, ls2);
4049 av_strlcpy(path, ls, path_size);
4051 ls = &p[strlen(p)]; // XXX
4053 /* the rest is hostname, use that to parse auth/port */
4055 /* authorization (user[:pass]@hostname) */
4057 while ((at = strchr(p, '@')) && at < ls) {
4058 av_strlcpy(authorization, at2,
4059 FFMIN(authorization_size, at + 1 - at2));
4060 p = at + 1; /* skip '@' */
4063 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4065 av_strlcpy(hostname, p + 1,
4066 FFMIN(hostname_size, brk - p));
4067 if (brk[1] == ':' && port_ptr)
4068 *port_ptr = atoi(brk + 2);
4069 } else if ((col = strchr(p, ':')) && col < ls) {
4070 av_strlcpy(hostname, p,
4071 FFMIN(col + 1 - p, hostname_size));
4073 *port_ptr = atoi(col + 1);
4075 av_strlcpy(hostname, p,
4076 FFMIN(ls + 1 - p, hostname_size));
4080 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4083 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4086 'C', 'D', 'E', 'F' };
4087 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4090 'c', 'd', 'e', 'f' };
4091 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4093 for (i = 0; i < s; i++) {
4094 buff[i * 2] = hex_table[src[i] >> 4];
4095 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4101 int ff_hex_to_data(uint8_t *data, const char *p)
4108 p += strspn(p, SPACE_CHARS);
4111 c = av_toupper((unsigned char) *p++);
4112 if (c >= '0' && c <= '9')
4114 else if (c >= 'A' && c <= 'F')
4129 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4130 unsigned int pts_num, unsigned int pts_den)
4133 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4134 if (new_tb.num != pts_num)
4135 av_log(NULL, AV_LOG_DEBUG,
4136 "st:%d removing common factor %d from timebase\n",
4137 s->index, pts_num / new_tb.num);
4139 av_log(NULL, AV_LOG_WARNING,
4140 "st:%d has too large timebase, reducing\n", s->index);
4142 if (new_tb.num <= 0 || new_tb.den <= 0) {
4143 av_log(NULL, AV_LOG_ERROR,
4144 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4145 new_tb.num, new_tb.den,
4149 s->time_base = new_tb;
4150 av_codec_set_pkt_timebase(s->codec, new_tb);
4151 s->pts_wrap_bits = pts_wrap_bits;
4154 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4157 const char *ptr = str;
4159 /* Parse key=value pairs. */
4162 char *dest = NULL, *dest_end;
4163 int key_len, dest_len = 0;
4165 /* Skip whitespace and potential commas. */
4166 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4173 if (!(ptr = strchr(key, '=')))
4176 key_len = ptr - key;
4178 callback_get_buf(context, key, key_len, &dest, &dest_len);
4179 dest_end = dest + dest_len - 1;
4183 while (*ptr && *ptr != '\"') {
4187 if (dest && dest < dest_end)
4191 if (dest && dest < dest_end)
4199 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4200 if (dest && dest < dest_end)
4208 int ff_find_stream_index(AVFormatContext *s, int id)
4211 for (i = 0; i < s->nb_streams; i++)
4212 if (s->streams[i]->id == id)
4217 int64_t ff_iso8601_to_unix_time(const char *datestr)
4219 struct tm time1 = { 0 }, time2 = { 0 };
4220 const char *ret1, *ret2;
4221 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4222 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4224 return av_timegm(&time2);
4226 return av_timegm(&time1);
4229 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4233 unsigned int codec_tag;
4234 if (ofmt->query_codec)
4235 return ofmt->query_codec(codec_id, std_compliance);
4236 else if (ofmt->codec_tag)
4237 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4238 else if (codec_id == ofmt->video_codec ||
4239 codec_id == ofmt->audio_codec ||
4240 codec_id == ofmt->subtitle_codec)
4243 return AVERROR_PATCHWELCOME;
4246 int avformat_network_init(void)
4250 ff_network_inited_globally = 1;
4251 if ((ret = ff_network_init()) < 0)
4253 if ((ret = ff_tls_init()) < 0)
4259 int avformat_network_deinit(void)
4264 ff_network_inited_globally = 0;
4269 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4270 uint64_t channel_layout, int32_t sample_rate,
4271 int32_t width, int32_t height)
4277 return AVERROR(EINVAL);
4280 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4282 if (channel_layout) {
4284 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4288 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4290 if (width || height) {
4292 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4294 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4296 return AVERROR(ENOMEM);
4297 bytestream_put_le32(&data, flags);
4299 bytestream_put_le32(&data, channels);
4301 bytestream_put_le64(&data, channel_layout);
4303 bytestream_put_le32(&data, sample_rate);
4304 if (width || height) {
4305 bytestream_put_le32(&data, width);
4306 bytestream_put_le32(&data, height);
4311 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4313 AVRational undef = {0, 1};
4314 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4315 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4316 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4318 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4319 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4320 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4321 stream_sample_aspect_ratio = undef;
4323 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4324 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4325 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4326 frame_sample_aspect_ratio = undef;
4328 if (stream_sample_aspect_ratio.num)
4329 return stream_sample_aspect_ratio;
4331 return frame_sample_aspect_ratio;
4334 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4336 AVRational fr = st->r_frame_rate;
4337 AVRational codec_fr = st->codec->framerate;
4338 AVRational avg_fr = st->avg_frame_rate;
4340 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4341 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4346 if (st->codec->ticks_per_frame > 1) {
4347 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4348 (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))
4355 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4358 if (*spec <= '9' && *spec >= '0') /* opt:index */
4359 return strtol(spec, NULL, 0) == st->index;
4360 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4361 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4362 enum AVMediaType type;
4366 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4367 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4368 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4369 case 'd': type = AVMEDIA_TYPE_DATA; break;
4370 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4371 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4372 default: av_assert0(0);
4374 if (type != st->codec->codec_type)
4376 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4378 if (*spec++ == ':') { /* possibly followed by :index */
4379 int i, index = strtol(spec, NULL, 0);
4380 for (i = 0; i < s->nb_streams; i++)
4381 if (s->streams[i]->codec->codec_type == type &&
4382 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4384 return i == st->index;
4388 } else if (*spec == 'p' && *(spec + 1) == ':') {
4392 prog_id = strtol(spec, &endptr, 0);
4393 for (i = 0; i < s->nb_programs; i++) {
4394 if (s->programs[i]->id != prog_id)
4397 if (*endptr++ == ':') {
4398 int stream_idx = strtol(endptr, NULL, 0);
4399 return stream_idx >= 0 &&
4400 stream_idx < s->programs[i]->nb_stream_indexes &&
4401 st->index == s->programs[i]->stream_index[stream_idx];
4404 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4405 if (st->index == s->programs[i]->stream_index[j])
4409 } else if (*spec == '#' ||
4410 (*spec == 'i' && *(spec + 1) == ':')) {
4413 spec += 1 + (*spec == 'i');
4414 stream_id = strtol(spec, &endptr, 0);
4416 return stream_id == st->id;
4417 } else if (*spec == 'm' && *(spec + 1) == ':') {
4418 AVDictionaryEntry *tag;
4423 val = strchr(spec, ':');
4425 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4427 return AVERROR(ENOMEM);
4429 tag = av_dict_get(st->metadata, key, NULL, 0);
4431 if (!val || !strcmp(tag->value, val + 1))
4440 } else if (*spec == 'u') {
4441 AVCodecContext *avctx = st->codec;
4443 switch (avctx->codec_type) {
4444 case AVMEDIA_TYPE_AUDIO:
4445 val = avctx->sample_rate && avctx->channels;
4446 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4449 case AVMEDIA_TYPE_VIDEO:
4450 val = avctx->width && avctx->height;
4451 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4454 case AVMEDIA_TYPE_UNKNOWN:
4461 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4462 } else if (!*spec) /* empty specifier, matches everything */
4465 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4466 return AVERROR(EINVAL);
4469 int ff_generate_avci_extradata(AVStream *st)
4471 static const uint8_t avci100_1080p_extradata[] = {
4473 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4474 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4475 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4476 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4477 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4478 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4479 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4480 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4481 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4483 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4486 static const uint8_t avci100_1080i_extradata[] = {
4488 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4489 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4490 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4491 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4492 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4493 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4494 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4495 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4496 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4497 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4498 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4500 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4503 static const uint8_t avci50_1080p_extradata[] = {
4505 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4506 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4507 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4508 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4509 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4510 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4511 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4512 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4513 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4515 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4518 static const uint8_t avci50_1080i_extradata[] = {
4520 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4521 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4522 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4523 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4524 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4525 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4526 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4527 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4528 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4529 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4530 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4532 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4535 static const uint8_t avci100_720p_extradata[] = {
4537 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4538 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4539 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4540 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4541 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4542 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4543 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4544 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4545 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4546 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4548 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4551 static const uint8_t avci50_720p_extradata[] = {
4553 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4554 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4555 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4556 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4557 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4558 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4559 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4560 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4561 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4563 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4567 const uint8_t *data = NULL;
4570 if (st->codec->width == 1920) {
4571 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4572 data = avci100_1080p_extradata;
4573 size = sizeof(avci100_1080p_extradata);
4575 data = avci100_1080i_extradata;
4576 size = sizeof(avci100_1080i_extradata);
4578 } else if (st->codec->width == 1440) {
4579 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4580 data = avci50_1080p_extradata;
4581 size = sizeof(avci50_1080p_extradata);
4583 data = avci50_1080i_extradata;
4584 size = sizeof(avci50_1080i_extradata);
4586 } else if (st->codec->width == 1280) {
4587 data = avci100_720p_extradata;
4588 size = sizeof(avci100_720p_extradata);
4589 } else if (st->codec->width == 960) {
4590 data = avci50_720p_extradata;
4591 size = sizeof(avci50_720p_extradata);
4597 av_freep(&st->codec->extradata);
4598 if (ff_alloc_extradata(st->codec, size))
4599 return AVERROR(ENOMEM);
4600 memcpy(st->codec->extradata, data, size);
4605 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4610 for (i = 0; i < st->nb_side_data; i++) {
4611 if (st->side_data[i].type == type) {
4613 *size = st->side_data[i].size;
4614 return st->side_data[i].data;
4620 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4623 AVPacketSideData *sd, *tmp;
4625 uint8_t *data = av_malloc(size);
4630 for (i = 0; i < st->nb_side_data; i++) {
4631 sd = &st->side_data[i];
4633 if (sd->type == type) {
4634 av_freep(&sd->data);
4641 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4647 st->side_data = tmp;
4650 sd = &st->side_data[st->nb_side_data - 1];
4657 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4659 AVBitStreamFilterContext *bsfc = NULL;
4660 AVBitStreamFilterContext **dest = &st->internal->bsfc;
4661 while (*dest && (*dest)->next)
4662 dest = &(*dest)->next;
4664 if (!(bsfc = av_bitstream_filter_init(name))) {
4665 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4666 return AVERROR(EINVAL);
4668 if (args && !(bsfc->args = av_strdup(args))) {
4669 av_bitstream_filter_close(bsfc);
4670 return AVERROR(ENOMEM);
4672 av_log(st->codec, AV_LOG_VERBOSE,
4673 "Automatically inserted bitstream filter '%s'; args='%s'\n",
4674 name, args ? args : "");
4679 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4680 AVBitStreamFilterContext *bsfc)
4684 AVPacket new_pkt = *pkt;
4685 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4686 &new_pkt.data, &new_pkt.size,
4687 pkt->data, pkt->size,
4688 pkt->flags & AV_PKT_FLAG_KEY);
4689 if(a == 0 && new_pkt.data != pkt->data) {
4690 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
4692 memcpy(t, new_pkt.data, new_pkt.size);
4693 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
4698 a = AVERROR(ENOMEM);
4702 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
4703 av_buffer_default_free, NULL, 0);
4705 pkt->side_data = NULL;
4706 pkt->side_data_elems = 0;
4707 av_packet_unref(pkt);
4709 av_freep(&new_pkt.data);
4710 a = AVERROR(ENOMEM);
4714 av_log(codec, AV_LOG_ERROR,
4715 "Failed to open bitstream filter %s for stream %d with codec %s",
4716 bsfc->filter->name, pkt->stream_index,
4717 codec->codec ? codec->codec->name : "copy");