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 av_packet_unref(&pkt);
2146 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2147 if (pkt.flags & AV_PKT_FLAG_KEY)
2149 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2150 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);
2155 index = av_index_search_timestamp(st, timestamp, flags);
2160 ff_read_frame_flush(s);
2161 if (s->iformat->read_seek)
2162 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2164 ie = &st->index_entries[index];
2165 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2167 ff_update_cur_dts(s, st, ie->timestamp);
2172 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2173 int64_t timestamp, int flags)
2178 if (flags & AVSEEK_FLAG_BYTE) {
2179 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2181 ff_read_frame_flush(s);
2182 return seek_frame_byte(s, stream_index, timestamp, flags);
2185 if (stream_index < 0) {
2186 stream_index = av_find_default_stream_index(s);
2187 if (stream_index < 0)
2190 st = s->streams[stream_index];
2191 /* timestamp for default must be expressed in AV_TIME_BASE units */
2192 timestamp = av_rescale(timestamp, st->time_base.den,
2193 AV_TIME_BASE * (int64_t) st->time_base.num);
2196 /* first, we try the format specific seek */
2197 if (s->iformat->read_seek) {
2198 ff_read_frame_flush(s);
2199 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2205 if (s->iformat->read_timestamp &&
2206 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2207 ff_read_frame_flush(s);
2208 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2209 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2210 ff_read_frame_flush(s);
2211 return seek_frame_generic(s, stream_index, timestamp, flags);
2216 int av_seek_frame(AVFormatContext *s, int stream_index,
2217 int64_t timestamp, int flags)
2221 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2222 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2223 if ((flags & AVSEEK_FLAG_BACKWARD))
2227 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2228 flags & ~AVSEEK_FLAG_BACKWARD);
2231 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2234 ret = avformat_queue_attached_pictures(s);
2239 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2240 int64_t ts, int64_t max_ts, int flags)
2242 if (min_ts > ts || max_ts < ts)
2244 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2245 return AVERROR(EINVAL);
2248 flags |= AVSEEK_FLAG_ANY;
2249 flags &= ~AVSEEK_FLAG_BACKWARD;
2251 if (s->iformat->read_seek2) {
2253 ff_read_frame_flush(s);
2255 if (stream_index == -1 && s->nb_streams == 1) {
2256 AVRational time_base = s->streams[0]->time_base;
2257 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2258 min_ts = av_rescale_rnd(min_ts, time_base.den,
2259 time_base.num * (int64_t)AV_TIME_BASE,
2260 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2261 max_ts = av_rescale_rnd(max_ts, time_base.den,
2262 time_base.num * (int64_t)AV_TIME_BASE,
2263 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2266 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2270 ret = avformat_queue_attached_pictures(s);
2274 if (s->iformat->read_timestamp) {
2275 // try to seek via read_timestamp()
2278 // Fall back on old API if new is not implemented but old is.
2279 // Note the old API has somewhat different semantics.
2280 if (s->iformat->read_seek || 1) {
2281 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2282 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2283 if (ret<0 && ts != min_ts && max_ts != ts) {
2284 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2286 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2291 // try some generic seek like seek_frame_generic() but with new ts semantics
2292 return -1; //unreachable
2295 int avformat_flush(AVFormatContext *s)
2297 ff_read_frame_flush(s);
2301 /*******************************************************/
2304 * Return TRUE if the stream has accurate duration in any stream.
2306 * @return TRUE if the stream has accurate duration for at least one component.
2308 static int has_duration(AVFormatContext *ic)
2313 for (i = 0; i < ic->nb_streams; i++) {
2314 st = ic->streams[i];
2315 if (st->duration != AV_NOPTS_VALUE)
2318 if (ic->duration != AV_NOPTS_VALUE)
2324 * Estimate the stream timings from the one of each components.
2326 * Also computes the global bitrate if possible.
2328 static void update_stream_timings(AVFormatContext *ic)
2330 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2331 int64_t duration, duration1, filesize;
2336 start_time = INT64_MAX;
2337 start_time_text = INT64_MAX;
2338 end_time = INT64_MIN;
2339 duration = INT64_MIN;
2340 for (i = 0; i < ic->nb_streams; i++) {
2341 st = ic->streams[i];
2342 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2343 start_time1 = av_rescale_q(st->start_time, st->time_base,
2345 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2346 if (start_time1 < start_time_text)
2347 start_time_text = start_time1;
2349 start_time = FFMIN(start_time, start_time1);
2350 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2352 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2353 if (end_time1 != AV_NOPTS_VALUE) {
2354 end_time1 += start_time1;
2355 end_time = FFMAX(end_time, end_time1);
2357 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2358 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2359 p->start_time = start_time1;
2360 if (p->end_time < end_time1)
2361 p->end_time = end_time1;
2364 if (st->duration != AV_NOPTS_VALUE) {
2365 duration1 = av_rescale_q(st->duration, st->time_base,
2367 duration = FFMAX(duration, duration1);
2370 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2371 start_time = start_time_text;
2372 else if (start_time > start_time_text)
2373 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2375 if (start_time != INT64_MAX) {
2376 ic->start_time = start_time;
2377 if (end_time != INT64_MIN) {
2378 if (ic->nb_programs) {
2379 for (i = 0; i < ic->nb_programs; i++) {
2380 p = ic->programs[i];
2381 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2382 duration = FFMAX(duration, p->end_time - p->start_time);
2385 duration = FFMAX(duration, end_time - start_time);
2388 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2389 ic->duration = duration;
2391 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2392 /* compute the bitrate */
2393 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2394 (double) ic->duration;
2395 if (bitrate >= 0 && bitrate <= INT64_MAX)
2396 ic->bit_rate = bitrate;
2400 static void fill_all_stream_timings(AVFormatContext *ic)
2405 update_stream_timings(ic);
2406 for (i = 0; i < ic->nb_streams; i++) {
2407 st = ic->streams[i];
2408 if (st->start_time == AV_NOPTS_VALUE) {
2409 if (ic->start_time != AV_NOPTS_VALUE)
2410 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2412 if (ic->duration != AV_NOPTS_VALUE)
2413 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2419 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2421 int64_t filesize, duration;
2422 int i, show_warning = 0;
2425 /* if bit_rate is already set, we believe it */
2426 if (ic->bit_rate <= 0) {
2428 for (i = 0; i < ic->nb_streams; i++) {
2429 st = ic->streams[i];
2430 if (st->codec->bit_rate > 0) {
2431 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2435 bit_rate += st->codec->bit_rate;
2436 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2437 // If we have a videostream with packets but without a bitrate
2438 // then consider the sum not known
2443 ic->bit_rate = bit_rate;
2446 /* if duration is already set, we believe it */
2447 if (ic->duration == AV_NOPTS_VALUE &&
2448 ic->bit_rate != 0) {
2449 filesize = ic->pb ? avio_size(ic->pb) : 0;
2450 if (filesize > ic->internal->data_offset) {
2451 filesize -= ic->internal->data_offset;
2452 for (i = 0; i < ic->nb_streams; i++) {
2453 st = ic->streams[i];
2454 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2455 && st->duration == AV_NOPTS_VALUE) {
2456 duration = av_rescale(8 * filesize, st->time_base.den,
2458 (int64_t) st->time_base.num);
2459 st->duration = duration;
2466 av_log(ic, AV_LOG_WARNING,
2467 "Estimating duration from bitrate, this may be inaccurate\n");
2470 #define DURATION_MAX_READ_SIZE 250000LL
2471 #define DURATION_MAX_RETRY 6
2473 /* only usable for MPEG-PS streams */
2474 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2476 AVPacket pkt1, *pkt = &pkt1;
2478 int num, den, read_size, i, ret;
2479 int found_duration = 0;
2481 int64_t filesize, offset, duration;
2484 /* flush packet queue */
2485 flush_packet_queue(ic);
2487 for (i = 0; i < ic->nb_streams; i++) {
2488 st = ic->streams[i];
2489 if (st->start_time == AV_NOPTS_VALUE &&
2490 st->first_dts == AV_NOPTS_VALUE &&
2491 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2492 av_log(st->codec, AV_LOG_WARNING,
2493 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2496 av_parser_close(st->parser);
2501 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2502 /* estimate the end time (duration) */
2503 /* XXX: may need to support wrapping */
2504 filesize = ic->pb ? avio_size(ic->pb) : 0;
2506 is_end = found_duration;
2507 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2511 avio_seek(ic->pb, offset, SEEK_SET);
2514 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2518 ret = ff_read_packet(ic, pkt);
2519 } while (ret == AVERROR(EAGAIN));
2522 read_size += pkt->size;
2523 st = ic->streams[pkt->stream_index];
2524 if (pkt->pts != AV_NOPTS_VALUE &&
2525 (st->start_time != AV_NOPTS_VALUE ||
2526 st->first_dts != AV_NOPTS_VALUE)) {
2527 if (pkt->duration == 0) {
2528 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2530 pkt->duration = av_rescale_rnd(1,
2531 num * (int64_t) st->time_base.den,
2532 den * (int64_t) st->time_base.num,
2536 duration = pkt->pts + pkt->duration;
2538 if (st->start_time != AV_NOPTS_VALUE)
2539 duration -= st->start_time;
2541 duration -= st->first_dts;
2543 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2544 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2545 st->duration = duration;
2546 st->info->last_duration = duration;
2549 av_packet_unref(pkt);
2552 /* check if all audio/video streams have valid duration */
2555 for (i = 0; i < ic->nb_streams; i++) {
2556 st = ic->streams[i];
2557 switch (st->codec->codec_type) {
2558 case AVMEDIA_TYPE_VIDEO:
2559 case AVMEDIA_TYPE_AUDIO:
2560 if (st->duration == AV_NOPTS_VALUE)
2567 ++retry <= DURATION_MAX_RETRY);
2569 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2571 /* warn about audio/video streams which duration could not be estimated */
2572 for (i = 0; i < ic->nb_streams; i++) {
2573 st = ic->streams[i];
2574 if (st->duration == AV_NOPTS_VALUE) {
2575 switch (st->codec->codec_type) {
2576 case AVMEDIA_TYPE_VIDEO:
2577 case AVMEDIA_TYPE_AUDIO:
2578 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2579 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2581 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2585 fill_all_stream_timings(ic);
2587 avio_seek(ic->pb, old_offset, SEEK_SET);
2588 for (i = 0; i < ic->nb_streams; i++) {
2591 st = ic->streams[i];
2592 st->cur_dts = st->first_dts;
2593 st->last_IP_pts = AV_NOPTS_VALUE;
2594 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2595 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2596 st->pts_buffer[j] = AV_NOPTS_VALUE;
2600 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2604 /* get the file size, if possible */
2605 if (ic->iformat->flags & AVFMT_NOFILE) {
2608 file_size = avio_size(ic->pb);
2609 file_size = FFMAX(0, file_size);
2612 if ((!strcmp(ic->iformat->name, "mpeg") ||
2613 !strcmp(ic->iformat->name, "mpegts")) &&
2614 file_size && ic->pb->seekable) {
2615 /* get accurate estimate from the PTSes */
2616 estimate_timings_from_pts(ic, old_offset);
2617 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2618 } else if (has_duration(ic)) {
2619 /* at least one component has timings - we use them for all
2621 fill_all_stream_timings(ic);
2622 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2624 /* less precise: use bitrate info */
2625 estimate_timings_from_bit_rate(ic);
2626 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2628 update_stream_timings(ic);
2632 AVStream av_unused *st;
2633 for (i = 0; i < ic->nb_streams; i++) {
2634 st = ic->streams[i];
2635 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2636 (double) st->start_time / AV_TIME_BASE,
2637 (double) st->duration / AV_TIME_BASE);
2639 av_log(ic, AV_LOG_TRACE,
2640 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2641 (double) ic->start_time / AV_TIME_BASE,
2642 (double) ic->duration / AV_TIME_BASE,
2643 (int64_t)ic->bit_rate / 1000);
2647 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2649 AVCodecContext *avctx = st->codec;
2651 #define FAIL(errmsg) do { \
2653 *errmsg_ptr = errmsg; \
2657 if ( avctx->codec_id == AV_CODEC_ID_NONE
2658 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2659 FAIL("unknown codec");
2660 switch (avctx->codec_type) {
2661 case AVMEDIA_TYPE_AUDIO:
2662 if (!avctx->frame_size && determinable_frame_size(avctx))
2663 FAIL("unspecified frame size");
2664 if (st->info->found_decoder >= 0 &&
2665 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2666 FAIL("unspecified sample format");
2667 if (!avctx->sample_rate)
2668 FAIL("unspecified sample rate");
2669 if (!avctx->channels)
2670 FAIL("unspecified number of channels");
2671 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2672 FAIL("no decodable DTS frames");
2674 case AVMEDIA_TYPE_VIDEO:
2676 FAIL("unspecified size");
2677 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2678 FAIL("unspecified pixel format");
2679 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2680 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2681 FAIL("no frame in rv30/40 and no sar");
2683 case AVMEDIA_TYPE_SUBTITLE:
2684 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2685 FAIL("unspecified size");
2687 case AVMEDIA_TYPE_DATA:
2688 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2694 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2695 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2696 AVDictionary **options)
2698 const AVCodec *codec;
2699 int got_picture = 1, ret = 0;
2700 AVFrame *frame = av_frame_alloc();
2701 AVSubtitle subtitle;
2702 AVPacket pkt = *avpkt;
2703 int do_skip_frame = 0;
2704 enum AVDiscard skip_frame;
2707 return AVERROR(ENOMEM);
2709 if (!avcodec_is_open(st->codec) &&
2710 st->info->found_decoder <= 0 &&
2711 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2712 AVDictionary *thread_opt = NULL;
2714 codec = find_decoder(s, st, st->codec->codec_id);
2717 st->info->found_decoder = -st->codec->codec_id;
2722 /* Force thread count to 1 since the H.264 decoder will not extract
2723 * SPS and PPS to extradata during multi-threaded decoding. */
2724 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2725 if (s->codec_whitelist)
2726 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2727 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2729 av_dict_free(&thread_opt);
2731 st->info->found_decoder = -st->codec->codec_id;
2734 st->info->found_decoder = 1;
2735 } else if (!st->info->found_decoder)
2736 st->info->found_decoder = 1;
2738 if (st->info->found_decoder < 0) {
2743 if (st->codec->codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM) {
2745 skip_frame = st->codec->skip_frame;
2746 st->codec->skip_frame = AVDISCARD_ALL;
2749 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2751 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2752 (!st->codec_info_nb_frames &&
2753 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2755 switch (st->codec->codec_type) {
2756 case AVMEDIA_TYPE_VIDEO:
2757 ret = avcodec_decode_video2(st->codec, frame,
2758 &got_picture, &pkt);
2760 case AVMEDIA_TYPE_AUDIO:
2761 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2763 case AVMEDIA_TYPE_SUBTITLE:
2764 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2765 &got_picture, &pkt);
2773 st->nb_decoded_frames++;
2780 if (!pkt.data && !got_picture)
2784 if (do_skip_frame) {
2785 st->codec->skip_frame = skip_frame;
2788 av_frame_free(&frame);
2792 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2794 while (tags->id != AV_CODEC_ID_NONE) {
2802 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2805 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2806 if (tag == tags[i].tag)
2808 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2809 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2811 return AV_CODEC_ID_NONE;
2814 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2819 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2821 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2823 return AV_CODEC_ID_NONE;
2828 if (sflags & (1 << (bps - 1))) {
2831 return AV_CODEC_ID_PCM_S8;
2833 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2835 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2837 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2839 return AV_CODEC_ID_NONE;
2844 return AV_CODEC_ID_PCM_U8;
2846 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2848 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2850 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2852 return AV_CODEC_ID_NONE;
2858 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2861 if (!av_codec_get_tag2(tags, id, &tag))
2866 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2870 for (i = 0; tags && tags[i]; i++) {
2871 const AVCodecTag *codec_tags = tags[i];
2872 while (codec_tags->id != AV_CODEC_ID_NONE) {
2873 if (codec_tags->id == id) {
2874 *tag = codec_tags->tag;
2883 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2886 for (i = 0; tags && tags[i]; i++) {
2887 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2888 if (id != AV_CODEC_ID_NONE)
2891 return AV_CODEC_ID_NONE;
2894 static void compute_chapters_end(AVFormatContext *s)
2897 int64_t max_time = 0;
2899 if (s->duration > 0)
2900 max_time = s->duration +
2901 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2903 for (i = 0; i < s->nb_chapters; i++)
2904 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2905 AVChapter *ch = s->chapters[i];
2906 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2910 for (j = 0; j < s->nb_chapters; j++) {
2911 AVChapter *ch1 = s->chapters[j];
2912 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2914 if (j != i && next_start > ch->start && next_start < end)
2917 ch->end = (end == INT64_MAX) ? ch->start : end;
2921 static int get_std_framerate(int i)
2924 return (i + 1) * 1001;
2928 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2932 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2935 /* Is the time base unreliable?
2936 * This is a heuristic to balance between quick acceptance of the values in
2937 * the headers vs. some extra checks.
2938 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2939 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2940 * And there are "variable" fps files this needs to detect as well. */
2941 static int tb_unreliable(AVCodecContext *c)
2943 if (c->time_base.den >= 101LL * c->time_base.num ||
2944 c->time_base.den < 5LL * c->time_base.num ||
2945 // c->codec_tag == AV_RL32("DIVX") ||
2946 // c->codec_tag == AV_RL32("XVID") ||
2947 c->codec_tag == AV_RL32("mp4v") ||
2948 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2949 c->codec_id == AV_CODEC_ID_GIF ||
2950 c->codec_id == AV_CODEC_ID_HEVC ||
2951 c->codec_id == AV_CODEC_ID_H264)
2956 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2960 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2961 avctx->extradata = NULL;
2962 avctx->extradata_size = 0;
2963 return AVERROR(EINVAL);
2965 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2966 if (avctx->extradata) {
2967 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2968 avctx->extradata_size = size;
2971 avctx->extradata_size = 0;
2972 ret = AVERROR(ENOMEM);
2977 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2979 int ret = ff_alloc_extradata(avctx, size);
2982 ret = avio_read(pb, avctx->extradata, size);
2984 av_freep(&avctx->extradata);
2985 avctx->extradata_size = 0;
2986 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2987 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2993 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2996 int64_t last = st->info->last_dts;
2998 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2999 && ts - (uint64_t)last < INT64_MAX) {
3000 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3001 int64_t duration = ts - last;
3003 if (!st->info->duration_error)
3004 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3005 if (!st->info->duration_error)
3006 return AVERROR(ENOMEM);
3008 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3009 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3010 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3011 if (st->info->duration_error[0][1][i] < 1e10) {
3012 int framerate = get_std_framerate(i);
3013 double sdts = dts*framerate/(1001*12);
3014 for (j= 0; j<2; j++) {
3015 int64_t ticks = llrint(sdts+j*0.5);
3016 double error= sdts - ticks + j*0.5;
3017 st->info->duration_error[j][0][i] += error;
3018 st->info->duration_error[j][1][i] += error*error;
3022 st->info->duration_count++;
3023 st->info->rfps_duration_sum += duration;
3025 if (st->info->duration_count % 10 == 0) {
3026 int n = st->info->duration_count;
3027 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3028 if (st->info->duration_error[0][1][i] < 1e10) {
3029 double a0 = st->info->duration_error[0][0][i] / n;
3030 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3031 double a1 = st->info->duration_error[1][0][i] / n;
3032 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3033 if (error0 > 0.04 && error1 > 0.04) {
3034 st->info->duration_error[0][1][i] = 2e10;
3035 st->info->duration_error[1][1][i] = 2e10;
3041 // ignore the first 4 values, they might have some random jitter
3042 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3043 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3045 if (ts != AV_NOPTS_VALUE)
3046 st->info->last_dts = ts;
3051 void ff_rfps_calculate(AVFormatContext *ic)
3055 for (i = 0; i < ic->nb_streams; i++) {
3056 AVStream *st = ic->streams[i];
3058 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3060 // the check for tb_unreliable() is not completely correct, since this is not about handling
3061 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3062 // ipmovie.c produces.
3063 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)
3064 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);
3065 if (st->info->duration_count>1 && !st->r_frame_rate.num
3066 && tb_unreliable(st->codec)) {
3068 double best_error= 0.01;
3069 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3071 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3074 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3076 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3079 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3082 for (k= 0; k<2; k++) {
3083 int n = st->info->duration_count;
3084 double a= st->info->duration_error[k][0][j] / n;
3085 double error= st->info->duration_error[k][1][j]/n - a*a;
3087 if (error < best_error && best_error> 0.000000001) {
3089 num = get_std_framerate(j);
3092 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3095 // do not increase frame rate by more than 1 % in order to match a standard rate.
3096 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3097 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3099 if ( !st->avg_frame_rate.num
3100 && st->r_frame_rate.num && st->info->rfps_duration_sum
3101 && st->info->codec_info_duration <= 0
3102 && st->info->duration_count > 2
3103 && 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
3105 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3106 st->avg_frame_rate = st->r_frame_rate;
3109 av_freep(&st->info->duration_error);
3110 st->info->last_dts = AV_NOPTS_VALUE;
3111 st->info->duration_count = 0;
3112 st->info->rfps_duration_sum = 0;
3116 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3118 int i, count, ret = 0, j;
3121 AVPacket pkt1, *pkt;
3122 int64_t old_offset = avio_tell(ic->pb);
3123 // new streams might appear, no options for those
3124 int orig_nb_streams = ic->nb_streams;
3126 int64_t max_analyze_duration = ic->max_analyze_duration;
3127 int64_t max_stream_analyze_duration;
3128 int64_t max_subtitle_analyze_duration;
3129 int64_t probesize = ic->probesize;
3131 flush_codecs = probesize > 0;
3133 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3135 max_stream_analyze_duration = max_analyze_duration;
3136 max_subtitle_analyze_duration = max_analyze_duration;
3137 if (!max_analyze_duration) {
3138 max_stream_analyze_duration =
3139 max_analyze_duration = 5*AV_TIME_BASE;
3140 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3141 if (!strcmp(ic->iformat->name, "flv"))
3142 max_stream_analyze_duration = 90*AV_TIME_BASE;
3146 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3147 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3149 for (i = 0; i < ic->nb_streams; i++) {
3150 const AVCodec *codec;
3151 AVDictionary *thread_opt = NULL;
3152 st = ic->streams[i];
3154 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3155 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3156 /* if (!st->time_base.num)
3158 if (!st->codec->time_base.num)
3159 st->codec->time_base = st->time_base;
3161 // only for the split stuff
3162 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3163 st->parser = av_parser_init(st->codec->codec_id);
3165 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3166 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3167 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3168 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3170 } else if (st->need_parsing) {
3171 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3172 "%s, packets or times may be invalid.\n",
3173 avcodec_get_name(st->codec->codec_id));
3176 codec = find_decoder(ic, st, st->codec->codec_id);
3178 /* Force thread count to 1 since the H.264 decoder will not extract
3179 * SPS and PPS to extradata during multi-threaded decoding. */
3180 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3182 if (ic->codec_whitelist)
3183 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3185 /* Ensure that subtitle_header is properly set. */
3186 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3187 && codec && !st->codec->codec) {
3188 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3189 av_log(ic, AV_LOG_WARNING,
3190 "Failed to open codec in av_find_stream_info\n");
3193 // Try to just open decoders, in case this is enough to get parameters.
3194 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3195 if (codec && !st->codec->codec)
3196 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3197 av_log(ic, AV_LOG_WARNING,
3198 "Failed to open codec in av_find_stream_info\n");
3201 av_dict_free(&thread_opt);
3204 for (i = 0; i < ic->nb_streams; i++) {
3205 #if FF_API_R_FRAME_RATE
3206 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3208 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3209 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3215 int analyzed_all_streams;
3216 if (ff_check_interrupt(&ic->interrupt_callback)) {
3218 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3222 /* check if one codec still needs to be handled */
3223 for (i = 0; i < ic->nb_streams; i++) {
3224 int fps_analyze_framecount = 20;
3226 st = ic->streams[i];
3227 if (!has_codec_parameters(st, NULL))
3229 /* If the timebase is coarse (like the usual millisecond precision
3230 * of mkv), we need to analyze more frames to reliably arrive at
3231 * the correct fps. */
3232 if (av_q2d(st->time_base) > 0.0005)
3233 fps_analyze_framecount *= 2;
3234 if (!tb_unreliable(st->codec))
3235 fps_analyze_framecount = 0;
3236 if (ic->fps_probe_size >= 0)
3237 fps_analyze_framecount = ic->fps_probe_size;
3238 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3239 fps_analyze_framecount = 0;
3240 /* variable fps and no guess at the real fps */
3241 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3242 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3243 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3244 st->info->codec_info_duration_fields/2 :
3245 st->info->duration_count;
3246 if (count < fps_analyze_framecount)
3249 if (st->parser && st->parser->parser->split &&
3250 !st->codec->extradata)
3252 if (st->first_dts == AV_NOPTS_VALUE &&
3253 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3254 st->codec_info_nb_frames < ic->max_ts_probe &&
3255 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3256 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3259 analyzed_all_streams = 0;
3260 if (i == ic->nb_streams) {
3261 analyzed_all_streams = 1;
3262 /* NOTE: If the format has no header, then we need to read some
3263 * packets to get most of the streams, so we cannot stop here. */
3264 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3265 /* If we found the info for all the codecs, we can stop. */
3267 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3272 /* We did not get all the codec info, but we read too much data. */
3273 if (read_size >= probesize) {
3275 av_log(ic, AV_LOG_DEBUG,
3276 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3277 for (i = 0; i < ic->nb_streams; i++)
3278 if (!ic->streams[i]->r_frame_rate.num &&
3279 ic->streams[i]->info->duration_count <= 1 &&
3280 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3281 strcmp(ic->iformat->name, "image2"))
3282 av_log(ic, AV_LOG_WARNING,
3283 "Stream #%d: not enough frames to estimate rate; "
3284 "consider increasing probesize\n", i);
3288 /* NOTE: A new stream can be added there if no header in file
3289 * (AVFMTCTX_NOHEADER). */
3290 ret = read_frame_internal(ic, &pkt1);
3291 if (ret == AVERROR(EAGAIN))
3301 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3302 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3303 &ic->internal->packet_buffer_end, 0);
3305 goto find_stream_info_err;
3308 st = ic->streams[pkt->stream_index];
3309 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3310 read_size += pkt->size;
3312 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3313 /* check for non-increasing dts */
3314 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3315 st->info->fps_last_dts >= pkt->dts) {
3316 av_log(ic, AV_LOG_DEBUG,
3317 "Non-increasing DTS in stream %d: packet %d with DTS "
3318 "%"PRId64", packet %d with DTS %"PRId64"\n",
3319 st->index, st->info->fps_last_dts_idx,
3320 st->info->fps_last_dts, st->codec_info_nb_frames,
3322 st->info->fps_first_dts =
3323 st->info->fps_last_dts = AV_NOPTS_VALUE;
3325 /* Check for a discontinuity in dts. If the difference in dts
3326 * is more than 1000 times the average packet duration in the
3327 * sequence, we treat it as a discontinuity. */
3328 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3329 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3330 (pkt->dts - st->info->fps_last_dts) / 1000 >
3331 (st->info->fps_last_dts - st->info->fps_first_dts) /
3332 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3333 av_log(ic, AV_LOG_WARNING,
3334 "DTS discontinuity in stream %d: packet %d with DTS "
3335 "%"PRId64", packet %d with DTS %"PRId64"\n",
3336 st->index, st->info->fps_last_dts_idx,
3337 st->info->fps_last_dts, st->codec_info_nb_frames,
3339 st->info->fps_first_dts =
3340 st->info->fps_last_dts = AV_NOPTS_VALUE;
3343 /* update stored dts values */
3344 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3345 st->info->fps_first_dts = pkt->dts;
3346 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3348 st->info->fps_last_dts = pkt->dts;
3349 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3351 if (st->codec_info_nb_frames>1) {
3355 if (st->time_base.den > 0)
3356 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3357 if (st->avg_frame_rate.num > 0)
3358 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3361 && st->codec_info_nb_frames>30
3362 && st->info->fps_first_dts != AV_NOPTS_VALUE
3363 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3364 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3366 if (analyzed_all_streams) limit = max_analyze_duration;
3367 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3368 else limit = max_stream_analyze_duration;
3371 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3373 t, pkt->stream_index);
3374 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3375 av_packet_unref(pkt);
3378 if (pkt->duration) {
3379 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3380 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3382 st->info->codec_info_duration += pkt->duration;
3383 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3386 #if FF_API_R_FRAME_RATE
3387 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3388 ff_rfps_add_frame(ic, st, pkt->dts);
3390 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3391 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3392 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3393 if (ff_alloc_extradata(st->codec, i))
3394 return AVERROR(ENOMEM);
3395 memcpy(st->codec->extradata, pkt->data,
3396 st->codec->extradata_size);
3400 /* If still no information, we try to open the codec and to
3401 * decompress the frame. We try to avoid that in most cases as
3402 * it takes longer and uses more memory. For MPEG-4, we need to
3403 * decompress for QuickTime.
3405 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3406 * least one frame of codec data, this makes sure the codec initializes
3407 * the channel configuration and does not only trust the values from
3409 try_decode_frame(ic, st, pkt,
3410 (options && i < orig_nb_streams) ? &options[i] : NULL);
3412 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3413 av_packet_unref(pkt);
3415 st->codec_info_nb_frames++;
3420 AVPacket empty_pkt = { 0 };
3422 av_init_packet(&empty_pkt);
3424 for (i = 0; i < ic->nb_streams; i++) {
3426 st = ic->streams[i];
3428 /* flush the decoders */
3429 if (st->info->found_decoder == 1) {
3431 err = try_decode_frame(ic, st, &empty_pkt,
3432 (options && i < orig_nb_streams)
3433 ? &options[i] : NULL);
3434 } while (err > 0 && !has_codec_parameters(st, NULL));
3437 av_log(ic, AV_LOG_INFO,
3438 "decoding for stream %d failed\n", st->index);
3444 // close codecs which were opened in try_decode_frame()
3445 for (i = 0; i < ic->nb_streams; i++) {
3446 st = ic->streams[i];
3447 avcodec_close(st->codec);
3450 ff_rfps_calculate(ic);
3452 for (i = 0; i < ic->nb_streams; i++) {
3453 st = ic->streams[i];
3454 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3455 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3456 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3457 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3458 st->codec->codec_tag= tag;
3461 /* estimate average framerate if not set by demuxer */
3462 if (st->info->codec_info_duration_fields &&
3463 !st->avg_frame_rate.num &&
3464 st->info->codec_info_duration) {
3466 double best_error = 0.01;
3468 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3469 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3470 st->info->codec_info_duration < 0)
3472 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3473 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3474 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3476 /* Round guessed framerate to a "standard" framerate if it's
3477 * within 1% of the original estimate. */
3478 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3479 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3480 double error = fabs(av_q2d(st->avg_frame_rate) /
3481 av_q2d(std_fps) - 1);
3483 if (error < best_error) {
3485 best_fps = std_fps.num;
3489 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3490 best_fps, 12 * 1001, INT_MAX);
3493 if (!st->r_frame_rate.num) {
3494 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3495 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3496 st->r_frame_rate.num = st->codec->time_base.den;
3497 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3499 st->r_frame_rate.num = st->time_base.den;
3500 st->r_frame_rate.den = st->time_base.num;
3503 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3504 AVRational hw_ratio = { st->codec->height, st->codec->width };
3505 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3508 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3509 if (!st->codec->bits_per_coded_sample)
3510 st->codec->bits_per_coded_sample =
3511 av_get_bits_per_sample(st->codec->codec_id);
3512 // set stream disposition based on audio service type
3513 switch (st->codec->audio_service_type) {
3514 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3515 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3517 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3518 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3520 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3521 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3523 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3524 st->disposition = AV_DISPOSITION_COMMENT;
3526 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3527 st->disposition = AV_DISPOSITION_KARAOKE;
3534 estimate_timings(ic, old_offset);
3536 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3538 if (ret >= 0 && ic->nb_streams)
3539 /* We could not have all the codec parameters before EOF. */
3541 for (i = 0; i < ic->nb_streams; i++) {
3543 st = ic->streams[i];
3544 if (!has_codec_parameters(st, &errmsg)) {
3546 avcodec_string(buf, sizeof(buf), st->codec, 0);
3547 av_log(ic, AV_LOG_WARNING,
3548 "Could not find codec parameters for stream %d (%s): %s\n"
3549 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3556 compute_chapters_end(ic);
3558 find_stream_info_err:
3559 for (i = 0; i < ic->nb_streams; i++) {
3560 st = ic->streams[i];
3561 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3562 ic->streams[i]->codec->thread_count = 0;
3564 av_freep(&st->info->duration_error);
3565 av_freep(&ic->streams[i]->info);
3568 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3569 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3573 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3577 for (i = 0; i < ic->nb_programs; i++) {
3578 if (ic->programs[i] == last) {
3582 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3583 if (ic->programs[i]->stream_index[j] == s)
3584 return ic->programs[i];
3590 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3591 int wanted_stream_nb, int related_stream,
3592 AVCodec **decoder_ret, int flags)
3594 int i, nb_streams = ic->nb_streams;
3595 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3596 unsigned *program = NULL;
3597 const AVCodec *decoder = NULL, *best_decoder = NULL;
3599 if (related_stream >= 0 && wanted_stream_nb < 0) {
3600 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3602 program = p->stream_index;
3603 nb_streams = p->nb_stream_indexes;
3606 for (i = 0; i < nb_streams; i++) {
3607 int real_stream_index = program ? program[i] : i;
3608 AVStream *st = ic->streams[real_stream_index];
3609 AVCodecContext *avctx = st->codec;
3610 if (avctx->codec_type != type)
3612 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3614 if (wanted_stream_nb != real_stream_index &&
3615 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3616 AV_DISPOSITION_VISUAL_IMPAIRED))
3618 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3621 decoder = find_decoder(ic, st, st->codec->codec_id);
3624 ret = AVERROR_DECODER_NOT_FOUND;
3628 count = st->codec_info_nb_frames;
3629 bitrate = avctx->bit_rate;
3631 bitrate = avctx->rc_max_rate;
3632 multiframe = FFMIN(5, count);
3633 if ((best_multiframe > multiframe) ||
3634 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3635 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3638 best_bitrate = bitrate;
3639 best_multiframe = multiframe;
3640 ret = real_stream_index;
3641 best_decoder = decoder;
3642 if (program && i == nb_streams - 1 && ret < 0) {
3644 nb_streams = ic->nb_streams;
3645 /* no related stream found, try again with everything */
3650 *decoder_ret = (AVCodec*)best_decoder;
3654 /*******************************************************/
3656 int av_read_play(AVFormatContext *s)
3658 if (s->iformat->read_play)
3659 return s->iformat->read_play(s);
3661 return avio_pause(s->pb, 0);
3662 return AVERROR(ENOSYS);
3665 int av_read_pause(AVFormatContext *s)
3667 if (s->iformat->read_pause)
3668 return s->iformat->read_pause(s);
3670 return avio_pause(s->pb, 1);
3671 return AVERROR(ENOSYS);
3674 static void free_stream(AVStream **pst)
3676 AVStream *st = *pst;
3682 for (i = 0; i < st->nb_side_data; i++)
3683 av_freep(&st->side_data[i].data);
3684 av_freep(&st->side_data);
3687 av_parser_close(st->parser);
3689 if (st->attached_pic.data)
3690 av_packet_unref(&st->attached_pic);
3692 av_freep(&st->internal);
3694 av_dict_free(&st->metadata);
3695 av_freep(&st->probe_data.buf);
3696 av_freep(&st->index_entries);
3697 av_freep(&st->codec->extradata);
3698 av_freep(&st->codec->subtitle_header);
3699 av_freep(&st->codec);
3700 av_freep(&st->priv_data);
3702 av_freep(&st->info->duration_error);
3703 av_freep(&st->info);
3704 av_freep(&st->recommended_encoder_configuration);
3705 av_freep(&st->priv_pts);
3710 void ff_free_stream(AVFormatContext *s, AVStream *st)
3712 av_assert0(s->nb_streams>0);
3713 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3715 free_stream(&s->streams[ --s->nb_streams ]);
3718 void avformat_free_context(AVFormatContext *s)
3726 if (s->iformat && s->iformat->priv_class && s->priv_data)
3727 av_opt_free(s->priv_data);
3728 if (s->oformat && s->oformat->priv_class && s->priv_data)
3729 av_opt_free(s->priv_data);
3731 for (i = s->nb_streams - 1; i >= 0; i--)
3732 ff_free_stream(s, s->streams[i]);
3735 for (i = s->nb_programs - 1; i >= 0; i--) {
3736 av_dict_free(&s->programs[i]->metadata);
3737 av_freep(&s->programs[i]->stream_index);
3738 av_freep(&s->programs[i]);
3740 av_freep(&s->programs);
3741 av_freep(&s->priv_data);
3742 while (s->nb_chapters--) {
3743 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3744 av_freep(&s->chapters[s->nb_chapters]);
3746 av_freep(&s->chapters);
3747 av_dict_free(&s->metadata);
3748 av_freep(&s->streams);
3749 av_freep(&s->internal);
3750 flush_packet_queue(s);
3754 void avformat_close_input(AVFormatContext **ps)
3765 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3766 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3769 flush_packet_queue(s);
3772 if (s->iformat->read_close)
3773 s->iformat->read_close(s);
3775 avformat_free_context(s);
3782 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3788 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3790 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3793 s->streams = streams;
3795 st = av_mallocz(sizeof(AVStream));
3798 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3802 st->info->last_dts = AV_NOPTS_VALUE;
3804 st->codec = avcodec_alloc_context3(c);
3811 st->internal = av_mallocz(sizeof(*st->internal));
3816 /* no default bitrate if decoding */
3817 st->codec->bit_rate = 0;
3819 /* default pts setting is MPEG-like */
3820 avpriv_set_pts_info(st, 33, 1, 90000);
3821 /* we set the current DTS to 0 so that formats without any timestamps
3822 * but durations get some timestamps, formats with some unknown
3823 * timestamps have their first few packets buffered and the
3824 * timestamps corrected before they are returned to the user */
3825 st->cur_dts = RELATIVE_TS_BASE;
3827 st->cur_dts = AV_NOPTS_VALUE;
3830 st->index = s->nb_streams;
3831 st->start_time = AV_NOPTS_VALUE;
3832 st->duration = AV_NOPTS_VALUE;
3833 st->first_dts = AV_NOPTS_VALUE;
3834 st->probe_packets = MAX_PROBE_PACKETS;
3835 st->pts_wrap_reference = AV_NOPTS_VALUE;
3836 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3838 st->last_IP_pts = AV_NOPTS_VALUE;
3839 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3840 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3841 st->pts_buffer[i] = AV_NOPTS_VALUE;
3843 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3845 #if FF_API_R_FRAME_RATE
3846 st->info->last_dts = AV_NOPTS_VALUE;
3848 st->info->fps_first_dts = AV_NOPTS_VALUE;
3849 st->info->fps_last_dts = AV_NOPTS_VALUE;
3851 st->inject_global_side_data = s->internal->inject_global_side_data;
3853 s->streams[s->nb_streams++] = st;
3860 AVProgram *av_new_program(AVFormatContext *ac, int id)
3862 AVProgram *program = NULL;
3865 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3867 for (i = 0; i < ac->nb_programs; i++)
3868 if (ac->programs[i]->id == id)
3869 program = ac->programs[i];
3872 program = av_mallocz(sizeof(AVProgram));
3875 dynarray_add(&ac->programs, &ac->nb_programs, program);
3876 program->discard = AVDISCARD_NONE;
3879 program->pts_wrap_reference = AV_NOPTS_VALUE;
3880 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3882 program->start_time =
3883 program->end_time = AV_NOPTS_VALUE;
3888 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3889 int64_t start, int64_t end, const char *title)
3891 AVChapter *chapter = NULL;
3894 if (end != AV_NOPTS_VALUE && start > end) {
3895 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3899 for (i = 0; i < s->nb_chapters; i++)
3900 if (s->chapters[i]->id == id)
3901 chapter = s->chapters[i];
3904 chapter = av_mallocz(sizeof(AVChapter));
3907 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3909 av_dict_set(&chapter->metadata, "title", title, 0);
3911 chapter->time_base = time_base;
3912 chapter->start = start;
3918 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3921 AVProgram *program = NULL;
3924 if (idx >= ac->nb_streams) {
3925 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3929 for (i = 0; i < ac->nb_programs; i++) {
3930 if (ac->programs[i]->id != progid)
3932 program = ac->programs[i];
3933 for (j = 0; j < program->nb_stream_indexes; j++)
3934 if (program->stream_index[j] == idx)
3937 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3940 program->stream_index = tmp;
3941 program->stream_index[program->nb_stream_indexes++] = idx;
3946 uint64_t ff_ntp_time(void)
3948 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3951 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3954 char *q, buf1[20], c;
3955 int nd, len, percentd_found;
3967 while (av_isdigit(*p))
3968 nd = nd * 10 + *p++ - '0';
3970 } while (av_isdigit(c));
3981 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3983 if ((q - buf + len) > buf_size - 1)
3985 memcpy(q, buf1, len);
3993 if ((q - buf) < buf_size - 1)
3997 if (!percentd_found)
4006 void av_url_split(char *proto, int proto_size,
4007 char *authorization, int authorization_size,
4008 char *hostname, int hostname_size,
4009 int *port_ptr, char *path, int path_size, const char *url)
4011 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4017 if (authorization_size > 0)
4018 authorization[0] = 0;
4019 if (hostname_size > 0)
4024 /* parse protocol */
4025 if ((p = strchr(url, ':'))) {
4026 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4033 /* no protocol means plain filename */
4034 av_strlcpy(path, url, path_size);
4038 /* separate path from hostname */
4039 ls = strchr(p, '/');
4040 ls2 = strchr(p, '?');
4044 ls = FFMIN(ls, ls2);
4046 av_strlcpy(path, ls, path_size);
4048 ls = &p[strlen(p)]; // XXX
4050 /* the rest is hostname, use that to parse auth/port */
4052 /* authorization (user[:pass]@hostname) */
4054 while ((at = strchr(p, '@')) && at < ls) {
4055 av_strlcpy(authorization, at2,
4056 FFMIN(authorization_size, at + 1 - at2));
4057 p = at + 1; /* skip '@' */
4060 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4062 av_strlcpy(hostname, p + 1,
4063 FFMIN(hostname_size, brk - p));
4064 if (brk[1] == ':' && port_ptr)
4065 *port_ptr = atoi(brk + 2);
4066 } else if ((col = strchr(p, ':')) && col < ls) {
4067 av_strlcpy(hostname, p,
4068 FFMIN(col + 1 - p, hostname_size));
4070 *port_ptr = atoi(col + 1);
4072 av_strlcpy(hostname, p,
4073 FFMIN(ls + 1 - p, hostname_size));
4077 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4080 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4083 'C', 'D', 'E', 'F' };
4084 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4087 'c', 'd', 'e', 'f' };
4088 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4090 for (i = 0; i < s; i++) {
4091 buff[i * 2] = hex_table[src[i] >> 4];
4092 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4098 int ff_hex_to_data(uint8_t *data, const char *p)
4105 p += strspn(p, SPACE_CHARS);
4108 c = av_toupper((unsigned char) *p++);
4109 if (c >= '0' && c <= '9')
4111 else if (c >= 'A' && c <= 'F')
4126 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4127 unsigned int pts_num, unsigned int pts_den)
4130 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4131 if (new_tb.num != pts_num)
4132 av_log(NULL, AV_LOG_DEBUG,
4133 "st:%d removing common factor %d from timebase\n",
4134 s->index, pts_num / new_tb.num);
4136 av_log(NULL, AV_LOG_WARNING,
4137 "st:%d has too large timebase, reducing\n", s->index);
4139 if (new_tb.num <= 0 || new_tb.den <= 0) {
4140 av_log(NULL, AV_LOG_ERROR,
4141 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4142 new_tb.num, new_tb.den,
4146 s->time_base = new_tb;
4147 av_codec_set_pkt_timebase(s->codec, new_tb);
4148 s->pts_wrap_bits = pts_wrap_bits;
4151 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4154 const char *ptr = str;
4156 /* Parse key=value pairs. */
4159 char *dest = NULL, *dest_end;
4160 int key_len, dest_len = 0;
4162 /* Skip whitespace and potential commas. */
4163 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4170 if (!(ptr = strchr(key, '=')))
4173 key_len = ptr - key;
4175 callback_get_buf(context, key, key_len, &dest, &dest_len);
4176 dest_end = dest + dest_len - 1;
4180 while (*ptr && *ptr != '\"') {
4184 if (dest && dest < dest_end)
4188 if (dest && dest < dest_end)
4196 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4197 if (dest && dest < dest_end)
4205 int ff_find_stream_index(AVFormatContext *s, int id)
4208 for (i = 0; i < s->nb_streams; i++)
4209 if (s->streams[i]->id == id)
4214 int64_t ff_iso8601_to_unix_time(const char *datestr)
4216 struct tm time1 = { 0 }, time2 = { 0 };
4217 const char *ret1, *ret2;
4218 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4219 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4221 return av_timegm(&time2);
4223 return av_timegm(&time1);
4226 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4230 unsigned int codec_tag;
4231 if (ofmt->query_codec)
4232 return ofmt->query_codec(codec_id, std_compliance);
4233 else if (ofmt->codec_tag)
4234 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4235 else if (codec_id == ofmt->video_codec ||
4236 codec_id == ofmt->audio_codec ||
4237 codec_id == ofmt->subtitle_codec)
4240 return AVERROR_PATCHWELCOME;
4243 int avformat_network_init(void)
4247 ff_network_inited_globally = 1;
4248 if ((ret = ff_network_init()) < 0)
4250 if ((ret = ff_tls_init()) < 0)
4256 int avformat_network_deinit(void)
4261 ff_network_inited_globally = 0;
4266 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4267 uint64_t channel_layout, int32_t sample_rate,
4268 int32_t width, int32_t height)
4274 return AVERROR(EINVAL);
4277 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4279 if (channel_layout) {
4281 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4285 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4287 if (width || height) {
4289 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4291 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4293 return AVERROR(ENOMEM);
4294 bytestream_put_le32(&data, flags);
4296 bytestream_put_le32(&data, channels);
4298 bytestream_put_le64(&data, channel_layout);
4300 bytestream_put_le32(&data, sample_rate);
4301 if (width || height) {
4302 bytestream_put_le32(&data, width);
4303 bytestream_put_le32(&data, height);
4308 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4310 AVRational undef = {0, 1};
4311 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4312 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4313 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4315 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4316 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4317 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4318 stream_sample_aspect_ratio = undef;
4320 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4321 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4322 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4323 frame_sample_aspect_ratio = undef;
4325 if (stream_sample_aspect_ratio.num)
4326 return stream_sample_aspect_ratio;
4328 return frame_sample_aspect_ratio;
4331 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4333 AVRational fr = st->r_frame_rate;
4334 AVRational codec_fr = st->codec->framerate;
4335 AVRational avg_fr = st->avg_frame_rate;
4337 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4338 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4343 if (st->codec->ticks_per_frame > 1) {
4344 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4345 (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))
4352 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4355 if (*spec <= '9' && *spec >= '0') /* opt:index */
4356 return strtol(spec, NULL, 0) == st->index;
4357 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4358 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4359 enum AVMediaType type;
4363 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4364 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4365 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4366 case 'd': type = AVMEDIA_TYPE_DATA; break;
4367 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4368 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4369 default: av_assert0(0);
4371 if (type != st->codec->codec_type)
4373 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4375 if (*spec++ == ':') { /* possibly followed by :index */
4376 int i, index = strtol(spec, NULL, 0);
4377 for (i = 0; i < s->nb_streams; i++)
4378 if (s->streams[i]->codec->codec_type == type &&
4379 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4381 return i == st->index;
4385 } else if (*spec == 'p' && *(spec + 1) == ':') {
4389 prog_id = strtol(spec, &endptr, 0);
4390 for (i = 0; i < s->nb_programs; i++) {
4391 if (s->programs[i]->id != prog_id)
4394 if (*endptr++ == ':') {
4395 int stream_idx = strtol(endptr, NULL, 0);
4396 return stream_idx >= 0 &&
4397 stream_idx < s->programs[i]->nb_stream_indexes &&
4398 st->index == s->programs[i]->stream_index[stream_idx];
4401 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4402 if (st->index == s->programs[i]->stream_index[j])
4406 } else if (*spec == '#' ||
4407 (*spec == 'i' && *(spec + 1) == ':')) {
4410 spec += 1 + (*spec == 'i');
4411 stream_id = strtol(spec, &endptr, 0);
4413 return stream_id == st->id;
4414 } else if (*spec == 'm' && *(spec + 1) == ':') {
4415 AVDictionaryEntry *tag;
4420 val = strchr(spec, ':');
4422 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4424 return AVERROR(ENOMEM);
4426 tag = av_dict_get(st->metadata, key, NULL, 0);
4428 if (!val || !strcmp(tag->value, val + 1))
4437 } else if (*spec == 'u') {
4438 AVCodecContext *avctx = st->codec;
4440 switch (avctx->codec_type) {
4441 case AVMEDIA_TYPE_AUDIO:
4442 val = avctx->sample_rate && avctx->channels;
4443 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4446 case AVMEDIA_TYPE_VIDEO:
4447 val = avctx->width && avctx->height;
4448 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4451 case AVMEDIA_TYPE_UNKNOWN:
4458 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4459 } else if (!*spec) /* empty specifier, matches everything */
4462 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4463 return AVERROR(EINVAL);
4466 int ff_generate_avci_extradata(AVStream *st)
4468 static const uint8_t avci100_1080p_extradata[] = {
4470 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4471 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4472 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4473 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4474 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4475 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4476 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4477 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4478 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4480 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4483 static const uint8_t avci100_1080i_extradata[] = {
4485 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4486 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4487 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4488 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4489 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4490 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4491 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4492 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4493 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4494 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4495 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4497 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4500 static const uint8_t avci50_1080p_extradata[] = {
4502 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4503 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4504 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4505 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4506 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4507 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4508 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4509 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4510 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4512 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4515 static const uint8_t avci50_1080i_extradata[] = {
4517 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4518 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4519 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4520 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4521 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4522 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4523 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4524 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4525 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4526 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4527 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4529 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4532 static const uint8_t avci100_720p_extradata[] = {
4534 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4535 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4536 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4537 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4538 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4539 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4540 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4541 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4542 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4543 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4545 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4548 static const uint8_t avci50_720p_extradata[] = {
4550 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4551 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4552 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4553 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4554 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4555 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4556 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4557 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4558 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4560 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4564 const uint8_t *data = NULL;
4567 if (st->codec->width == 1920) {
4568 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4569 data = avci100_1080p_extradata;
4570 size = sizeof(avci100_1080p_extradata);
4572 data = avci100_1080i_extradata;
4573 size = sizeof(avci100_1080i_extradata);
4575 } else if (st->codec->width == 1440) {
4576 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4577 data = avci50_1080p_extradata;
4578 size = sizeof(avci50_1080p_extradata);
4580 data = avci50_1080i_extradata;
4581 size = sizeof(avci50_1080i_extradata);
4583 } else if (st->codec->width == 1280) {
4584 data = avci100_720p_extradata;
4585 size = sizeof(avci100_720p_extradata);
4586 } else if (st->codec->width == 960) {
4587 data = avci50_720p_extradata;
4588 size = sizeof(avci50_720p_extradata);
4594 av_freep(&st->codec->extradata);
4595 if (ff_alloc_extradata(st->codec, size))
4596 return AVERROR(ENOMEM);
4597 memcpy(st->codec->extradata, data, size);
4602 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4607 for (i = 0; i < st->nb_side_data; i++) {
4608 if (st->side_data[i].type == type) {
4610 *size = st->side_data[i].size;
4611 return st->side_data[i].data;
4617 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4620 AVPacketSideData *sd, *tmp;
4622 uint8_t *data = av_malloc(size);
4627 for (i = 0; i < st->nb_side_data; i++) {
4628 sd = &st->side_data[i];
4630 if (sd->type == type) {
4631 av_freep(&sd->data);
4638 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4644 st->side_data = tmp;
4647 sd = &st->side_data[st->nb_side_data - 1];
4654 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4656 AVBitStreamFilterContext *bsfc = NULL;
4657 AVBitStreamFilterContext **dest = &st->internal->bsfc;
4658 while (*dest && (*dest)->next)
4659 dest = &(*dest)->next;
4661 if (!(bsfc = av_bitstream_filter_init(name))) {
4662 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4663 return AVERROR(EINVAL);
4665 if (args && !(bsfc->args = av_strdup(args))) {
4666 av_bitstream_filter_close(bsfc);
4667 return AVERROR(ENOMEM);
4669 av_log(st->codec, AV_LOG_VERBOSE,
4670 "Automatically inserted bitstream filter '%s'; args='%s'\n",
4671 name, args ? args : "");
4676 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4677 AVBitStreamFilterContext *bsfc)
4681 AVPacket new_pkt = *pkt;
4682 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4683 &new_pkt.data, &new_pkt.size,
4684 pkt->data, pkt->size,
4685 pkt->flags & AV_PKT_FLAG_KEY);
4686 if(a == 0 && new_pkt.data != pkt->data) {
4687 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
4689 memcpy(t, new_pkt.data, new_pkt.size);
4690 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
4695 a = AVERROR(ENOMEM);
4699 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
4700 av_buffer_default_free, NULL, 0);
4702 pkt->side_data = NULL;
4703 pkt->side_data_elems = 0;
4704 av_packet_unref(pkt);
4706 av_freep(&new_pkt.data);
4707 a = AVERROR(ENOMEM);
4711 av_log(codec, AV_LOG_ERROR,
4712 "Failed to open bitstream filter %s for stream %d with codec %s",
4713 bsfc->filter->name, pkt->stream_index,
4714 codec->codec ? codec->codec->name : "copy");