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)
116 int64_t av_stream_get_end_pts(const AVStream *st)
121 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
126 void av_format_inject_global_side_data(AVFormatContext *s)
129 s->internal->inject_global_side_data = 1;
130 for (i = 0; i < s->nb_streams; i++) {
131 AVStream *st = s->streams[i];
132 st->inject_global_side_data = 1;
136 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
138 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
139 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
140 dst->format_whitelist = av_strdup(src->format_whitelist);
141 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
142 || (src->format_whitelist && !dst->format_whitelist)) {
143 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
144 return AVERROR(ENOMEM);
149 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
151 if (st->codec->codec)
152 return st->codec->codec;
154 switch (st->codec->codec_type) {
155 case AVMEDIA_TYPE_VIDEO:
156 if (s->video_codec) return s->video_codec;
158 case AVMEDIA_TYPE_AUDIO:
159 if (s->audio_codec) return s->audio_codec;
161 case AVMEDIA_TYPE_SUBTITLE:
162 if (s->subtitle_codec) return s->subtitle_codec;
166 return avcodec_find_decoder(codec_id);
169 int av_format_get_probe_score(const AVFormatContext *s)
171 return s->probe_score;
174 /* an arbitrarily chosen "sane" max packet size -- 50M */
175 #define SANE_CHUNK_SIZE (50000000)
177 int ffio_limit(AVIOContext *s, int size)
179 if (s->maxsize>= 0) {
180 int64_t remaining= s->maxsize - avio_tell(s);
181 if (remaining < size) {
182 int64_t newsize = avio_size(s);
183 if (!s->maxsize || s->maxsize<newsize)
184 s->maxsize = newsize - !newsize;
185 remaining= s->maxsize - avio_tell(s);
186 remaining= FFMAX(remaining, 0);
189 if (s->maxsize>= 0 && remaining+1 < size) {
190 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
197 /* Read the data in sane-sized chunks and append to pkt.
198 * Return the number of bytes read or an error. */
199 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
201 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
202 int orig_size = pkt->size;
206 int prev_size = pkt->size;
209 /* When the caller requests a lot of data, limit it to the amount
210 * left in file or SANE_CHUNK_SIZE when it is not known. */
212 if (read_size > SANE_CHUNK_SIZE/10) {
213 read_size = ffio_limit(s, read_size);
214 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
216 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
219 ret = av_grow_packet(pkt, read_size);
223 ret = avio_read(s, pkt->data + prev_size, read_size);
224 if (ret != read_size) {
225 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
232 pkt->flags |= AV_PKT_FLAG_CORRUPT;
237 return pkt->size > orig_size ? pkt->size - orig_size : ret;
240 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
245 pkt->pos = avio_tell(s);
247 return append_packet_chunked(s, pkt, size);
250 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
253 return av_get_packet(s, pkt, size);
254 return append_packet_chunked(s, pkt, size);
257 int av_filename_number_test(const char *filename)
261 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
264 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
267 static const struct {
270 enum AVMediaType type;
272 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
273 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
274 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
275 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
276 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
277 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
278 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
279 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
280 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
281 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
282 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
286 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
288 if (fmt && st->request_probe <= score) {
290 av_log(s, AV_LOG_DEBUG,
291 "Probe with size=%d, packets=%d detected %s with score=%d\n",
292 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
294 for (i = 0; fmt_id_type[i].name; i++) {
295 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
296 st->codec->codec_id = fmt_id_type[i].id;
297 st->codec->codec_type = fmt_id_type[i].type;
305 /************************************************************/
306 /* input media file */
308 int av_demuxer_open(AVFormatContext *ic) {
311 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
312 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
313 return AVERROR(EINVAL);
316 if (ic->iformat->read_header) {
317 err = ic->iformat->read_header(ic);
322 if (ic->pb && !ic->internal->data_offset)
323 ic->internal->data_offset = avio_tell(ic->pb);
328 /* Open input file and probe the format if necessary. */
329 static int init_input(AVFormatContext *s, const char *filename,
330 AVDictionary **options)
333 AVProbeData pd = { filename, NULL, 0 };
334 int score = AVPROBE_SCORE_RETRY;
337 s->flags |= AVFMT_FLAG_CUSTOM_IO;
339 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
340 s, 0, s->format_probesize);
341 else if (s->iformat->flags & AVFMT_NOFILE)
342 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
343 "will be ignored with AVFMT_NOFILE format.\n");
347 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
348 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
351 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
352 &s->interrupt_callback, options)) < 0)
356 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
357 s, 0, s->format_probesize);
360 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
361 AVPacketList **plast_pktl)
363 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
368 (*plast_pktl)->next = pktl;
370 *packet_buffer = pktl;
372 /* Add the packet in the buffered packet list. */
378 int avformat_queue_attached_pictures(AVFormatContext *s)
381 for (i = 0; i < s->nb_streams; i++)
382 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
383 s->streams[i]->discard < AVDISCARD_ALL) {
384 AVPacket copy = s->streams[i]->attached_pic;
385 if (copy.size <= 0) {
386 av_log(s, AV_LOG_WARNING,
387 "Attached picture on stream %d has invalid size, "
391 copy.buf = av_buffer_ref(copy.buf);
393 return AVERROR(ENOMEM);
395 add_to_pktbuf(&s->internal->raw_packet_buffer, ©,
396 &s->internal->raw_packet_buffer_end);
401 int avformat_open_input(AVFormatContext **ps, const char *filename,
402 AVInputFormat *fmt, AVDictionary **options)
404 AVFormatContext *s = *ps;
406 AVDictionary *tmp = NULL;
407 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
409 if (!s && !(s = avformat_alloc_context()))
410 return AVERROR(ENOMEM);
412 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
413 return AVERROR(EINVAL);
419 av_dict_copy(&tmp, *options, 0);
421 if (s->pb) // must be before any goto fail
422 s->flags |= AVFMT_FLAG_CUSTOM_IO;
424 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
427 if ((ret = init_input(s, filename, &tmp)) < 0)
429 s->probe_score = ret;
431 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
432 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
433 ret = AVERROR(EINVAL);
437 avio_skip(s->pb, s->skip_initial_bytes);
439 /* Check filename in case an image number is expected. */
440 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
441 if (!av_filename_number_test(filename)) {
442 ret = AVERROR(EINVAL);
447 s->duration = s->start_time = AV_NOPTS_VALUE;
448 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
450 /* Allocate private data. */
451 if (s->iformat->priv_data_size > 0) {
452 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
453 ret = AVERROR(ENOMEM);
456 if (s->iformat->priv_class) {
457 *(const AVClass **) s->priv_data = s->iformat->priv_class;
458 av_opt_set_defaults(s->priv_data);
459 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
464 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
466 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
468 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
469 if ((ret = s->iformat->read_header(s)) < 0)
472 if (id3v2_extra_meta) {
473 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
474 !strcmp(s->iformat->name, "tta")) {
475 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
478 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
480 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
482 if ((ret = avformat_queue_attached_pictures(s)) < 0)
485 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
486 s->internal->data_offset = avio_tell(s->pb);
488 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
491 av_dict_free(options);
498 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
500 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
502 avformat_free_context(s);
507 /*******************************************************/
509 static void force_codec_ids(AVFormatContext *s, AVStream *st)
511 switch (st->codec->codec_type) {
512 case AVMEDIA_TYPE_VIDEO:
513 if (s->video_codec_id)
514 st->codec->codec_id = s->video_codec_id;
516 case AVMEDIA_TYPE_AUDIO:
517 if (s->audio_codec_id)
518 st->codec->codec_id = s->audio_codec_id;
520 case AVMEDIA_TYPE_SUBTITLE:
521 if (s->subtitle_codec_id)
522 st->codec->codec_id = s->subtitle_codec_id;
527 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
529 if (st->request_probe>0) {
530 AVProbeData *pd = &st->probe_data;
532 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
536 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
538 av_log(s, AV_LOG_WARNING,
539 "Failed to reallocate probe buffer for stream %d\n",
544 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
545 pd->buf_size += pkt->size;
546 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
549 st->probe_packets = 0;
551 av_log(s, AV_LOG_WARNING,
552 "nothing to probe for stream %d\n", st->index);
556 end= s->internal->raw_packet_buffer_remaining_size <= 0
557 || st->probe_packets<= 0;
559 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
560 int score = set_codec_from_probe_data(s, st, pd);
561 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
565 st->request_probe = -1;
566 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
567 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
569 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
571 force_codec_ids(s, st);
577 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
579 int64_t ref = pkt->dts;
580 int i, pts_wrap_behavior;
581 int64_t pts_wrap_reference;
582 AVProgram *first_program;
584 if (ref == AV_NOPTS_VALUE)
586 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
588 ref &= (1LL << st->pts_wrap_bits)-1;
590 // reference time stamp should be 60 s before first time stamp
591 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
592 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
593 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
594 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
595 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
597 first_program = av_find_program_from_stream(s, NULL, stream_index);
599 if (!first_program) {
600 int default_stream_index = av_find_default_stream_index(s);
601 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
602 for (i = 0; i < s->nb_streams; i++) {
603 if (av_find_program_from_stream(s, NULL, i))
605 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
606 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
610 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
611 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
615 AVProgram *program = first_program;
617 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
618 pts_wrap_reference = program->pts_wrap_reference;
619 pts_wrap_behavior = program->pts_wrap_behavior;
622 program = av_find_program_from_stream(s, program, stream_index);
625 // update every program with differing pts_wrap_reference
626 program = first_program;
628 if (program->pts_wrap_reference != pts_wrap_reference) {
629 for (i = 0; i<program->nb_stream_indexes; i++) {
630 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
631 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
634 program->pts_wrap_reference = pts_wrap_reference;
635 program->pts_wrap_behavior = pts_wrap_behavior;
637 program = av_find_program_from_stream(s, program, stream_index);
643 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
649 AVPacketList *pktl = s->internal->raw_packet_buffer;
653 st = s->streams[pkt->stream_index];
654 if (s->internal->raw_packet_buffer_remaining_size <= 0)
655 if ((err = probe_codec(s, st, NULL)) < 0)
657 if (st->request_probe <= 0) {
658 s->internal->raw_packet_buffer = pktl->next;
659 s->internal->raw_packet_buffer_remaining_size += pkt->size;
668 ret = s->iformat->read_packet(s, pkt);
670 if (!pktl || ret == AVERROR(EAGAIN))
672 for (i = 0; i < s->nb_streams; i++) {
674 if (st->probe_packets)
675 if ((err = probe_codec(s, st, NULL)) < 0)
677 av_assert0(st->request_probe <= 0);
682 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
683 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
684 av_log(s, AV_LOG_WARNING,
685 "Dropped corrupted packet (stream = %d)\n",
691 if (pkt->stream_index >= (unsigned)s->nb_streams) {
692 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
696 st = s->streams[pkt->stream_index];
698 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
699 // correct first time stamps to negative values
700 if (!is_relative(st->first_dts))
701 st->first_dts = wrap_timestamp(st, st->first_dts);
702 if (!is_relative(st->start_time))
703 st->start_time = wrap_timestamp(st, st->start_time);
704 if (!is_relative(st->cur_dts))
705 st->cur_dts = wrap_timestamp(st, st->cur_dts);
708 pkt->dts = wrap_timestamp(st, pkt->dts);
709 pkt->pts = wrap_timestamp(st, pkt->pts);
711 force_codec_ids(s, st);
713 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
714 if (s->use_wallclock_as_timestamps)
715 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
717 if (!pktl && st->request_probe <= 0)
720 add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
721 &s->internal->raw_packet_buffer_end);
722 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
724 if ((err = probe_codec(s, st, pkt)) < 0)
730 /**********************************************************/
732 static int determinable_frame_size(AVCodecContext *avctx)
734 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
735 avctx->codec_id == AV_CODEC_ID_MP1 ||
736 avctx->codec_id == AV_CODEC_ID_MP2 ||
737 avctx->codec_id == AV_CODEC_ID_MP3/* ||
738 avctx->codec_id == AV_CODEC_ID_CELT*/)
744 * Return the frame duration in seconds. Return 0 if not available.
746 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
747 AVCodecParserContext *pc, AVPacket *pkt)
749 AVRational codec_framerate = s->iformat ? st->codec->framerate :
750 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
755 switch (st->codec->codec_type) {
756 case AVMEDIA_TYPE_VIDEO:
757 if (st->r_frame_rate.num && !pc && s->iformat) {
758 *pnum = st->r_frame_rate.den;
759 *pden = st->r_frame_rate.num;
760 } else if (st->time_base.num * 1000LL > st->time_base.den) {
761 *pnum = st->time_base.num;
762 *pden = st->time_base.den;
763 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
764 av_assert0(st->codec->ticks_per_frame);
765 av_reduce(pnum, pden,
767 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
770 if (pc && pc->repeat_pict) {
771 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
772 av_reduce(pnum, pden,
773 (*pnum) * (1LL + pc->repeat_pict),
777 /* If this codec can be interlaced or progressive then we need
778 * a parser to compute duration of a packet. Thus if we have
779 * no parser in such case leave duration undefined. */
780 if (st->codec->ticks_per_frame > 1 && !pc)
784 case AVMEDIA_TYPE_AUDIO:
785 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
786 if (frame_size <= 0 || st->codec->sample_rate <= 0)
789 *pden = st->codec->sample_rate;
796 static int is_intra_only(AVCodecContext *enc) {
797 const AVCodecDescriptor *desc;
799 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
802 desc = av_codec_get_codec_descriptor(enc);
804 desc = avcodec_descriptor_get(enc->codec_id);
805 av_codec_set_codec_descriptor(enc, desc);
808 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
812 static int has_decode_delay_been_guessed(AVStream *st)
814 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
815 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
817 #if CONFIG_H264_DECODER
818 if (st->codec->has_b_frames &&
819 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
822 if (st->codec->has_b_frames<3)
823 return st->nb_decoded_frames >= 7;
824 else if (st->codec->has_b_frames<4)
825 return st->nb_decoded_frames >= 18;
827 return st->nb_decoded_frames >= 20;
830 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
834 if (pktl == s->internal->packet_buffer_end)
835 return s->internal->parse_queue;
839 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
840 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
841 st->codec->codec_id != AV_CODEC_ID_HEVC;
844 int delay = st->codec->has_b_frames;
847 if (dts == AV_NOPTS_VALUE) {
848 int64_t best_score = INT64_MAX;
849 for (i = 0; i<delay; i++) {
850 if (st->pts_reorder_error_count[i]) {
851 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
852 if (score < best_score) {
859 for (i = 0; i<delay; i++) {
860 if (pts_buffer[i] != AV_NOPTS_VALUE) {
861 int64_t diff = FFABS(pts_buffer[i] - dts)
862 + (uint64_t)st->pts_reorder_error[i];
863 diff = FFMAX(diff, st->pts_reorder_error[i]);
864 st->pts_reorder_error[i] = diff;
865 st->pts_reorder_error_count[i]++;
866 if (st->pts_reorder_error_count[i] > 250) {
867 st->pts_reorder_error[i] >>= 1;
868 st->pts_reorder_error_count[i] >>= 1;
875 if (dts == AV_NOPTS_VALUE)
881 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
882 int64_t dts, int64_t pts, AVPacket *pkt)
884 AVStream *st = s->streams[stream_index];
885 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
886 int64_t pts_buffer[MAX_REORDER_DELAY+1];
890 if (st->first_dts != AV_NOPTS_VALUE ||
891 dts == AV_NOPTS_VALUE ||
892 st->cur_dts == AV_NOPTS_VALUE ||
896 delay = st->codec->has_b_frames;
897 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
899 shift = st->first_dts - RELATIVE_TS_BASE;
901 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
902 pts_buffer[i] = AV_NOPTS_VALUE;
904 if (is_relative(pts))
907 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
908 if (pktl->pkt.stream_index != stream_index)
910 if (is_relative(pktl->pkt.pts))
911 pktl->pkt.pts += shift;
913 if (is_relative(pktl->pkt.dts))
914 pktl->pkt.dts += shift;
916 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
917 st->start_time = pktl->pkt.pts;
919 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
920 pts_buffer[0] = pktl->pkt.pts;
921 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
922 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
924 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
928 if (st->start_time == AV_NOPTS_VALUE)
929 st->start_time = pts;
932 static void update_initial_durations(AVFormatContext *s, AVStream *st,
933 int stream_index, int duration)
935 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
936 int64_t cur_dts = RELATIVE_TS_BASE;
938 if (st->first_dts != AV_NOPTS_VALUE) {
939 if (st->update_initial_durations_done)
941 st->update_initial_durations_done = 1;
942 cur_dts = st->first_dts;
943 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
944 if (pktl->pkt.stream_index == stream_index) {
945 if (pktl->pkt.pts != pktl->pkt.dts ||
946 pktl->pkt.dts != AV_NOPTS_VALUE ||
952 if (pktl && pktl->pkt.dts != st->first_dts) {
953 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
954 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
958 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
961 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
962 st->first_dts = cur_dts;
963 } else if (st->cur_dts != RELATIVE_TS_BASE)
966 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
967 if (pktl->pkt.stream_index != stream_index)
969 if (pktl->pkt.pts == pktl->pkt.dts &&
970 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
971 !pktl->pkt.duration) {
972 pktl->pkt.dts = cur_dts;
973 if (!st->codec->has_b_frames)
974 pktl->pkt.pts = cur_dts;
975 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
976 pktl->pkt.duration = duration;
979 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
982 st->cur_dts = cur_dts;
985 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
986 AVCodecParserContext *pc, AVPacket *pkt,
987 int64_t next_dts, int64_t next_pts)
989 int num, den, presentation_delayed, delay, i;
992 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
993 st->codec->codec_id != AV_CODEC_ID_HEVC;
995 if (s->flags & AVFMT_FLAG_NOFILLIN)
998 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
999 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1000 if (st->last_dts_for_order_check <= pkt->dts) {
1003 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1004 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1006 st->last_dts_for_order_check);
1007 st->dts_misordered++;
1009 if (st->dts_ordered + st->dts_misordered > 250) {
1010 st->dts_ordered >>= 1;
1011 st->dts_misordered >>= 1;
1015 st->last_dts_for_order_check = pkt->dts;
1016 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1017 pkt->dts = AV_NOPTS_VALUE;
1020 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1021 pkt->dts = AV_NOPTS_VALUE;
1023 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1024 && !st->codec->has_b_frames)
1025 //FIXME Set low_delay = 0 when has_b_frames = 1
1026 st->codec->has_b_frames = 1;
1028 /* do we have a video B-frame ? */
1029 delay = st->codec->has_b_frames;
1030 presentation_delayed = 0;
1032 /* XXX: need has_b_frame, but cannot get it if the codec is
1033 * not initialized */
1035 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1036 presentation_delayed = 1;
1038 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1039 st->pts_wrap_bits < 63 &&
1040 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1041 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1042 pkt->dts -= 1LL << st->pts_wrap_bits;
1044 pkt->pts += 1LL << st->pts_wrap_bits;
1047 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1048 * We take the conservative approach and discard both.
1049 * Note: If this is misbehaving for an H.264 file, then possibly
1050 * presentation_delayed is not set correctly. */
1051 if (delay == 1 && pkt->dts == pkt->pts &&
1052 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1053 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1054 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1055 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1056 pkt->dts = AV_NOPTS_VALUE;
1059 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1060 if (pkt->duration == 0) {
1061 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1063 duration = (AVRational) {num, den};
1064 pkt->duration = av_rescale_rnd(1,
1065 num * (int64_t) st->time_base.den,
1066 den * (int64_t) st->time_base.num,
1071 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1072 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1074 /* Correct timestamps with byte offset if demuxers only have timestamps
1075 * on packet boundaries */
1076 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1077 /* this will estimate bitrate based on this frame's duration and size */
1078 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1079 if (pkt->pts != AV_NOPTS_VALUE)
1081 if (pkt->dts != AV_NOPTS_VALUE)
1085 /* This may be redundant, but it should not hurt. */
1086 if (pkt->dts != AV_NOPTS_VALUE &&
1087 pkt->pts != AV_NOPTS_VALUE &&
1088 pkt->pts > pkt->dts)
1089 presentation_delayed = 1;
1091 if (s->debug & FF_FDEBUG_TS)
1092 av_log(s, AV_LOG_TRACE,
1093 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1094 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1095 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1097 /* Interpolate PTS and DTS if they are not present. We skip H264
1098 * currently because delay and has_b_frames are not reliably set. */
1099 if ((delay == 0 || (delay == 1 && pc)) &&
1101 if (presentation_delayed) {
1102 /* DTS = decompression timestamp */
1103 /* PTS = presentation timestamp */
1104 if (pkt->dts == AV_NOPTS_VALUE)
1105 pkt->dts = st->last_IP_pts;
1106 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1107 if (pkt->dts == AV_NOPTS_VALUE)
1108 pkt->dts = st->cur_dts;
1110 /* This is tricky: the dts must be incremented by the duration
1111 * of the frame we are displaying, i.e. the last I- or P-frame. */
1112 if (st->last_IP_duration == 0)
1113 st->last_IP_duration = pkt->duration;
1114 if (pkt->dts != AV_NOPTS_VALUE)
1115 st->cur_dts = pkt->dts + st->last_IP_duration;
1116 if (pkt->dts != AV_NOPTS_VALUE &&
1117 pkt->pts == AV_NOPTS_VALUE &&
1118 st->last_IP_duration > 0 &&
1119 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1120 next_dts != next_pts &&
1121 next_pts != AV_NOPTS_VALUE)
1122 pkt->pts = next_dts;
1124 st->last_IP_duration = pkt->duration;
1125 st->last_IP_pts = pkt->pts;
1126 /* Cannot compute PTS if not present (we can compute it only
1127 * by knowing the future. */
1128 } else if (pkt->pts != AV_NOPTS_VALUE ||
1129 pkt->dts != AV_NOPTS_VALUE ||
1132 /* presentation is not delayed : PTS and DTS are the same */
1133 if (pkt->pts == AV_NOPTS_VALUE)
1134 pkt->pts = pkt->dts;
1135 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1137 if (pkt->pts == AV_NOPTS_VALUE)
1138 pkt->pts = st->cur_dts;
1139 pkt->dts = pkt->pts;
1140 if (pkt->pts != AV_NOPTS_VALUE)
1141 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1145 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1146 st->pts_buffer[0] = pkt->pts;
1147 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1148 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1150 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1152 // We skipped it above so we try here.
1154 // This should happen on the first packet
1155 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1156 if (pkt->dts > st->cur_dts)
1157 st->cur_dts = pkt->dts;
1159 if (s->debug & FF_FDEBUG_TS)
1160 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1161 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1164 if (is_intra_only(st->codec))
1165 pkt->flags |= AV_PKT_FLAG_KEY;
1167 pkt->convergence_duration = pc->convergence_duration;
1170 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1173 AVPacketList *pktl = *pkt_buf;
1174 *pkt_buf = pktl->next;
1175 av_free_packet(&pktl->pkt);
1178 *pkt_buf_end = NULL;
1182 * Parse a packet, add all split parts to parse_queue.
1184 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1186 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1188 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1189 AVStream *st = s->streams[stream_index];
1190 uint8_t *data = pkt ? pkt->data : NULL;
1191 int size = pkt ? pkt->size : 0;
1192 int ret = 0, got_output = 0;
1195 av_init_packet(&flush_pkt);
1198 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1199 // preserve 0-size sync packets
1200 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1203 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1205 int64_t next_pts = pkt->pts;
1206 int64_t next_dts = pkt->dts;
1208 av_init_packet(&out_pkt);
1209 len = av_parser_parse2(st->parser, st->codec,
1210 &out_pkt.data, &out_pkt.size, data, size,
1211 pkt->pts, pkt->dts, pkt->pos);
1213 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1215 /* increment read pointer */
1219 got_output = !!out_pkt.size;
1224 if (pkt->side_data) {
1225 out_pkt.side_data = pkt->side_data;
1226 out_pkt.side_data_elems = pkt->side_data_elems;
1227 pkt->side_data = NULL;
1228 pkt->side_data_elems = 0;
1231 /* set the duration */
1232 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1233 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1234 if (st->codec->sample_rate > 0) {
1236 av_rescale_q_rnd(st->parser->duration,
1237 (AVRational) { 1, st->codec->sample_rate },
1243 out_pkt.stream_index = st->index;
1244 out_pkt.pts = st->parser->pts;
1245 out_pkt.dts = st->parser->dts;
1246 out_pkt.pos = st->parser->pos;
1248 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1249 out_pkt.pos = st->parser->frame_offset;
1251 if (st->parser->key_frame == 1 ||
1252 (st->parser->key_frame == -1 &&
1253 st->parser->pict_type == AV_PICTURE_TYPE_I))
1254 out_pkt.flags |= AV_PKT_FLAG_KEY;
1256 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1257 out_pkt.flags |= AV_PKT_FLAG_KEY;
1259 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1261 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1262 out_pkt.buf = pkt->buf;
1264 #if FF_API_DESTRUCT_PACKET
1265 FF_DISABLE_DEPRECATION_WARNINGS
1266 out_pkt.destruct = pkt->destruct;
1267 pkt->destruct = NULL;
1268 FF_ENABLE_DEPRECATION_WARNINGS
1271 if ((ret = av_dup_packet(&out_pkt)) < 0)
1274 if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1275 av_free_packet(&out_pkt);
1276 ret = AVERROR(ENOMEM);
1281 /* end of the stream => close and free the parser */
1282 if (pkt == &flush_pkt) {
1283 av_parser_close(st->parser);
1288 av_free_packet(pkt);
1292 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1293 AVPacketList **pkt_buffer_end,
1297 av_assert0(*pkt_buffer);
1300 *pkt_buffer = pktl->next;
1302 *pkt_buffer_end = NULL;
1307 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1309 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1312 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1314 int ret = 0, i, got_packet = 0;
1315 AVDictionary *metadata = NULL;
1317 av_init_packet(pkt);
1319 while (!got_packet && !s->internal->parse_queue) {
1323 /* read next packet */
1324 ret = ff_read_packet(s, &cur_pkt);
1326 if (ret == AVERROR(EAGAIN))
1328 /* flush the parsers */
1329 for (i = 0; i < s->nb_streams; i++) {
1331 if (st->parser && st->need_parsing)
1332 parse_packet(s, NULL, st->index);
1334 /* all remaining packets are now in parse_queue =>
1335 * really terminate parsing */
1339 st = s->streams[cur_pkt.stream_index];
1341 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1342 cur_pkt.dts != AV_NOPTS_VALUE &&
1343 cur_pkt.pts < cur_pkt.dts) {
1344 av_log(s, AV_LOG_WARNING,
1345 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1346 cur_pkt.stream_index,
1347 av_ts2str(cur_pkt.pts),
1348 av_ts2str(cur_pkt.dts),
1351 if (s->debug & FF_FDEBUG_TS)
1352 av_log(s, AV_LOG_DEBUG,
1353 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1354 cur_pkt.stream_index,
1355 av_ts2str(cur_pkt.pts),
1356 av_ts2str(cur_pkt.dts),
1357 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1359 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1360 st->parser = av_parser_init(st->codec->codec_id);
1362 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1363 "%s, packets or times may be invalid.\n",
1364 avcodec_get_name(st->codec->codec_id));
1365 /* no parser available: just output the raw packets */
1366 st->need_parsing = AVSTREAM_PARSE_NONE;
1367 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1368 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1369 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1370 st->parser->flags |= PARSER_FLAG_ONCE;
1371 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1372 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1375 if (!st->need_parsing || !st->parser) {
1376 /* no parsing needed: we just output the packet as is */
1378 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1379 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1380 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1381 ff_reduce_index(s, st->index);
1382 av_add_index_entry(st, pkt->pos, pkt->dts,
1383 0, 0, AVINDEX_KEYFRAME);
1386 } else if (st->discard < AVDISCARD_ALL) {
1387 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1391 av_free_packet(&cur_pkt);
1393 if (pkt->flags & AV_PKT_FLAG_KEY)
1394 st->skip_to_keyframe = 0;
1395 if (st->skip_to_keyframe) {
1396 av_free_packet(&cur_pkt);
1404 if (!got_packet && s->internal->parse_queue)
1405 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1408 AVStream *st = s->streams[pkt->stream_index];
1409 int discard_padding = 0;
1410 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1411 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1412 int64_t sample = ts_to_samples(st, pts);
1413 int duration = ts_to_samples(st, pkt->duration);
1414 int64_t end_sample = sample + duration;
1415 if (duration > 0 && end_sample >= st->first_discard_sample &&
1416 sample < st->last_discard_sample)
1417 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1419 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1420 st->skip_samples = st->start_skip_samples;
1421 if (st->skip_samples || discard_padding) {
1422 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1424 AV_WL32(p, st->skip_samples);
1425 AV_WL32(p + 4, discard_padding);
1426 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1428 st->skip_samples = 0;
1431 if (st->inject_global_side_data) {
1432 for (i = 0; i < st->nb_side_data; i++) {
1433 AVPacketSideData *src_sd = &st->side_data[i];
1436 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1439 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1441 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1445 memcpy(dst_data, src_sd->data, src_sd->size);
1447 st->inject_global_side_data = 0;
1450 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1451 av_packet_merge_side_data(pkt);
1454 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1456 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1457 av_dict_copy(&s->metadata, metadata, 0);
1458 av_dict_free(&metadata);
1459 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1462 if (s->debug & FF_FDEBUG_TS)
1463 av_log(s, AV_LOG_DEBUG,
1464 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1465 "size=%d, duration=%d, flags=%d\n",
1467 av_ts2str(pkt->pts),
1468 av_ts2str(pkt->dts),
1469 pkt->size, pkt->duration, pkt->flags);
1474 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1476 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1482 ret = s->internal->packet_buffer
1483 ? read_from_packet_buffer(&s->internal->packet_buffer,
1484 &s->internal->packet_buffer_end, pkt)
1485 : read_frame_internal(s, pkt);
1492 AVPacketList *pktl = s->internal->packet_buffer;
1495 AVPacket *next_pkt = &pktl->pkt;
1497 if (next_pkt->dts != AV_NOPTS_VALUE) {
1498 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1499 // last dts seen for this stream. if any of packets following
1500 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1501 int64_t last_dts = next_pkt->dts;
1502 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1503 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1504 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1505 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1507 next_pkt->pts = pktl->pkt.dts;
1509 if (last_dts != AV_NOPTS_VALUE) {
1510 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1511 last_dts = pktl->pkt.dts;
1516 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1517 // Fixing the last reference frame had none pts issue (For MXF etc).
1518 // We only do this when
1520 // 2. we are not able to resolve a pts value for current packet.
1521 // 3. the packets for this stream at the end of the files had valid dts.
1522 next_pkt->pts = last_dts + next_pkt->duration;
1524 pktl = s->internal->packet_buffer;
1527 /* read packet from packet buffer, if there is data */
1528 st = s->streams[next_pkt->stream_index];
1529 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1530 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1531 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1532 &s->internal->packet_buffer_end, pkt);
1537 ret = read_frame_internal(s, pkt);
1539 if (pktl && ret != AVERROR(EAGAIN)) {
1546 if (av_dup_packet(add_to_pktbuf(&s->internal->packet_buffer, pkt,
1547 &s->internal->packet_buffer_end)) < 0)
1548 return AVERROR(ENOMEM);
1553 st = s->streams[pkt->stream_index];
1554 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1555 ff_reduce_index(s, st->index);
1556 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1559 if (is_relative(pkt->dts))
1560 pkt->dts -= RELATIVE_TS_BASE;
1561 if (is_relative(pkt->pts))
1562 pkt->pts -= RELATIVE_TS_BASE;
1567 /* XXX: suppress the packet queue */
1568 static void flush_packet_queue(AVFormatContext *s)
1572 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1573 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1574 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1576 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1579 /*******************************************************/
1582 int av_find_default_stream_index(AVFormatContext *s)
1586 int best_stream = 0;
1587 int best_score = -1;
1589 if (s->nb_streams <= 0)
1591 for (i = 0; i < s->nb_streams; i++) {
1594 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1595 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1596 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1601 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1602 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1608 if (st->discard != AVDISCARD_ALL)
1611 if (score > best_score) {
1619 /** Flush the frame reader. */
1620 void ff_read_frame_flush(AVFormatContext *s)
1625 flush_packet_queue(s);
1627 /* Reset read state for each stream. */
1628 for (i = 0; i < s->nb_streams; i++) {
1632 av_parser_close(st->parser);
1635 st->last_IP_pts = AV_NOPTS_VALUE;
1636 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1637 if (st->first_dts == AV_NOPTS_VALUE)
1638 st->cur_dts = RELATIVE_TS_BASE;
1640 /* We set the current DTS to an unspecified origin. */
1641 st->cur_dts = AV_NOPTS_VALUE;
1643 st->probe_packets = MAX_PROBE_PACKETS;
1645 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1646 st->pts_buffer[j] = AV_NOPTS_VALUE;
1648 if (s->internal->inject_global_side_data)
1649 st->inject_global_side_data = 1;
1651 st->skip_samples = 0;
1655 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1659 for (i = 0; i < s->nb_streams; i++) {
1660 AVStream *st = s->streams[i];
1663 av_rescale(timestamp,
1664 st->time_base.den * (int64_t) ref_st->time_base.num,
1665 st->time_base.num * (int64_t) ref_st->time_base.den);
1669 void ff_reduce_index(AVFormatContext *s, int stream_index)
1671 AVStream *st = s->streams[stream_index];
1672 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1674 if ((unsigned) st->nb_index_entries >= max_entries) {
1676 for (i = 0; 2 * i < st->nb_index_entries; i++)
1677 st->index_entries[i] = st->index_entries[2 * i];
1678 st->nb_index_entries = i;
1682 int ff_add_index_entry(AVIndexEntry **index_entries,
1683 int *nb_index_entries,
1684 unsigned int *index_entries_allocated_size,
1685 int64_t pos, int64_t timestamp,
1686 int size, int distance, int flags)
1688 AVIndexEntry *entries, *ie;
1691 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1694 if (timestamp == AV_NOPTS_VALUE)
1695 return AVERROR(EINVAL);
1697 if (size < 0 || size > 0x3FFFFFFF)
1698 return AVERROR(EINVAL);
1700 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1701 timestamp -= RELATIVE_TS_BASE;
1703 entries = av_fast_realloc(*index_entries,
1704 index_entries_allocated_size,
1705 (*nb_index_entries + 1) *
1706 sizeof(AVIndexEntry));
1710 *index_entries = entries;
1712 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1713 timestamp, AVSEEK_FLAG_ANY);
1716 index = (*nb_index_entries)++;
1717 ie = &entries[index];
1718 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1720 ie = &entries[index];
1721 if (ie->timestamp != timestamp) {
1722 if (ie->timestamp <= timestamp)
1724 memmove(entries + index + 1, entries + index,
1725 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1726 (*nb_index_entries)++;
1727 } else if (ie->pos == pos && distance < ie->min_distance)
1728 // do not reduce the distance
1729 distance = ie->min_distance;
1733 ie->timestamp = timestamp;
1734 ie->min_distance = distance;
1741 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1742 int size, int distance, int flags)
1744 timestamp = wrap_timestamp(st, timestamp);
1745 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1746 &st->index_entries_allocated_size, pos,
1747 timestamp, size, distance, flags);
1750 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1751 int64_t wanted_timestamp, int flags)
1759 // Optimize appending index entries at the end.
1760 if (b && entries[b - 1].timestamp < wanted_timestamp)
1765 timestamp = entries[m].timestamp;
1766 if (timestamp >= wanted_timestamp)
1768 if (timestamp <= wanted_timestamp)
1771 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1773 if (!(flags & AVSEEK_FLAG_ANY))
1774 while (m >= 0 && m < nb_entries &&
1775 !(entries[m].flags & AVINDEX_KEYFRAME))
1776 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1778 if (m == nb_entries)
1783 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1785 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1786 wanted_timestamp, flags);
1789 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1790 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1792 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1793 if (stream_index >= 0)
1794 ts = wrap_timestamp(s->streams[stream_index], ts);
1798 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1799 int64_t target_ts, int flags)
1801 AVInputFormat *avif = s->iformat;
1802 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1803 int64_t ts_min, ts_max, ts;
1808 if (stream_index < 0)
1811 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1814 ts_min = AV_NOPTS_VALUE;
1815 pos_limit = -1; // GCC falsely says it may be uninitialized.
1817 st = s->streams[stream_index];
1818 if (st->index_entries) {
1821 /* FIXME: Whole function must be checked for non-keyframe entries in
1822 * index case, especially read_timestamp(). */
1823 index = av_index_search_timestamp(st, target_ts,
1824 flags | AVSEEK_FLAG_BACKWARD);
1825 index = FFMAX(index, 0);
1826 e = &st->index_entries[index];
1828 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1830 ts_min = e->timestamp;
1831 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1832 pos_min, av_ts2str(ts_min));
1834 av_assert1(index == 0);
1837 index = av_index_search_timestamp(st, target_ts,
1838 flags & ~AVSEEK_FLAG_BACKWARD);
1839 av_assert0(index < st->nb_index_entries);
1841 e = &st->index_entries[index];
1842 av_assert1(e->timestamp >= target_ts);
1844 ts_max = e->timestamp;
1845 pos_limit = pos_max - e->min_distance;
1846 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1847 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1851 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1852 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1857 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1860 ff_read_frame_flush(s);
1861 ff_update_cur_dts(s, st, ts);
1866 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1867 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1869 int64_t step = 1024;
1870 int64_t limit, ts_max;
1871 int64_t filesize = avio_size(s->pb);
1872 int64_t pos_max = filesize - 1;
1875 pos_max = FFMAX(0, (pos_max) - step);
1876 ts_max = ff_read_timestamp(s, stream_index,
1877 &pos_max, limit, read_timestamp);
1879 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1880 if (ts_max == AV_NOPTS_VALUE)
1884 int64_t tmp_pos = pos_max + 1;
1885 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1886 &tmp_pos, INT64_MAX, read_timestamp);
1887 if (tmp_ts == AV_NOPTS_VALUE)
1889 av_assert0(tmp_pos > pos_max);
1892 if (tmp_pos >= filesize)
1904 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1905 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1906 int64_t ts_min, int64_t ts_max,
1907 int flags, int64_t *ts_ret,
1908 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1909 int64_t *, int64_t))
1916 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1918 if (ts_min == AV_NOPTS_VALUE) {
1919 pos_min = s->internal->data_offset;
1920 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1921 if (ts_min == AV_NOPTS_VALUE)
1925 if (ts_min >= target_ts) {
1930 if (ts_max == AV_NOPTS_VALUE) {
1931 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1933 pos_limit = pos_max;
1936 if (ts_max <= target_ts) {
1941 av_assert0(ts_min < ts_max);
1944 while (pos_min < pos_limit) {
1945 av_log(s, AV_LOG_TRACE,
1946 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1947 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1948 av_assert0(pos_limit <= pos_max);
1950 if (no_change == 0) {
1951 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1952 // interpolate position (better than dichotomy)
1953 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1955 pos_min - approximate_keyframe_distance;
1956 } else if (no_change == 1) {
1957 // bisection if interpolation did not change min / max pos last time
1958 pos = (pos_min + pos_limit) >> 1;
1960 /* linear search if bisection failed, can only happen if there
1961 * are very few or no keyframes between min/max */
1966 else if (pos > pos_limit)
1970 // May pass pos_limit instead of -1.
1971 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1976 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1977 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1978 pos_min, pos, pos_max,
1979 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1980 pos_limit, start_pos, no_change);
1981 if (ts == AV_NOPTS_VALUE) {
1982 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1985 if (target_ts <= ts) {
1986 pos_limit = start_pos - 1;
1990 if (target_ts >= ts) {
1996 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1997 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2000 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2002 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2003 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2004 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2010 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2011 int64_t pos, int flags)
2013 int64_t pos_min, pos_max;
2015 pos_min = s->internal->data_offset;
2016 pos_max = avio_size(s->pb) - 1;
2020 else if (pos > pos_max)
2023 avio_seek(s->pb, pos, SEEK_SET);
2025 s->io_repositioned = 1;
2030 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2031 int64_t timestamp, int flags)
2038 st = s->streams[stream_index];
2040 index = av_index_search_timestamp(st, timestamp, flags);
2042 if (index < 0 && st->nb_index_entries &&
2043 timestamp < st->index_entries[0].timestamp)
2046 if (index < 0 || index == st->nb_index_entries - 1) {
2050 if (st->nb_index_entries) {
2051 av_assert0(st->index_entries);
2052 ie = &st->index_entries[st->nb_index_entries - 1];
2053 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2055 ff_update_cur_dts(s, st, ie->timestamp);
2057 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2063 read_status = av_read_frame(s, &pkt);
2064 } while (read_status == AVERROR(EAGAIN));
2065 if (read_status < 0)
2067 av_free_packet(&pkt);
2068 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2069 if (pkt.flags & AV_PKT_FLAG_KEY)
2071 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2072 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);
2077 index = av_index_search_timestamp(st, timestamp, flags);
2082 ff_read_frame_flush(s);
2083 if (s->iformat->read_seek)
2084 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2086 ie = &st->index_entries[index];
2087 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2089 ff_update_cur_dts(s, st, ie->timestamp);
2094 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2095 int64_t timestamp, int flags)
2100 if (flags & AVSEEK_FLAG_BYTE) {
2101 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2103 ff_read_frame_flush(s);
2104 return seek_frame_byte(s, stream_index, timestamp, flags);
2107 if (stream_index < 0) {
2108 stream_index = av_find_default_stream_index(s);
2109 if (stream_index < 0)
2112 st = s->streams[stream_index];
2113 /* timestamp for default must be expressed in AV_TIME_BASE units */
2114 timestamp = av_rescale(timestamp, st->time_base.den,
2115 AV_TIME_BASE * (int64_t) st->time_base.num);
2118 /* first, we try the format specific seek */
2119 if (s->iformat->read_seek) {
2120 ff_read_frame_flush(s);
2121 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2127 if (s->iformat->read_timestamp &&
2128 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2129 ff_read_frame_flush(s);
2130 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2131 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2132 ff_read_frame_flush(s);
2133 return seek_frame_generic(s, stream_index, timestamp, flags);
2138 int av_seek_frame(AVFormatContext *s, int stream_index,
2139 int64_t timestamp, int flags)
2143 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2144 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2145 if ((flags & AVSEEK_FLAG_BACKWARD))
2149 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2150 flags & ~AVSEEK_FLAG_BACKWARD);
2153 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2156 ret = avformat_queue_attached_pictures(s);
2161 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2162 int64_t ts, int64_t max_ts, int flags)
2164 if (min_ts > ts || max_ts < ts)
2166 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2167 return AVERROR(EINVAL);
2170 flags |= AVSEEK_FLAG_ANY;
2171 flags &= ~AVSEEK_FLAG_BACKWARD;
2173 if (s->iformat->read_seek2) {
2175 ff_read_frame_flush(s);
2177 if (stream_index == -1 && s->nb_streams == 1) {
2178 AVRational time_base = s->streams[0]->time_base;
2179 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2180 min_ts = av_rescale_rnd(min_ts, time_base.den,
2181 time_base.num * (int64_t)AV_TIME_BASE,
2182 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2183 max_ts = av_rescale_rnd(max_ts, time_base.den,
2184 time_base.num * (int64_t)AV_TIME_BASE,
2185 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2188 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2192 ret = avformat_queue_attached_pictures(s);
2196 if (s->iformat->read_timestamp) {
2197 // try to seek via read_timestamp()
2200 // Fall back on old API if new is not implemented but old is.
2201 // Note the old API has somewhat different semantics.
2202 if (s->iformat->read_seek || 1) {
2203 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2204 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2205 if (ret<0 && ts != min_ts && max_ts != ts) {
2206 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2208 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2213 // try some generic seek like seek_frame_generic() but with new ts semantics
2214 return -1; //unreachable
2217 int avformat_flush(AVFormatContext *s)
2219 ff_read_frame_flush(s);
2223 /*******************************************************/
2226 * Return TRUE if the stream has accurate duration in any stream.
2228 * @return TRUE if the stream has accurate duration for at least one component.
2230 static int has_duration(AVFormatContext *ic)
2235 for (i = 0; i < ic->nb_streams; i++) {
2236 st = ic->streams[i];
2237 if (st->duration != AV_NOPTS_VALUE)
2240 if (ic->duration != AV_NOPTS_VALUE)
2246 * Estimate the stream timings from the one of each components.
2248 * Also computes the global bitrate if possible.
2250 static void update_stream_timings(AVFormatContext *ic)
2252 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2253 int64_t duration, duration1, filesize;
2258 start_time = INT64_MAX;
2259 start_time_text = INT64_MAX;
2260 end_time = INT64_MIN;
2261 duration = INT64_MIN;
2262 for (i = 0; i < ic->nb_streams; i++) {
2263 st = ic->streams[i];
2264 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2265 start_time1 = av_rescale_q(st->start_time, st->time_base,
2267 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2268 if (start_time1 < start_time_text)
2269 start_time_text = start_time1;
2271 start_time = FFMIN(start_time, start_time1);
2272 end_time1 = AV_NOPTS_VALUE;
2273 if (st->duration != AV_NOPTS_VALUE) {
2274 end_time1 = start_time1 +
2275 av_rescale_q(st->duration, st->time_base,
2277 end_time = FFMAX(end_time, end_time1);
2279 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2280 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2281 p->start_time = start_time1;
2282 if (p->end_time < end_time1)
2283 p->end_time = end_time1;
2286 if (st->duration != AV_NOPTS_VALUE) {
2287 duration1 = av_rescale_q(st->duration, st->time_base,
2289 duration = FFMAX(duration, duration1);
2292 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2293 start_time = start_time_text;
2294 else if (start_time > start_time_text)
2295 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2297 if (start_time != INT64_MAX) {
2298 ic->start_time = start_time;
2299 if (end_time != INT64_MIN) {
2300 if (ic->nb_programs) {
2301 for (i = 0; i < ic->nb_programs; i++) {
2302 p = ic->programs[i];
2303 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2304 duration = FFMAX(duration, p->end_time - p->start_time);
2307 duration = FFMAX(duration, end_time - start_time);
2310 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2311 ic->duration = duration;
2313 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2314 /* compute the bitrate */
2315 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2316 (double) ic->duration;
2317 if (bitrate >= 0 && bitrate <= INT_MAX)
2318 ic->bit_rate = bitrate;
2322 static void fill_all_stream_timings(AVFormatContext *ic)
2327 update_stream_timings(ic);
2328 for (i = 0; i < ic->nb_streams; i++) {
2329 st = ic->streams[i];
2330 if (st->start_time == AV_NOPTS_VALUE) {
2331 if (ic->start_time != AV_NOPTS_VALUE)
2332 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2334 if (ic->duration != AV_NOPTS_VALUE)
2335 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2341 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2343 int64_t filesize, duration;
2344 int i, show_warning = 0;
2347 /* if bit_rate is already set, we believe it */
2348 if (ic->bit_rate <= 0) {
2350 for (i = 0; i < ic->nb_streams; i++) {
2351 st = ic->streams[i];
2352 if (st->codec->bit_rate > 0) {
2353 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2357 bit_rate += st->codec->bit_rate;
2358 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2359 // If we have a videostream with packets but without a bitrate
2360 // then consider the sum not known
2365 ic->bit_rate = bit_rate;
2368 /* if duration is already set, we believe it */
2369 if (ic->duration == AV_NOPTS_VALUE &&
2370 ic->bit_rate != 0) {
2371 filesize = ic->pb ? avio_size(ic->pb) : 0;
2372 if (filesize > ic->internal->data_offset) {
2373 filesize -= ic->internal->data_offset;
2374 for (i = 0; i < ic->nb_streams; i++) {
2375 st = ic->streams[i];
2376 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2377 && st->duration == AV_NOPTS_VALUE) {
2378 duration = av_rescale(8 * filesize, st->time_base.den,
2380 (int64_t) st->time_base.num);
2381 st->duration = duration;
2388 av_log(ic, AV_LOG_WARNING,
2389 "Estimating duration from bitrate, this may be inaccurate\n");
2392 #define DURATION_MAX_READ_SIZE 250000LL
2393 #define DURATION_MAX_RETRY 4
2395 /* only usable for MPEG-PS streams */
2396 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2398 AVPacket pkt1, *pkt = &pkt1;
2400 int num, den, read_size, i, ret;
2401 int found_duration = 0;
2403 int64_t filesize, offset, duration;
2406 /* flush packet queue */
2407 flush_packet_queue(ic);
2409 for (i = 0; i < ic->nb_streams; i++) {
2410 st = ic->streams[i];
2411 if (st->start_time == AV_NOPTS_VALUE &&
2412 st->first_dts == AV_NOPTS_VALUE &&
2413 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2414 av_log(st->codec, AV_LOG_WARNING,
2415 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2418 av_parser_close(st->parser);
2423 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2424 /* estimate the end time (duration) */
2425 /* XXX: may need to support wrapping */
2426 filesize = ic->pb ? avio_size(ic->pb) : 0;
2428 is_end = found_duration;
2429 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2433 avio_seek(ic->pb, offset, SEEK_SET);
2436 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2440 ret = ff_read_packet(ic, pkt);
2441 } while (ret == AVERROR(EAGAIN));
2444 read_size += pkt->size;
2445 st = ic->streams[pkt->stream_index];
2446 if (pkt->pts != AV_NOPTS_VALUE &&
2447 (st->start_time != AV_NOPTS_VALUE ||
2448 st->first_dts != AV_NOPTS_VALUE)) {
2449 if (pkt->duration == 0) {
2450 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2452 pkt->duration = av_rescale_rnd(1,
2453 num * (int64_t) st->time_base.den,
2454 den * (int64_t) st->time_base.num,
2458 duration = pkt->pts + pkt->duration;
2460 if (st->start_time != AV_NOPTS_VALUE)
2461 duration -= st->start_time;
2463 duration -= st->first_dts;
2465 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2466 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2467 st->duration = duration;
2468 st->info->last_duration = duration;
2471 av_free_packet(pkt);
2474 /* check if all audio/video streams have valid duration */
2477 for (i = 0; i < ic->nb_streams; i++) {
2478 st = ic->streams[i];
2479 switch (st->codec->codec_type) {
2480 case AVMEDIA_TYPE_VIDEO:
2481 case AVMEDIA_TYPE_AUDIO:
2482 if (st->duration == AV_NOPTS_VALUE)
2489 ++retry <= DURATION_MAX_RETRY);
2491 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2493 /* warn about audio/video streams which duration could not be estimated */
2494 for (i = 0; i < ic->nb_streams; i++) {
2495 st = ic->streams[i];
2496 if (st->duration == AV_NOPTS_VALUE) {
2497 switch (st->codec->codec_type) {
2498 case AVMEDIA_TYPE_VIDEO:
2499 case AVMEDIA_TYPE_AUDIO:
2500 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2501 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2503 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2507 fill_all_stream_timings(ic);
2509 avio_seek(ic->pb, old_offset, SEEK_SET);
2510 for (i = 0; i < ic->nb_streams; i++) {
2513 st = ic->streams[i];
2514 st->cur_dts = st->first_dts;
2515 st->last_IP_pts = AV_NOPTS_VALUE;
2516 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2517 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2518 st->pts_buffer[j] = AV_NOPTS_VALUE;
2522 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2526 /* get the file size, if possible */
2527 if (ic->iformat->flags & AVFMT_NOFILE) {
2530 file_size = avio_size(ic->pb);
2531 file_size = FFMAX(0, file_size);
2534 if ((!strcmp(ic->iformat->name, "mpeg") ||
2535 !strcmp(ic->iformat->name, "mpegts")) &&
2536 file_size && ic->pb->seekable) {
2537 /* get accurate estimate from the PTSes */
2538 estimate_timings_from_pts(ic, old_offset);
2539 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2540 } else if (has_duration(ic)) {
2541 /* at least one component has timings - we use them for all
2543 fill_all_stream_timings(ic);
2544 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2546 /* less precise: use bitrate info */
2547 estimate_timings_from_bit_rate(ic);
2548 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2550 update_stream_timings(ic);
2554 AVStream av_unused *st;
2555 for (i = 0; i < ic->nb_streams; i++) {
2556 st = ic->streams[i];
2557 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2558 (double) st->start_time / AV_TIME_BASE,
2559 (double) st->duration / AV_TIME_BASE);
2561 av_log(ic, AV_LOG_TRACE,
2562 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2563 (double) ic->start_time / AV_TIME_BASE,
2564 (double) ic->duration / AV_TIME_BASE,
2565 ic->bit_rate / 1000);
2569 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2571 AVCodecContext *avctx = st->codec;
2573 #define FAIL(errmsg) do { \
2575 *errmsg_ptr = errmsg; \
2579 if ( avctx->codec_id == AV_CODEC_ID_NONE
2580 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2581 FAIL("unknown codec");
2582 switch (avctx->codec_type) {
2583 case AVMEDIA_TYPE_AUDIO:
2584 if (!avctx->frame_size && determinable_frame_size(avctx))
2585 FAIL("unspecified frame size");
2586 if (st->info->found_decoder >= 0 &&
2587 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2588 FAIL("unspecified sample format");
2589 if (!avctx->sample_rate)
2590 FAIL("unspecified sample rate");
2591 if (!avctx->channels)
2592 FAIL("unspecified number of channels");
2593 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2594 FAIL("no decodable DTS frames");
2596 case AVMEDIA_TYPE_VIDEO:
2598 FAIL("unspecified size");
2599 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2600 FAIL("unspecified pixel format");
2601 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2602 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2603 FAIL("no frame in rv30/40 and no sar");
2605 case AVMEDIA_TYPE_SUBTITLE:
2606 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2607 FAIL("unspecified size");
2609 case AVMEDIA_TYPE_DATA:
2610 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2616 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2617 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2618 AVDictionary **options)
2620 const AVCodec *codec;
2621 int got_picture = 1, ret = 0;
2622 AVFrame *frame = av_frame_alloc();
2623 AVSubtitle subtitle;
2624 AVPacket pkt = *avpkt;
2627 return AVERROR(ENOMEM);
2629 if (!avcodec_is_open(st->codec) &&
2630 st->info->found_decoder <= 0 &&
2631 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2632 AVDictionary *thread_opt = NULL;
2634 codec = find_decoder(s, st, st->codec->codec_id);
2637 st->info->found_decoder = -st->codec->codec_id;
2642 /* Force thread count to 1 since the H.264 decoder will not extract
2643 * SPS and PPS to extradata during multi-threaded decoding. */
2644 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2645 if (s->codec_whitelist)
2646 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2647 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2649 av_dict_free(&thread_opt);
2651 st->info->found_decoder = -st->codec->codec_id;
2654 st->info->found_decoder = 1;
2655 } else if (!st->info->found_decoder)
2656 st->info->found_decoder = 1;
2658 if (st->info->found_decoder < 0) {
2663 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2665 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2666 (!st->codec_info_nb_frames &&
2667 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2669 switch (st->codec->codec_type) {
2670 case AVMEDIA_TYPE_VIDEO:
2671 ret = avcodec_decode_video2(st->codec, frame,
2672 &got_picture, &pkt);
2674 case AVMEDIA_TYPE_AUDIO:
2675 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2677 case AVMEDIA_TYPE_SUBTITLE:
2678 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2679 &got_picture, &pkt);
2687 st->nb_decoded_frames++;
2694 if (!pkt.data && !got_picture)
2698 av_frame_free(&frame);
2702 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2704 while (tags->id != AV_CODEC_ID_NONE) {
2712 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2715 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2716 if (tag == tags[i].tag)
2718 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2719 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2721 return AV_CODEC_ID_NONE;
2724 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2729 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2731 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2733 return AV_CODEC_ID_NONE;
2738 if (sflags & (1 << (bps - 1))) {
2741 return AV_CODEC_ID_PCM_S8;
2743 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2745 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2747 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2749 return AV_CODEC_ID_NONE;
2754 return AV_CODEC_ID_PCM_U8;
2756 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2758 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2760 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2762 return AV_CODEC_ID_NONE;
2768 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2771 if (!av_codec_get_tag2(tags, id, &tag))
2776 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2780 for (i = 0; tags && tags[i]; i++) {
2781 const AVCodecTag *codec_tags = tags[i];
2782 while (codec_tags->id != AV_CODEC_ID_NONE) {
2783 if (codec_tags->id == id) {
2784 *tag = codec_tags->tag;
2793 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2796 for (i = 0; tags && tags[i]; i++) {
2797 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2798 if (id != AV_CODEC_ID_NONE)
2801 return AV_CODEC_ID_NONE;
2804 static void compute_chapters_end(AVFormatContext *s)
2807 int64_t max_time = s->duration +
2808 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2810 for (i = 0; i < s->nb_chapters; i++)
2811 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2812 AVChapter *ch = s->chapters[i];
2813 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2817 for (j = 0; j < s->nb_chapters; j++) {
2818 AVChapter *ch1 = s->chapters[j];
2819 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2821 if (j != i && next_start > ch->start && next_start < end)
2824 ch->end = (end == INT64_MAX) ? ch->start : end;
2828 static int get_std_framerate(int i)
2831 return (i + 1) * 1001;
2835 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2839 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2842 /* Is the time base unreliable?
2843 * This is a heuristic to balance between quick acceptance of the values in
2844 * the headers vs. some extra checks.
2845 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2846 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2847 * And there are "variable" fps files this needs to detect as well. */
2848 static int tb_unreliable(AVCodecContext *c)
2850 if (c->time_base.den >= 101LL * c->time_base.num ||
2851 c->time_base.den < 5LL * c->time_base.num ||
2852 // c->codec_tag == AV_RL32("DIVX") ||
2853 // c->codec_tag == AV_RL32("XVID") ||
2854 c->codec_tag == AV_RL32("mp4v") ||
2855 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2856 c->codec_id == AV_CODEC_ID_GIF ||
2857 c->codec_id == AV_CODEC_ID_HEVC ||
2858 c->codec_id == AV_CODEC_ID_H264)
2863 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2867 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2868 avctx->extradata = NULL;
2869 avctx->extradata_size = 0;
2870 return AVERROR(EINVAL);
2872 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2873 if (avctx->extradata) {
2874 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2875 avctx->extradata_size = size;
2878 avctx->extradata_size = 0;
2879 ret = AVERROR(ENOMEM);
2884 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2886 int ret = ff_alloc_extradata(avctx, size);
2889 ret = avio_read(pb, avctx->extradata, size);
2891 av_freep(&avctx->extradata);
2892 avctx->extradata_size = 0;
2893 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2894 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2900 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2903 int64_t last = st->info->last_dts;
2905 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2906 && ts - (uint64_t)last < INT64_MAX) {
2907 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2908 int64_t duration = ts - last;
2910 if (!st->info->duration_error)
2911 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2912 if (!st->info->duration_error)
2913 return AVERROR(ENOMEM);
2915 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2916 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2917 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2918 if (st->info->duration_error[0][1][i] < 1e10) {
2919 int framerate = get_std_framerate(i);
2920 double sdts = dts*framerate/(1001*12);
2921 for (j= 0; j<2; j++) {
2922 int64_t ticks = llrint(sdts+j*0.5);
2923 double error= sdts - ticks + j*0.5;
2924 st->info->duration_error[j][0][i] += error;
2925 st->info->duration_error[j][1][i] += error*error;
2929 st->info->duration_count++;
2930 st->info->rfps_duration_sum += duration;
2932 if (st->info->duration_count % 10 == 0) {
2933 int n = st->info->duration_count;
2934 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2935 if (st->info->duration_error[0][1][i] < 1e10) {
2936 double a0 = st->info->duration_error[0][0][i] / n;
2937 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2938 double a1 = st->info->duration_error[1][0][i] / n;
2939 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2940 if (error0 > 0.04 && error1 > 0.04) {
2941 st->info->duration_error[0][1][i] = 2e10;
2942 st->info->duration_error[1][1][i] = 2e10;
2948 // ignore the first 4 values, they might have some random jitter
2949 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2950 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2952 if (ts != AV_NOPTS_VALUE)
2953 st->info->last_dts = ts;
2958 void ff_rfps_calculate(AVFormatContext *ic)
2962 for (i = 0; i < ic->nb_streams; i++) {
2963 AVStream *st = ic->streams[i];
2965 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2967 // the check for tb_unreliable() is not completely correct, since this is not about handling
2968 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2969 // ipmovie.c produces.
2970 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)
2971 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);
2972 if (st->info->duration_count>1 && !st->r_frame_rate.num
2973 && tb_unreliable(st->codec)) {
2975 double best_error= 0.01;
2976 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2978 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2981 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2983 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2986 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2989 for (k= 0; k<2; k++) {
2990 int n = st->info->duration_count;
2991 double a= st->info->duration_error[k][0][j] / n;
2992 double error= st->info->duration_error[k][1][j]/n - a*a;
2994 if (error < best_error && best_error> 0.000000001) {
2996 num = get_std_framerate(j);
2999 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3002 // do not increase frame rate by more than 1 % in order to match a standard rate.
3003 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3004 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3006 if ( !st->avg_frame_rate.num
3007 && st->r_frame_rate.num && st->info->rfps_duration_sum
3008 && st->info->codec_info_duration <= 0
3009 && st->info->duration_count > 2
3010 && 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
3012 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3013 st->avg_frame_rate = st->r_frame_rate;
3016 av_freep(&st->info->duration_error);
3017 st->info->last_dts = AV_NOPTS_VALUE;
3018 st->info->duration_count = 0;
3019 st->info->rfps_duration_sum = 0;
3023 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3025 int i, count, ret = 0, j;
3028 AVPacket pkt1, *pkt;
3029 int64_t old_offset = avio_tell(ic->pb);
3030 // new streams might appear, no options for those
3031 int orig_nb_streams = ic->nb_streams;
3033 int64_t max_analyze_duration = ic->max_analyze_duration2;
3034 int64_t max_stream_analyze_duration;
3035 int64_t probesize = ic->probesize2;
3037 if (!max_analyze_duration)
3038 max_analyze_duration = ic->max_analyze_duration;
3040 probesize = ic->probesize;
3041 flush_codecs = probesize > 0;
3043 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3045 max_stream_analyze_duration = max_analyze_duration;
3046 if (!max_analyze_duration) {
3047 max_stream_analyze_duration =
3048 max_analyze_duration = 5*AV_TIME_BASE;
3049 if (!strcmp(ic->iformat->name, "flv"))
3050 max_stream_analyze_duration = 30*AV_TIME_BASE;
3054 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3055 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3057 for (i = 0; i < ic->nb_streams; i++) {
3058 const AVCodec *codec;
3059 AVDictionary *thread_opt = NULL;
3060 st = ic->streams[i];
3062 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3063 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3064 /* if (!st->time_base.num)
3066 if (!st->codec->time_base.num)
3067 st->codec->time_base = st->time_base;
3069 // only for the split stuff
3070 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3071 st->parser = av_parser_init(st->codec->codec_id);
3073 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3074 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3075 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3076 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3078 } else if (st->need_parsing) {
3079 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3080 "%s, packets or times may be invalid.\n",
3081 avcodec_get_name(st->codec->codec_id));
3084 codec = find_decoder(ic, st, st->codec->codec_id);
3086 /* Force thread count to 1 since the H.264 decoder will not extract
3087 * SPS and PPS to extradata during multi-threaded decoding. */
3088 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3090 if (ic->codec_whitelist)
3091 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3093 /* Ensure that subtitle_header is properly set. */
3094 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3095 && codec && !st->codec->codec) {
3096 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3097 av_log(ic, AV_LOG_WARNING,
3098 "Failed to open codec in av_find_stream_info\n");
3101 // Try to just open decoders, in case this is enough to get parameters.
3102 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3103 if (codec && !st->codec->codec)
3104 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3105 av_log(ic, AV_LOG_WARNING,
3106 "Failed to open codec in av_find_stream_info\n");
3109 av_dict_free(&thread_opt);
3112 for (i = 0; i < ic->nb_streams; i++) {
3113 #if FF_API_R_FRAME_RATE
3114 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3116 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3117 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3123 int analyzed_all_streams;
3124 if (ff_check_interrupt(&ic->interrupt_callback)) {
3126 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3130 /* check if one codec still needs to be handled */
3131 for (i = 0; i < ic->nb_streams; i++) {
3132 int fps_analyze_framecount = 20;
3134 st = ic->streams[i];
3135 if (!has_codec_parameters(st, NULL))
3137 /* If the timebase is coarse (like the usual millisecond precision
3138 * of mkv), we need to analyze more frames to reliably arrive at
3139 * the correct fps. */
3140 if (av_q2d(st->time_base) > 0.0005)
3141 fps_analyze_framecount *= 2;
3142 if (!tb_unreliable(st->codec))
3143 fps_analyze_framecount = 0;
3144 if (ic->fps_probe_size >= 0)
3145 fps_analyze_framecount = ic->fps_probe_size;
3146 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3147 fps_analyze_framecount = 0;
3148 /* variable fps and no guess at the real fps */
3149 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3150 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3151 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3152 st->info->codec_info_duration_fields/2 :
3153 st->info->duration_count;
3154 if (count < fps_analyze_framecount)
3157 if (st->parser && st->parser->parser->split &&
3158 !st->codec->extradata)
3160 if (st->first_dts == AV_NOPTS_VALUE &&
3161 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3162 st->codec_info_nb_frames < ic->max_ts_probe &&
3163 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3164 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3167 analyzed_all_streams = 0;
3168 if (i == ic->nb_streams) {
3169 analyzed_all_streams = 1;
3170 /* NOTE: If the format has no header, then we need to read some
3171 * packets to get most of the streams, so we cannot stop here. */
3172 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3173 /* If we found the info for all the codecs, we can stop. */
3175 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3180 /* We did not get all the codec info, but we read too much data. */
3181 if (read_size >= probesize) {
3183 av_log(ic, AV_LOG_DEBUG,
3184 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3185 for (i = 0; i < ic->nb_streams; i++)
3186 if (!ic->streams[i]->r_frame_rate.num &&
3187 ic->streams[i]->info->duration_count <= 1 &&
3188 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3189 strcmp(ic->iformat->name, "image2"))
3190 av_log(ic, AV_LOG_WARNING,
3191 "Stream #%d: not enough frames to estimate rate; "
3192 "consider increasing probesize\n", i);
3196 /* NOTE: A new stream can be added there if no header in file
3197 * (AVFMTCTX_NOHEADER). */
3198 ret = read_frame_internal(ic, &pkt1);
3199 if (ret == AVERROR(EAGAIN))
3207 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3208 free_packet_buffer(&ic->internal->packet_buffer,
3209 &ic->internal->packet_buffer_end);
3211 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3212 &ic->internal->packet_buffer_end);
3214 ret = AVERROR(ENOMEM);
3215 goto find_stream_info_err;
3217 if ((ret = av_dup_packet(pkt)) < 0)
3218 goto find_stream_info_err;
3221 st = ic->streams[pkt->stream_index];
3222 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3223 read_size += pkt->size;
3225 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3226 /* check for non-increasing dts */
3227 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3228 st->info->fps_last_dts >= pkt->dts) {
3229 av_log(ic, AV_LOG_DEBUG,
3230 "Non-increasing DTS in stream %d: packet %d with DTS "
3231 "%"PRId64", packet %d with DTS %"PRId64"\n",
3232 st->index, st->info->fps_last_dts_idx,
3233 st->info->fps_last_dts, st->codec_info_nb_frames,
3235 st->info->fps_first_dts =
3236 st->info->fps_last_dts = AV_NOPTS_VALUE;
3238 /* Check for a discontinuity in dts. If the difference in dts
3239 * is more than 1000 times the average packet duration in the
3240 * sequence, we treat it as a discontinuity. */
3241 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3242 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3243 (pkt->dts - st->info->fps_last_dts) / 1000 >
3244 (st->info->fps_last_dts - st->info->fps_first_dts) /
3245 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3246 av_log(ic, AV_LOG_WARNING,
3247 "DTS discontinuity in stream %d: packet %d with DTS "
3248 "%"PRId64", packet %d with DTS %"PRId64"\n",
3249 st->index, st->info->fps_last_dts_idx,
3250 st->info->fps_last_dts, st->codec_info_nb_frames,
3252 st->info->fps_first_dts =
3253 st->info->fps_last_dts = AV_NOPTS_VALUE;
3256 /* update stored dts values */
3257 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3258 st->info->fps_first_dts = pkt->dts;
3259 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3261 st->info->fps_last_dts = pkt->dts;
3262 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3264 if (st->codec_info_nb_frames>1) {
3267 if (st->time_base.den > 0)
3268 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3269 if (st->avg_frame_rate.num > 0)
3270 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3273 && st->codec_info_nb_frames>30
3274 && st->info->fps_first_dts != AV_NOPTS_VALUE
3275 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3276 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3278 if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3279 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3280 max_analyze_duration,
3282 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3283 av_packet_unref(pkt);
3286 if (pkt->duration) {
3287 st->info->codec_info_duration += pkt->duration;
3288 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3291 #if FF_API_R_FRAME_RATE
3292 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3293 ff_rfps_add_frame(ic, st, pkt->dts);
3295 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3296 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3297 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3298 if (ff_alloc_extradata(st->codec, i))
3299 return AVERROR(ENOMEM);
3300 memcpy(st->codec->extradata, pkt->data,
3301 st->codec->extradata_size);
3305 /* If still no information, we try to open the codec and to
3306 * decompress the frame. We try to avoid that in most cases as
3307 * it takes longer and uses more memory. For MPEG-4, we need to
3308 * decompress for QuickTime.
3310 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3311 * least one frame of codec data, this makes sure the codec initializes
3312 * the channel configuration and does not only trust the values from
3314 try_decode_frame(ic, st, pkt,
3315 (options && i < orig_nb_streams) ? &options[i] : NULL);
3317 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3318 av_packet_unref(pkt);
3320 st->codec_info_nb_frames++;
3325 AVPacket empty_pkt = { 0 };
3327 av_init_packet(&empty_pkt);
3329 for (i = 0; i < ic->nb_streams; i++) {
3331 st = ic->streams[i];
3333 /* flush the decoders */
3334 if (st->info->found_decoder == 1) {
3336 err = try_decode_frame(ic, st, &empty_pkt,
3337 (options && i < orig_nb_streams)
3338 ? &options[i] : NULL);
3339 } while (err > 0 && !has_codec_parameters(st, NULL));
3342 av_log(ic, AV_LOG_INFO,
3343 "decoding for stream %d failed\n", st->index);
3349 // close codecs which were opened in try_decode_frame()
3350 for (i = 0; i < ic->nb_streams; i++) {
3351 st = ic->streams[i];
3352 avcodec_close(st->codec);
3355 ff_rfps_calculate(ic);
3357 for (i = 0; i < ic->nb_streams; i++) {
3358 st = ic->streams[i];
3359 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3360 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3361 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3362 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3363 st->codec->codec_tag= tag;
3366 /* estimate average framerate if not set by demuxer */
3367 if (st->info->codec_info_duration_fields &&
3368 !st->avg_frame_rate.num &&
3369 st->info->codec_info_duration) {
3371 double best_error = 0.01;
3373 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3374 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3375 st->info->codec_info_duration < 0)
3377 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3378 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3379 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3381 /* Round guessed framerate to a "standard" framerate if it's
3382 * within 1% of the original estimate. */
3383 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3384 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3385 double error = fabs(av_q2d(st->avg_frame_rate) /
3386 av_q2d(std_fps) - 1);
3388 if (error < best_error) {
3390 best_fps = std_fps.num;
3394 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3395 best_fps, 12 * 1001, INT_MAX);
3398 if (!st->r_frame_rate.num) {
3399 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3400 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3401 st->r_frame_rate.num = st->codec->time_base.den;
3402 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3404 st->r_frame_rate.num = st->time_base.den;
3405 st->r_frame_rate.den = st->time_base.num;
3408 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3409 AVRational hw_ratio = { st->codec->height, st->codec->width };
3410 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3413 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3414 if (!st->codec->bits_per_coded_sample)
3415 st->codec->bits_per_coded_sample =
3416 av_get_bits_per_sample(st->codec->codec_id);
3417 // set stream disposition based on audio service type
3418 switch (st->codec->audio_service_type) {
3419 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3420 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3422 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3423 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3425 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3426 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3428 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3429 st->disposition = AV_DISPOSITION_COMMENT;
3431 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3432 st->disposition = AV_DISPOSITION_KARAOKE;
3439 estimate_timings(ic, old_offset);
3441 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3443 if (ret >= 0 && ic->nb_streams)
3444 /* We could not have all the codec parameters before EOF. */
3446 for (i = 0; i < ic->nb_streams; i++) {
3448 st = ic->streams[i];
3449 if (!has_codec_parameters(st, &errmsg)) {
3451 avcodec_string(buf, sizeof(buf), st->codec, 0);
3452 av_log(ic, AV_LOG_WARNING,
3453 "Could not find codec parameters for stream %d (%s): %s\n"
3454 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3461 compute_chapters_end(ic);
3463 find_stream_info_err:
3464 for (i = 0; i < ic->nb_streams; i++) {
3465 st = ic->streams[i];
3466 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3467 ic->streams[i]->codec->thread_count = 0;
3469 av_freep(&st->info->duration_error);
3470 av_freep(&ic->streams[i]->info);
3473 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3474 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3478 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3482 for (i = 0; i < ic->nb_programs; i++) {
3483 if (ic->programs[i] == last) {
3487 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3488 if (ic->programs[i]->stream_index[j] == s)
3489 return ic->programs[i];
3495 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3496 int wanted_stream_nb, int related_stream,
3497 AVCodec **decoder_ret, int flags)
3499 int i, nb_streams = ic->nb_streams;
3500 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3501 unsigned *program = NULL;
3502 const AVCodec *decoder = NULL, *best_decoder = NULL;
3504 if (related_stream >= 0 && wanted_stream_nb < 0) {
3505 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3507 program = p->stream_index;
3508 nb_streams = p->nb_stream_indexes;
3511 for (i = 0; i < nb_streams; i++) {
3512 int real_stream_index = program ? program[i] : i;
3513 AVStream *st = ic->streams[real_stream_index];
3514 AVCodecContext *avctx = st->codec;
3515 if (avctx->codec_type != type)
3517 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3519 if (wanted_stream_nb != real_stream_index &&
3520 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3521 AV_DISPOSITION_VISUAL_IMPAIRED))
3523 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3526 decoder = find_decoder(ic, st, st->codec->codec_id);
3529 ret = AVERROR_DECODER_NOT_FOUND;
3533 count = st->codec_info_nb_frames;
3534 bitrate = avctx->bit_rate;
3536 bitrate = avctx->rc_max_rate;
3537 multiframe = FFMIN(5, count);
3538 if ((best_multiframe > multiframe) ||
3539 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3540 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3543 best_bitrate = bitrate;
3544 best_multiframe = multiframe;
3545 ret = real_stream_index;
3546 best_decoder = decoder;
3547 if (program && i == nb_streams - 1 && ret < 0) {
3549 nb_streams = ic->nb_streams;
3550 /* no related stream found, try again with everything */
3555 *decoder_ret = (AVCodec*)best_decoder;
3559 /*******************************************************/
3561 int av_read_play(AVFormatContext *s)
3563 if (s->iformat->read_play)
3564 return s->iformat->read_play(s);
3566 return avio_pause(s->pb, 0);
3567 return AVERROR(ENOSYS);
3570 int av_read_pause(AVFormatContext *s)
3572 if (s->iformat->read_pause)
3573 return s->iformat->read_pause(s);
3575 return avio_pause(s->pb, 1);
3576 return AVERROR(ENOSYS);
3579 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3581 av_assert0(s->nb_streams>0);
3582 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3584 for (j = 0; j < st->nb_side_data; j++)
3585 av_freep(&st->side_data[j].data);
3586 av_freep(&st->side_data);
3587 st->nb_side_data = 0;
3590 av_parser_close(st->parser);
3592 if (st->attached_pic.data)
3593 av_free_packet(&st->attached_pic);
3594 av_dict_free(&st->metadata);
3595 av_freep(&st->probe_data.buf);
3596 av_freep(&st->index_entries);
3597 av_freep(&st->codec->extradata);
3598 av_freep(&st->codec->subtitle_header);
3599 av_freep(&st->codec);
3600 av_freep(&st->priv_data);
3602 av_freep(&st->info->duration_error);
3603 av_freep(&st->info);
3604 av_freep(&st->recommended_encoder_configuration);
3605 av_freep(&s->streams[ --s->nb_streams ]);
3608 void avformat_free_context(AVFormatContext *s)
3616 if (s->iformat && s->iformat->priv_class && s->priv_data)
3617 av_opt_free(s->priv_data);
3618 if (s->oformat && s->oformat->priv_class && s->priv_data)
3619 av_opt_free(s->priv_data);
3621 for (i = s->nb_streams - 1; i >= 0; i--) {
3622 ff_free_stream(s, s->streams[i]);
3624 for (i = s->nb_programs - 1; i >= 0; i--) {
3625 av_dict_free(&s->programs[i]->metadata);
3626 av_freep(&s->programs[i]->stream_index);
3627 av_freep(&s->programs[i]);
3629 av_freep(&s->programs);
3630 av_freep(&s->priv_data);
3631 while (s->nb_chapters--) {
3632 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3633 av_freep(&s->chapters[s->nb_chapters]);
3635 av_freep(&s->chapters);
3636 av_dict_free(&s->metadata);
3637 av_freep(&s->streams);
3638 av_freep(&s->internal);
3639 flush_packet_queue(s);
3643 void avformat_close_input(AVFormatContext **ps)
3654 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3655 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3658 flush_packet_queue(s);
3661 if (s->iformat->read_close)
3662 s->iformat->read_close(s);
3664 avformat_free_context(s);
3671 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3677 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3679 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3682 s->streams = streams;
3684 st = av_mallocz(sizeof(AVStream));
3687 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3691 st->info->last_dts = AV_NOPTS_VALUE;
3693 st->codec = avcodec_alloc_context3(c);
3700 /* no default bitrate if decoding */
3701 st->codec->bit_rate = 0;
3703 /* default pts setting is MPEG-like */
3704 avpriv_set_pts_info(st, 33, 1, 90000);
3707 st->index = s->nb_streams;
3708 st->start_time = AV_NOPTS_VALUE;
3709 st->duration = AV_NOPTS_VALUE;
3710 /* we set the current DTS to 0 so that formats without any timestamps
3711 * but durations get some timestamps, formats with some unknown
3712 * timestamps have their first few packets buffered and the
3713 * timestamps corrected before they are returned to the user */
3714 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3715 st->first_dts = AV_NOPTS_VALUE;
3716 st->probe_packets = MAX_PROBE_PACKETS;
3717 st->pts_wrap_reference = AV_NOPTS_VALUE;
3718 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3720 st->last_IP_pts = AV_NOPTS_VALUE;
3721 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3722 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3723 st->pts_buffer[i] = AV_NOPTS_VALUE;
3725 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3727 #if FF_API_R_FRAME_RATE
3728 st->info->last_dts = AV_NOPTS_VALUE;
3730 st->info->fps_first_dts = AV_NOPTS_VALUE;
3731 st->info->fps_last_dts = AV_NOPTS_VALUE;
3733 st->inject_global_side_data = s->internal->inject_global_side_data;
3735 s->streams[s->nb_streams++] = st;
3739 AVProgram *av_new_program(AVFormatContext *ac, int id)
3741 AVProgram *program = NULL;
3744 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3746 for (i = 0; i < ac->nb_programs; i++)
3747 if (ac->programs[i]->id == id)
3748 program = ac->programs[i];
3751 program = av_mallocz(sizeof(AVProgram));
3754 dynarray_add(&ac->programs, &ac->nb_programs, program);
3755 program->discard = AVDISCARD_NONE;
3758 program->pts_wrap_reference = AV_NOPTS_VALUE;
3759 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3761 program->start_time =
3762 program->end_time = AV_NOPTS_VALUE;
3767 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3768 int64_t start, int64_t end, const char *title)
3770 AVChapter *chapter = NULL;
3773 if (end != AV_NOPTS_VALUE && start > end) {
3774 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3778 for (i = 0; i < s->nb_chapters; i++)
3779 if (s->chapters[i]->id == id)
3780 chapter = s->chapters[i];
3783 chapter = av_mallocz(sizeof(AVChapter));
3786 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3788 av_dict_set(&chapter->metadata, "title", title, 0);
3790 chapter->time_base = time_base;
3791 chapter->start = start;
3797 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3800 AVProgram *program = NULL;
3803 if (idx >= ac->nb_streams) {
3804 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3808 for (i = 0; i < ac->nb_programs; i++) {
3809 if (ac->programs[i]->id != progid)
3811 program = ac->programs[i];
3812 for (j = 0; j < program->nb_stream_indexes; j++)
3813 if (program->stream_index[j] == idx)
3816 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3819 program->stream_index = tmp;
3820 program->stream_index[program->nb_stream_indexes++] = idx;
3825 uint64_t ff_ntp_time(void)
3827 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3830 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3833 char *q, buf1[20], c;
3834 int nd, len, percentd_found;
3846 while (av_isdigit(*p))
3847 nd = nd * 10 + *p++ - '0';
3849 } while (av_isdigit(c));
3860 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3862 if ((q - buf + len) > buf_size - 1)
3864 memcpy(q, buf1, len);
3872 if ((q - buf) < buf_size - 1)
3876 if (!percentd_found)
3885 void av_url_split(char *proto, int proto_size,
3886 char *authorization, int authorization_size,
3887 char *hostname, int hostname_size,
3888 int *port_ptr, char *path, int path_size, const char *url)
3890 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3896 if (authorization_size > 0)
3897 authorization[0] = 0;
3898 if (hostname_size > 0)
3903 /* parse protocol */
3904 if ((p = strchr(url, ':'))) {
3905 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3912 /* no protocol means plain filename */
3913 av_strlcpy(path, url, path_size);
3917 /* separate path from hostname */
3918 ls = strchr(p, '/');
3919 ls2 = strchr(p, '?');
3923 ls = FFMIN(ls, ls2);
3925 av_strlcpy(path, ls, path_size);
3927 ls = &p[strlen(p)]; // XXX
3929 /* the rest is hostname, use that to parse auth/port */
3931 /* authorization (user[:pass]@hostname) */
3933 while ((at = strchr(p, '@')) && at < ls) {
3934 av_strlcpy(authorization, at2,
3935 FFMIN(authorization_size, at + 1 - at2));
3936 p = at + 1; /* skip '@' */
3939 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3941 av_strlcpy(hostname, p + 1,
3942 FFMIN(hostname_size, brk - p));
3943 if (brk[1] == ':' && port_ptr)
3944 *port_ptr = atoi(brk + 2);
3945 } else if ((col = strchr(p, ':')) && col < ls) {
3946 av_strlcpy(hostname, p,
3947 FFMIN(col + 1 - p, hostname_size));
3949 *port_ptr = atoi(col + 1);
3951 av_strlcpy(hostname, p,
3952 FFMIN(ls + 1 - p, hostname_size));
3956 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3959 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3962 'C', 'D', 'E', 'F' };
3963 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3966 'c', 'd', 'e', 'f' };
3967 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3969 for (i = 0; i < s; i++) {
3970 buff[i * 2] = hex_table[src[i] >> 4];
3971 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3977 int ff_hex_to_data(uint8_t *data, const char *p)
3984 p += strspn(p, SPACE_CHARS);
3987 c = av_toupper((unsigned char) *p++);
3988 if (c >= '0' && c <= '9')
3990 else if (c >= 'A' && c <= 'F')
4005 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4006 unsigned int pts_num, unsigned int pts_den)
4009 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4010 if (new_tb.num != pts_num)
4011 av_log(NULL, AV_LOG_DEBUG,
4012 "st:%d removing common factor %d from timebase\n",
4013 s->index, pts_num / new_tb.num);
4015 av_log(NULL, AV_LOG_WARNING,
4016 "st:%d has too large timebase, reducing\n", s->index);
4018 if (new_tb.num <= 0 || new_tb.den <= 0) {
4019 av_log(NULL, AV_LOG_ERROR,
4020 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4021 new_tb.num, new_tb.den,
4025 s->time_base = new_tb;
4026 av_codec_set_pkt_timebase(s->codec, new_tb);
4027 s->pts_wrap_bits = pts_wrap_bits;
4030 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4033 const char *ptr = str;
4035 /* Parse key=value pairs. */
4038 char *dest = NULL, *dest_end;
4039 int key_len, dest_len = 0;
4041 /* Skip whitespace and potential commas. */
4042 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4049 if (!(ptr = strchr(key, '=')))
4052 key_len = ptr - key;
4054 callback_get_buf(context, key, key_len, &dest, &dest_len);
4055 dest_end = dest + dest_len - 1;
4059 while (*ptr && *ptr != '\"') {
4063 if (dest && dest < dest_end)
4067 if (dest && dest < dest_end)
4075 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4076 if (dest && dest < dest_end)
4084 int ff_find_stream_index(AVFormatContext *s, int id)
4087 for (i = 0; i < s->nb_streams; i++)
4088 if (s->streams[i]->id == id)
4093 int64_t ff_iso8601_to_unix_time(const char *datestr)
4095 struct tm time1 = { 0 }, time2 = { 0 };
4096 const char *ret1, *ret2;
4097 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4098 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4100 return av_timegm(&time2);
4102 return av_timegm(&time1);
4105 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4109 if (ofmt->query_codec)
4110 return ofmt->query_codec(codec_id, std_compliance);
4111 else if (ofmt->codec_tag)
4112 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4113 else if (codec_id == ofmt->video_codec ||
4114 codec_id == ofmt->audio_codec ||
4115 codec_id == ofmt->subtitle_codec)
4118 return AVERROR_PATCHWELCOME;
4121 int avformat_network_init(void)
4125 ff_network_inited_globally = 1;
4126 if ((ret = ff_network_init()) < 0)
4128 if ((ret = ff_tls_init()) < 0)
4134 int avformat_network_deinit(void)
4139 ff_network_inited_globally = 0;
4144 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4145 uint64_t channel_layout, int32_t sample_rate,
4146 int32_t width, int32_t height)
4152 return AVERROR(EINVAL);
4155 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4157 if (channel_layout) {
4159 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4163 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4165 if (width || height) {
4167 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4169 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4171 return AVERROR(ENOMEM);
4172 bytestream_put_le32(&data, flags);
4174 bytestream_put_le32(&data, channels);
4176 bytestream_put_le64(&data, channel_layout);
4178 bytestream_put_le32(&data, sample_rate);
4179 if (width || height) {
4180 bytestream_put_le32(&data, width);
4181 bytestream_put_le32(&data, height);
4186 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4188 AVRational undef = {0, 1};
4189 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4190 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4191 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4193 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4194 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4195 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4196 stream_sample_aspect_ratio = undef;
4198 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4199 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4200 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4201 frame_sample_aspect_ratio = undef;
4203 if (stream_sample_aspect_ratio.num)
4204 return stream_sample_aspect_ratio;
4206 return frame_sample_aspect_ratio;
4209 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4211 AVRational fr = st->r_frame_rate;
4212 AVRational codec_fr = st->codec->framerate;
4213 AVRational avg_fr = st->avg_frame_rate;
4215 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4216 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4221 if (st->codec->ticks_per_frame > 1) {
4222 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4223 (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))
4230 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4233 if (*spec <= '9' && *spec >= '0') /* opt:index */
4234 return strtol(spec, NULL, 0) == st->index;
4235 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4236 *spec == 't') { /* opt:[vasdt] */
4237 enum AVMediaType type;
4240 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4241 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4242 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4243 case 'd': type = AVMEDIA_TYPE_DATA; break;
4244 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4245 default: av_assert0(0);
4247 if (type != st->codec->codec_type)
4249 if (*spec++ == ':') { /* possibly followed by :index */
4250 int i, index = strtol(spec, NULL, 0);
4251 for (i = 0; i < s->nb_streams; i++)
4252 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4253 return i == st->index;
4257 } else if (*spec == 'p' && *(spec + 1) == ':') {
4261 prog_id = strtol(spec, &endptr, 0);
4262 for (i = 0; i < s->nb_programs; i++) {
4263 if (s->programs[i]->id != prog_id)
4266 if (*endptr++ == ':') {
4267 int stream_idx = strtol(endptr, NULL, 0);
4268 return stream_idx >= 0 &&
4269 stream_idx < s->programs[i]->nb_stream_indexes &&
4270 st->index == s->programs[i]->stream_index[stream_idx];
4273 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4274 if (st->index == s->programs[i]->stream_index[j])
4278 } else if (*spec == '#' ||
4279 (*spec == 'i' && *(spec + 1) == ':')) {
4282 spec += 1 + (*spec == 'i');
4283 stream_id = strtol(spec, &endptr, 0);
4285 return stream_id == st->id;
4286 } else if (*spec == 'm' && *(spec + 1) == ':') {
4287 AVDictionaryEntry *tag;
4292 val = strchr(spec, ':');
4294 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4296 return AVERROR(ENOMEM);
4298 tag = av_dict_get(st->metadata, key, NULL, 0);
4300 if (!val || !strcmp(tag->value, val + 1))
4309 } else if (*spec == 'u') {
4310 AVCodecContext *avctx = st->codec;
4312 switch (avctx->codec_type) {
4313 case AVMEDIA_TYPE_AUDIO:
4314 val = avctx->sample_rate && avctx->channels;
4315 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4318 case AVMEDIA_TYPE_VIDEO:
4319 val = avctx->width && avctx->height;
4320 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4323 case AVMEDIA_TYPE_UNKNOWN:
4330 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4331 } else if (!*spec) /* empty specifier, matches everything */
4334 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4335 return AVERROR(EINVAL);
4338 int ff_generate_avci_extradata(AVStream *st)
4340 static const uint8_t avci100_1080p_extradata[] = {
4342 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4343 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4344 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4345 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4346 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4347 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4348 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4349 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4350 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4352 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4355 static const uint8_t avci100_1080i_extradata[] = {
4357 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4358 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4359 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4360 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4361 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4362 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4363 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4364 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4365 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4366 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4367 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4369 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4372 static const uint8_t avci50_1080p_extradata[] = {
4374 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4375 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4376 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4377 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4378 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4379 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4380 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4381 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4382 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4384 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4387 static const uint8_t avci50_1080i_extradata[] = {
4389 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4390 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4391 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4392 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4393 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4394 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4395 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4396 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4397 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4398 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4399 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4401 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4404 static const uint8_t avci100_720p_extradata[] = {
4406 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4407 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4408 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4409 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4410 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4411 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4412 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4413 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4414 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4415 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4417 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4420 static const uint8_t avci50_720p_extradata[] = {
4422 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4423 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4424 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4425 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4426 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4427 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4428 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4429 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4430 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4432 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4436 const uint8_t *data = NULL;
4439 if (st->codec->width == 1920) {
4440 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4441 data = avci100_1080p_extradata;
4442 size = sizeof(avci100_1080p_extradata);
4444 data = avci100_1080i_extradata;
4445 size = sizeof(avci100_1080i_extradata);
4447 } else if (st->codec->width == 1440) {
4448 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4449 data = avci50_1080p_extradata;
4450 size = sizeof(avci50_1080p_extradata);
4452 data = avci50_1080i_extradata;
4453 size = sizeof(avci50_1080i_extradata);
4455 } else if (st->codec->width == 1280) {
4456 data = avci100_720p_extradata;
4457 size = sizeof(avci100_720p_extradata);
4458 } else if (st->codec->width == 960) {
4459 data = avci50_720p_extradata;
4460 size = sizeof(avci50_720p_extradata);
4466 av_freep(&st->codec->extradata);
4467 if (ff_alloc_extradata(st->codec, size))
4468 return AVERROR(ENOMEM);
4469 memcpy(st->codec->extradata, data, size);
4474 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4479 for (i = 0; i < st->nb_side_data; i++) {
4480 if (st->side_data[i].type == type) {
4482 *size = st->side_data[i].size;
4483 return st->side_data[i].data;
4489 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4492 AVPacketSideData *sd, *tmp;
4494 uint8_t *data = av_malloc(size);
4499 for (i = 0; i < st->nb_side_data; i++) {
4500 sd = &st->side_data[i];
4502 if (sd->type == type) {
4503 av_freep(&sd->data);
4510 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4516 st->side_data = tmp;
4519 sd = &st->side_data[st->nb_side_data - 1];