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 ((ret = av_opt_set_dict(s, &tmp)) < 0)
424 if ((ret = init_input(s, filename, &tmp)) < 0)
426 s->probe_score = ret;
428 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
429 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
430 ret = AVERROR(EINVAL);
434 avio_skip(s->pb, s->skip_initial_bytes);
436 /* Check filename in case an image number is expected. */
437 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
438 if (!av_filename_number_test(filename)) {
439 ret = AVERROR(EINVAL);
444 s->duration = s->start_time = AV_NOPTS_VALUE;
445 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
447 /* Allocate private data. */
448 if (s->iformat->priv_data_size > 0) {
449 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
450 ret = AVERROR(ENOMEM);
453 if (s->iformat->priv_class) {
454 *(const AVClass **) s->priv_data = s->iformat->priv_class;
455 av_opt_set_defaults(s->priv_data);
456 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
461 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
463 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
465 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
466 if ((ret = s->iformat->read_header(s)) < 0)
469 if (id3v2_extra_meta) {
470 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
471 !strcmp(s->iformat->name, "tta")) {
472 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
475 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
477 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
479 if ((ret = avformat_queue_attached_pictures(s)) < 0)
482 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
483 s->internal->data_offset = avio_tell(s->pb);
485 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
488 av_dict_free(options);
495 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
497 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
499 avformat_free_context(s);
504 /*******************************************************/
506 static void force_codec_ids(AVFormatContext *s, AVStream *st)
508 switch (st->codec->codec_type) {
509 case AVMEDIA_TYPE_VIDEO:
510 if (s->video_codec_id)
511 st->codec->codec_id = s->video_codec_id;
513 case AVMEDIA_TYPE_AUDIO:
514 if (s->audio_codec_id)
515 st->codec->codec_id = s->audio_codec_id;
517 case AVMEDIA_TYPE_SUBTITLE:
518 if (s->subtitle_codec_id)
519 st->codec->codec_id = s->subtitle_codec_id;
524 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
526 if (st->request_probe>0) {
527 AVProbeData *pd = &st->probe_data;
529 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
533 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
535 av_log(s, AV_LOG_WARNING,
536 "Failed to reallocate probe buffer for stream %d\n",
541 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
542 pd->buf_size += pkt->size;
543 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
546 st->probe_packets = 0;
548 av_log(s, AV_LOG_WARNING,
549 "nothing to probe for stream %d\n", st->index);
553 end= s->internal->raw_packet_buffer_remaining_size <= 0
554 || st->probe_packets<= 0;
556 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
557 int score = set_codec_from_probe_data(s, st, pd);
558 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
562 st->request_probe = -1;
563 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
564 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
566 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
568 force_codec_ids(s, st);
574 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
576 int64_t ref = pkt->dts;
577 int i, pts_wrap_behavior;
578 int64_t pts_wrap_reference;
579 AVProgram *first_program;
581 if (ref == AV_NOPTS_VALUE)
583 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
585 ref &= (1LL << st->pts_wrap_bits)-1;
587 // reference time stamp should be 60 s before first time stamp
588 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
589 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
590 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
591 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
592 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
594 first_program = av_find_program_from_stream(s, NULL, stream_index);
596 if (!first_program) {
597 int default_stream_index = av_find_default_stream_index(s);
598 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
599 for (i = 0; i < s->nb_streams; i++) {
600 if (av_find_program_from_stream(s, NULL, i))
602 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
603 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
607 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
608 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
612 AVProgram *program = first_program;
614 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
615 pts_wrap_reference = program->pts_wrap_reference;
616 pts_wrap_behavior = program->pts_wrap_behavior;
619 program = av_find_program_from_stream(s, program, stream_index);
622 // update every program with differing pts_wrap_reference
623 program = first_program;
625 if (program->pts_wrap_reference != pts_wrap_reference) {
626 for (i = 0; i<program->nb_stream_indexes; i++) {
627 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
628 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
631 program->pts_wrap_reference = pts_wrap_reference;
632 program->pts_wrap_behavior = pts_wrap_behavior;
634 program = av_find_program_from_stream(s, program, stream_index);
640 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
646 AVPacketList *pktl = s->internal->raw_packet_buffer;
650 st = s->streams[pkt->stream_index];
651 if (s->internal->raw_packet_buffer_remaining_size <= 0)
652 if ((err = probe_codec(s, st, NULL)) < 0)
654 if (st->request_probe <= 0) {
655 s->internal->raw_packet_buffer = pktl->next;
656 s->internal->raw_packet_buffer_remaining_size += pkt->size;
665 ret = s->iformat->read_packet(s, pkt);
667 if (!pktl || ret == AVERROR(EAGAIN))
669 for (i = 0; i < s->nb_streams; i++) {
671 if (st->probe_packets)
672 if ((err = probe_codec(s, st, NULL)) < 0)
674 av_assert0(st->request_probe <= 0);
679 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
680 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
681 av_log(s, AV_LOG_WARNING,
682 "Dropped corrupted packet (stream = %d)\n",
688 if (pkt->stream_index >= (unsigned)s->nb_streams) {
689 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
693 st = s->streams[pkt->stream_index];
695 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
696 // correct first time stamps to negative values
697 if (!is_relative(st->first_dts))
698 st->first_dts = wrap_timestamp(st, st->first_dts);
699 if (!is_relative(st->start_time))
700 st->start_time = wrap_timestamp(st, st->start_time);
701 if (!is_relative(st->cur_dts))
702 st->cur_dts = wrap_timestamp(st, st->cur_dts);
705 pkt->dts = wrap_timestamp(st, pkt->dts);
706 pkt->pts = wrap_timestamp(st, pkt->pts);
708 force_codec_ids(s, st);
710 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
711 if (s->use_wallclock_as_timestamps)
712 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
714 if (!pktl && st->request_probe <= 0)
717 add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
718 &s->internal->raw_packet_buffer_end);
719 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
721 if ((err = probe_codec(s, st, pkt)) < 0)
727 /**********************************************************/
729 static int determinable_frame_size(AVCodecContext *avctx)
731 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
732 avctx->codec_id == AV_CODEC_ID_MP1 ||
733 avctx->codec_id == AV_CODEC_ID_MP2 ||
734 avctx->codec_id == AV_CODEC_ID_MP3/* ||
735 avctx->codec_id == AV_CODEC_ID_CELT*/)
741 * Return the frame duration in seconds. Return 0 if not available.
743 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
744 AVCodecParserContext *pc, AVPacket *pkt)
746 AVRational codec_framerate = s->iformat ? st->codec->framerate :
747 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
752 switch (st->codec->codec_type) {
753 case AVMEDIA_TYPE_VIDEO:
754 if (st->r_frame_rate.num && !pc && s->iformat) {
755 *pnum = st->r_frame_rate.den;
756 *pden = st->r_frame_rate.num;
757 } else if (st->time_base.num * 1000LL > st->time_base.den) {
758 *pnum = st->time_base.num;
759 *pden = st->time_base.den;
760 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
761 av_assert0(st->codec->ticks_per_frame);
762 av_reduce(pnum, pden,
764 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
767 if (pc && pc->repeat_pict) {
768 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
769 av_reduce(pnum, pden,
770 (*pnum) * (1LL + pc->repeat_pict),
774 /* If this codec can be interlaced or progressive then we need
775 * a parser to compute duration of a packet. Thus if we have
776 * no parser in such case leave duration undefined. */
777 if (st->codec->ticks_per_frame > 1 && !pc)
781 case AVMEDIA_TYPE_AUDIO:
782 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
783 if (frame_size <= 0 || st->codec->sample_rate <= 0)
786 *pden = st->codec->sample_rate;
793 static int is_intra_only(AVCodecContext *enc) {
794 const AVCodecDescriptor *desc;
796 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
799 desc = av_codec_get_codec_descriptor(enc);
801 desc = avcodec_descriptor_get(enc->codec_id);
802 av_codec_set_codec_descriptor(enc, desc);
805 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
809 static int has_decode_delay_been_guessed(AVStream *st)
811 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
812 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
814 #if CONFIG_H264_DECODER
815 if (st->codec->has_b_frames &&
816 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
819 if (st->codec->has_b_frames<3)
820 return st->nb_decoded_frames >= 7;
821 else if (st->codec->has_b_frames<4)
822 return st->nb_decoded_frames >= 18;
824 return st->nb_decoded_frames >= 20;
827 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
831 if (pktl == s->internal->packet_buffer_end)
832 return s->internal->parse_queue;
836 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
837 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
838 st->codec->codec_id != AV_CODEC_ID_HEVC;
841 int delay = st->codec->has_b_frames;
844 if (dts == AV_NOPTS_VALUE) {
845 int64_t best_score = INT64_MAX;
846 for (i = 0; i<delay; i++) {
847 if (st->pts_reorder_error_count[i]) {
848 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
849 if (score < best_score) {
856 for (i = 0; i<delay; i++) {
857 if (pts_buffer[i] != AV_NOPTS_VALUE) {
858 int64_t diff = FFABS(pts_buffer[i] - dts)
859 + (uint64_t)st->pts_reorder_error[i];
860 diff = FFMAX(diff, st->pts_reorder_error[i]);
861 st->pts_reorder_error[i] = diff;
862 st->pts_reorder_error_count[i]++;
863 if (st->pts_reorder_error_count[i] > 250) {
864 st->pts_reorder_error[i] >>= 1;
865 st->pts_reorder_error_count[i] >>= 1;
872 if (dts == AV_NOPTS_VALUE)
878 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
879 int64_t dts, int64_t pts, AVPacket *pkt)
881 AVStream *st = s->streams[stream_index];
882 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
883 int64_t pts_buffer[MAX_REORDER_DELAY+1];
887 if (st->first_dts != AV_NOPTS_VALUE ||
888 dts == AV_NOPTS_VALUE ||
889 st->cur_dts == AV_NOPTS_VALUE ||
893 delay = st->codec->has_b_frames;
894 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
896 shift = st->first_dts - RELATIVE_TS_BASE;
898 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
899 pts_buffer[i] = AV_NOPTS_VALUE;
901 if (is_relative(pts))
904 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
905 if (pktl->pkt.stream_index != stream_index)
907 if (is_relative(pktl->pkt.pts))
908 pktl->pkt.pts += shift;
910 if (is_relative(pktl->pkt.dts))
911 pktl->pkt.dts += shift;
913 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
914 st->start_time = pktl->pkt.pts;
916 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
917 pts_buffer[0] = pktl->pkt.pts;
918 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
919 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
921 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
925 if (st->start_time == AV_NOPTS_VALUE)
926 st->start_time = pts;
929 static void update_initial_durations(AVFormatContext *s, AVStream *st,
930 int stream_index, int duration)
932 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
933 int64_t cur_dts = RELATIVE_TS_BASE;
935 if (st->first_dts != AV_NOPTS_VALUE) {
936 if (st->update_initial_durations_done)
938 st->update_initial_durations_done = 1;
939 cur_dts = st->first_dts;
940 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
941 if (pktl->pkt.stream_index == stream_index) {
942 if (pktl->pkt.pts != pktl->pkt.dts ||
943 pktl->pkt.dts != AV_NOPTS_VALUE ||
949 if (pktl && pktl->pkt.dts != st->first_dts) {
950 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
951 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
955 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
958 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
959 st->first_dts = cur_dts;
960 } else if (st->cur_dts != RELATIVE_TS_BASE)
963 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
964 if (pktl->pkt.stream_index != stream_index)
966 if (pktl->pkt.pts == pktl->pkt.dts &&
967 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
968 !pktl->pkt.duration) {
969 pktl->pkt.dts = cur_dts;
970 if (!st->codec->has_b_frames)
971 pktl->pkt.pts = cur_dts;
972 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
973 pktl->pkt.duration = duration;
976 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
979 st->cur_dts = cur_dts;
982 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
983 AVCodecParserContext *pc, AVPacket *pkt,
984 int64_t next_dts, int64_t next_pts)
986 int num, den, presentation_delayed, delay, i;
989 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
990 st->codec->codec_id != AV_CODEC_ID_HEVC;
992 if (s->flags & AVFMT_FLAG_NOFILLIN)
995 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
996 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
997 if (st->last_dts_for_order_check <= pkt->dts) {
1000 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1001 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1003 st->last_dts_for_order_check);
1004 st->dts_misordered++;
1006 if (st->dts_ordered + st->dts_misordered > 250) {
1007 st->dts_ordered >>= 1;
1008 st->dts_misordered >>= 1;
1012 st->last_dts_for_order_check = pkt->dts;
1013 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1014 pkt->dts = AV_NOPTS_VALUE;
1017 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1018 pkt->dts = AV_NOPTS_VALUE;
1020 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1021 && !st->codec->has_b_frames)
1022 //FIXME Set low_delay = 0 when has_b_frames = 1
1023 st->codec->has_b_frames = 1;
1025 /* do we have a video B-frame ? */
1026 delay = st->codec->has_b_frames;
1027 presentation_delayed = 0;
1029 /* XXX: need has_b_frame, but cannot get it if the codec is
1030 * not initialized */
1032 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1033 presentation_delayed = 1;
1035 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1036 st->pts_wrap_bits < 63 &&
1037 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1038 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1039 pkt->dts -= 1LL << st->pts_wrap_bits;
1041 pkt->pts += 1LL << st->pts_wrap_bits;
1044 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1045 * We take the conservative approach and discard both.
1046 * Note: If this is misbehaving for an H.264 file, then possibly
1047 * presentation_delayed is not set correctly. */
1048 if (delay == 1 && pkt->dts == pkt->pts &&
1049 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1050 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1051 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1052 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1053 pkt->dts = AV_NOPTS_VALUE;
1056 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1057 if (pkt->duration == 0) {
1058 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1060 duration = (AVRational) {num, den};
1061 pkt->duration = av_rescale_rnd(1,
1062 num * (int64_t) st->time_base.den,
1063 den * (int64_t) st->time_base.num,
1068 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1069 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1071 /* Correct timestamps with byte offset if demuxers only have timestamps
1072 * on packet boundaries */
1073 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1074 /* this will estimate bitrate based on this frame's duration and size */
1075 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1076 if (pkt->pts != AV_NOPTS_VALUE)
1078 if (pkt->dts != AV_NOPTS_VALUE)
1082 /* This may be redundant, but it should not hurt. */
1083 if (pkt->dts != AV_NOPTS_VALUE &&
1084 pkt->pts != AV_NOPTS_VALUE &&
1085 pkt->pts > pkt->dts)
1086 presentation_delayed = 1;
1089 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1090 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1091 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1092 /* Interpolate PTS and DTS if they are not present. We skip H264
1093 * currently because delay and has_b_frames are not reliably set. */
1094 if ((delay == 0 || (delay == 1 && pc)) &&
1096 if (presentation_delayed) {
1097 /* DTS = decompression timestamp */
1098 /* PTS = presentation timestamp */
1099 if (pkt->dts == AV_NOPTS_VALUE)
1100 pkt->dts = st->last_IP_pts;
1101 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1102 if (pkt->dts == AV_NOPTS_VALUE)
1103 pkt->dts = st->cur_dts;
1105 /* This is tricky: the dts must be incremented by the duration
1106 * of the frame we are displaying, i.e. the last I- or P-frame. */
1107 if (st->last_IP_duration == 0)
1108 st->last_IP_duration = pkt->duration;
1109 if (pkt->dts != AV_NOPTS_VALUE)
1110 st->cur_dts = pkt->dts + st->last_IP_duration;
1111 if (pkt->dts != AV_NOPTS_VALUE &&
1112 pkt->pts == AV_NOPTS_VALUE &&
1113 st->last_IP_duration > 0 &&
1114 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1115 next_dts != next_pts &&
1116 next_pts != AV_NOPTS_VALUE)
1117 pkt->pts = next_dts;
1119 st->last_IP_duration = pkt->duration;
1120 st->last_IP_pts = pkt->pts;
1121 /* Cannot compute PTS if not present (we can compute it only
1122 * by knowing the future. */
1123 } else if (pkt->pts != AV_NOPTS_VALUE ||
1124 pkt->dts != AV_NOPTS_VALUE ||
1127 /* presentation is not delayed : PTS and DTS are the same */
1128 if (pkt->pts == AV_NOPTS_VALUE)
1129 pkt->pts = pkt->dts;
1130 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1132 if (pkt->pts == AV_NOPTS_VALUE)
1133 pkt->pts = st->cur_dts;
1134 pkt->dts = pkt->pts;
1135 if (pkt->pts != AV_NOPTS_VALUE)
1136 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1140 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1141 st->pts_buffer[0] = pkt->pts;
1142 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1143 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1145 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1147 // We skipped it above so we try here.
1149 // This should happen on the first packet
1150 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1151 if (pkt->dts > st->cur_dts)
1152 st->cur_dts = pkt->dts;
1154 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1155 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1158 if (is_intra_only(st->codec))
1159 pkt->flags |= AV_PKT_FLAG_KEY;
1161 pkt->convergence_duration = pc->convergence_duration;
1164 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1167 AVPacketList *pktl = *pkt_buf;
1168 *pkt_buf = pktl->next;
1169 av_free_packet(&pktl->pkt);
1172 *pkt_buf_end = NULL;
1176 * Parse a packet, add all split parts to parse_queue.
1178 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1180 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1182 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1183 AVStream *st = s->streams[stream_index];
1184 uint8_t *data = pkt ? pkt->data : NULL;
1185 int size = pkt ? pkt->size : 0;
1186 int ret = 0, got_output = 0;
1189 av_init_packet(&flush_pkt);
1192 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1193 // preserve 0-size sync packets
1194 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1197 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1199 int64_t next_pts = pkt->pts;
1200 int64_t next_dts = pkt->dts;
1202 av_init_packet(&out_pkt);
1203 len = av_parser_parse2(st->parser, st->codec,
1204 &out_pkt.data, &out_pkt.size, data, size,
1205 pkt->pts, pkt->dts, pkt->pos);
1207 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1209 /* increment read pointer */
1213 got_output = !!out_pkt.size;
1218 if (pkt->side_data) {
1219 out_pkt.side_data = pkt->side_data;
1220 out_pkt.side_data_elems = pkt->side_data_elems;
1221 pkt->side_data = NULL;
1222 pkt->side_data_elems = 0;
1225 /* set the duration */
1226 out_pkt.duration = 0;
1227 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1228 if (st->codec->sample_rate > 0) {
1230 av_rescale_q_rnd(st->parser->duration,
1231 (AVRational) { 1, st->codec->sample_rate },
1237 out_pkt.stream_index = st->index;
1238 out_pkt.pts = st->parser->pts;
1239 out_pkt.dts = st->parser->dts;
1240 out_pkt.pos = st->parser->pos;
1242 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1243 out_pkt.pos = st->parser->frame_offset;
1245 if (st->parser->key_frame == 1 ||
1246 (st->parser->key_frame == -1 &&
1247 st->parser->pict_type == AV_PICTURE_TYPE_I))
1248 out_pkt.flags |= AV_PKT_FLAG_KEY;
1250 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1251 out_pkt.flags |= AV_PKT_FLAG_KEY;
1253 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1255 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1256 out_pkt.buf = pkt->buf;
1258 #if FF_API_DESTRUCT_PACKET
1259 FF_DISABLE_DEPRECATION_WARNINGS
1260 out_pkt.destruct = pkt->destruct;
1261 pkt->destruct = NULL;
1262 FF_ENABLE_DEPRECATION_WARNINGS
1265 if ((ret = av_dup_packet(&out_pkt)) < 0)
1268 if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1269 av_free_packet(&out_pkt);
1270 ret = AVERROR(ENOMEM);
1275 /* end of the stream => close and free the parser */
1276 if (pkt == &flush_pkt) {
1277 av_parser_close(st->parser);
1282 av_free_packet(pkt);
1286 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1287 AVPacketList **pkt_buffer_end,
1291 av_assert0(*pkt_buffer);
1294 *pkt_buffer = pktl->next;
1296 *pkt_buffer_end = NULL;
1301 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1303 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1306 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1308 int ret = 0, i, got_packet = 0;
1309 AVDictionary *metadata = NULL;
1311 av_init_packet(pkt);
1313 while (!got_packet && !s->internal->parse_queue) {
1317 /* read next packet */
1318 ret = ff_read_packet(s, &cur_pkt);
1320 if (ret == AVERROR(EAGAIN))
1322 /* flush the parsers */
1323 for (i = 0; i < s->nb_streams; i++) {
1325 if (st->parser && st->need_parsing)
1326 parse_packet(s, NULL, st->index);
1328 /* all remaining packets are now in parse_queue =>
1329 * really terminate parsing */
1333 st = s->streams[cur_pkt.stream_index];
1335 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1336 cur_pkt.dts != AV_NOPTS_VALUE &&
1337 cur_pkt.pts < cur_pkt.dts) {
1338 av_log(s, AV_LOG_WARNING,
1339 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1340 cur_pkt.stream_index,
1341 av_ts2str(cur_pkt.pts),
1342 av_ts2str(cur_pkt.dts),
1345 if (s->debug & FF_FDEBUG_TS)
1346 av_log(s, AV_LOG_DEBUG,
1347 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1348 cur_pkt.stream_index,
1349 av_ts2str(cur_pkt.pts),
1350 av_ts2str(cur_pkt.dts),
1351 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1353 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1354 st->parser = av_parser_init(st->codec->codec_id);
1356 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1357 "%s, packets or times may be invalid.\n",
1358 avcodec_get_name(st->codec->codec_id));
1359 /* no parser available: just output the raw packets */
1360 st->need_parsing = AVSTREAM_PARSE_NONE;
1361 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1362 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1363 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1364 st->parser->flags |= PARSER_FLAG_ONCE;
1365 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1366 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1369 if (!st->need_parsing || !st->parser) {
1370 /* no parsing needed: we just output the packet as is */
1372 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1373 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1374 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1375 ff_reduce_index(s, st->index);
1376 av_add_index_entry(st, pkt->pos, pkt->dts,
1377 0, 0, AVINDEX_KEYFRAME);
1380 } else if (st->discard < AVDISCARD_ALL) {
1381 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1385 av_free_packet(&cur_pkt);
1387 if (pkt->flags & AV_PKT_FLAG_KEY)
1388 st->skip_to_keyframe = 0;
1389 if (st->skip_to_keyframe) {
1390 av_free_packet(&cur_pkt);
1398 if (!got_packet && s->internal->parse_queue)
1399 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1402 AVStream *st = s->streams[pkt->stream_index];
1403 int discard_padding = 0;
1404 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1405 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1406 int64_t sample = ts_to_samples(st, pts);
1407 int duration = ts_to_samples(st, pkt->duration);
1408 int64_t end_sample = sample + duration;
1409 if (duration > 0 && end_sample >= st->first_discard_sample &&
1410 sample < st->last_discard_sample)
1411 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1413 if (st->skip_samples || discard_padding) {
1414 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1416 AV_WL32(p, st->skip_samples);
1417 AV_WL32(p + 4, discard_padding);
1418 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1420 st->skip_samples = 0;
1423 if (st->inject_global_side_data) {
1424 for (i = 0; i < st->nb_side_data; i++) {
1425 AVPacketSideData *src_sd = &st->side_data[i];
1428 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1431 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1433 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1437 memcpy(dst_data, src_sd->data, src_sd->size);
1439 st->inject_global_side_data = 0;
1442 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1443 av_packet_merge_side_data(pkt);
1446 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1448 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1449 av_dict_copy(&s->metadata, metadata, 0);
1450 av_dict_free(&metadata);
1451 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1454 if (s->debug & FF_FDEBUG_TS)
1455 av_log(s, AV_LOG_DEBUG,
1456 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1457 "size=%d, duration=%d, flags=%d\n",
1459 av_ts2str(pkt->pts),
1460 av_ts2str(pkt->dts),
1461 pkt->size, pkt->duration, pkt->flags);
1466 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1468 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1474 ret = s->internal->packet_buffer
1475 ? read_from_packet_buffer(&s->internal->packet_buffer,
1476 &s->internal->packet_buffer_end, pkt)
1477 : read_frame_internal(s, pkt);
1484 AVPacketList *pktl = s->internal->packet_buffer;
1487 AVPacket *next_pkt = &pktl->pkt;
1489 if (next_pkt->dts != AV_NOPTS_VALUE) {
1490 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1491 // last dts seen for this stream. if any of packets following
1492 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1493 int64_t last_dts = next_pkt->dts;
1494 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1495 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1496 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1497 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1499 next_pkt->pts = pktl->pkt.dts;
1501 if (last_dts != AV_NOPTS_VALUE) {
1502 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1503 last_dts = pktl->pkt.dts;
1508 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1509 // Fixing the last reference frame had none pts issue (For MXF etc).
1510 // We only do this when
1512 // 2. we are not able to resolve a pts value for current packet.
1513 // 3. the packets for this stream at the end of the files had valid dts.
1514 next_pkt->pts = last_dts + next_pkt->duration;
1516 pktl = s->internal->packet_buffer;
1519 /* read packet from packet buffer, if there is data */
1520 st = s->streams[next_pkt->stream_index];
1521 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1522 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1523 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1524 &s->internal->packet_buffer_end, pkt);
1529 ret = read_frame_internal(s, pkt);
1531 if (pktl && ret != AVERROR(EAGAIN)) {
1538 if (av_dup_packet(add_to_pktbuf(&s->internal->packet_buffer, pkt,
1539 &s->internal->packet_buffer_end)) < 0)
1540 return AVERROR(ENOMEM);
1545 st = s->streams[pkt->stream_index];
1546 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1547 ff_reduce_index(s, st->index);
1548 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1551 if (is_relative(pkt->dts))
1552 pkt->dts -= RELATIVE_TS_BASE;
1553 if (is_relative(pkt->pts))
1554 pkt->pts -= RELATIVE_TS_BASE;
1559 /* XXX: suppress the packet queue */
1560 static void flush_packet_queue(AVFormatContext *s)
1564 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1565 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1566 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1568 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1571 /*******************************************************/
1574 int av_find_default_stream_index(AVFormatContext *s)
1578 int best_stream = 0;
1579 int best_score = -1;
1581 if (s->nb_streams <= 0)
1583 for (i = 0; i < s->nb_streams; i++) {
1586 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1587 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1588 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1593 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1594 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1600 if (score > best_score) {
1608 /** Flush the frame reader. */
1609 void ff_read_frame_flush(AVFormatContext *s)
1614 flush_packet_queue(s);
1616 /* Reset read state for each stream. */
1617 for (i = 0; i < s->nb_streams; i++) {
1621 av_parser_close(st->parser);
1624 st->last_IP_pts = AV_NOPTS_VALUE;
1625 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1626 if (st->first_dts == AV_NOPTS_VALUE)
1627 st->cur_dts = RELATIVE_TS_BASE;
1629 /* We set the current DTS to an unspecified origin. */
1630 st->cur_dts = AV_NOPTS_VALUE;
1632 st->probe_packets = MAX_PROBE_PACKETS;
1634 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1635 st->pts_buffer[j] = AV_NOPTS_VALUE;
1637 if (s->internal->inject_global_side_data)
1638 st->inject_global_side_data = 1;
1642 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1646 for (i = 0; i < s->nb_streams; i++) {
1647 AVStream *st = s->streams[i];
1650 av_rescale(timestamp,
1651 st->time_base.den * (int64_t) ref_st->time_base.num,
1652 st->time_base.num * (int64_t) ref_st->time_base.den);
1656 void ff_reduce_index(AVFormatContext *s, int stream_index)
1658 AVStream *st = s->streams[stream_index];
1659 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1661 if ((unsigned) st->nb_index_entries >= max_entries) {
1663 for (i = 0; 2 * i < st->nb_index_entries; i++)
1664 st->index_entries[i] = st->index_entries[2 * i];
1665 st->nb_index_entries = i;
1669 int ff_add_index_entry(AVIndexEntry **index_entries,
1670 int *nb_index_entries,
1671 unsigned int *index_entries_allocated_size,
1672 int64_t pos, int64_t timestamp,
1673 int size, int distance, int flags)
1675 AVIndexEntry *entries, *ie;
1678 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1681 if (timestamp == AV_NOPTS_VALUE)
1682 return AVERROR(EINVAL);
1684 if (size < 0 || size > 0x3FFFFFFF)
1685 return AVERROR(EINVAL);
1687 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1688 timestamp -= RELATIVE_TS_BASE;
1690 entries = av_fast_realloc(*index_entries,
1691 index_entries_allocated_size,
1692 (*nb_index_entries + 1) *
1693 sizeof(AVIndexEntry));
1697 *index_entries = entries;
1699 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1700 timestamp, AVSEEK_FLAG_ANY);
1703 index = (*nb_index_entries)++;
1704 ie = &entries[index];
1705 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1707 ie = &entries[index];
1708 if (ie->timestamp != timestamp) {
1709 if (ie->timestamp <= timestamp)
1711 memmove(entries + index + 1, entries + index,
1712 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1713 (*nb_index_entries)++;
1714 } else if (ie->pos == pos && distance < ie->min_distance)
1715 // do not reduce the distance
1716 distance = ie->min_distance;
1720 ie->timestamp = timestamp;
1721 ie->min_distance = distance;
1728 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1729 int size, int distance, int flags)
1731 timestamp = wrap_timestamp(st, timestamp);
1732 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1733 &st->index_entries_allocated_size, pos,
1734 timestamp, size, distance, flags);
1737 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1738 int64_t wanted_timestamp, int flags)
1746 // Optimize appending index entries at the end.
1747 if (b && entries[b - 1].timestamp < wanted_timestamp)
1752 timestamp = entries[m].timestamp;
1753 if (timestamp >= wanted_timestamp)
1755 if (timestamp <= wanted_timestamp)
1758 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1760 if (!(flags & AVSEEK_FLAG_ANY))
1761 while (m >= 0 && m < nb_entries &&
1762 !(entries[m].flags & AVINDEX_KEYFRAME))
1763 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1765 if (m == nb_entries)
1770 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1772 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1773 wanted_timestamp, flags);
1776 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1777 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1779 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1780 if (stream_index >= 0)
1781 ts = wrap_timestamp(s->streams[stream_index], ts);
1785 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1786 int64_t target_ts, int flags)
1788 AVInputFormat *avif = s->iformat;
1789 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1790 int64_t ts_min, ts_max, ts;
1795 if (stream_index < 0)
1798 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1801 ts_min = AV_NOPTS_VALUE;
1802 pos_limit = -1; // GCC falsely says it may be uninitialized.
1804 st = s->streams[stream_index];
1805 if (st->index_entries) {
1808 /* FIXME: Whole function must be checked for non-keyframe entries in
1809 * index case, especially read_timestamp(). */
1810 index = av_index_search_timestamp(st, target_ts,
1811 flags | AVSEEK_FLAG_BACKWARD);
1812 index = FFMAX(index, 0);
1813 e = &st->index_entries[index];
1815 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1817 ts_min = e->timestamp;
1818 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1819 pos_min, av_ts2str(ts_min));
1821 av_assert1(index == 0);
1824 index = av_index_search_timestamp(st, target_ts,
1825 flags & ~AVSEEK_FLAG_BACKWARD);
1826 av_assert0(index < st->nb_index_entries);
1828 e = &st->index_entries[index];
1829 av_assert1(e->timestamp >= target_ts);
1831 ts_max = e->timestamp;
1832 pos_limit = pos_max - e->min_distance;
1833 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1834 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1838 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1839 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1844 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1847 ff_read_frame_flush(s);
1848 ff_update_cur_dts(s, st, ts);
1853 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1854 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1856 int64_t step = 1024;
1857 int64_t limit, ts_max;
1858 int64_t filesize = avio_size(s->pb);
1859 int64_t pos_max = filesize - 1;
1862 pos_max = FFMAX(0, (pos_max) - step);
1863 ts_max = ff_read_timestamp(s, stream_index,
1864 &pos_max, limit, read_timestamp);
1866 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1867 if (ts_max == AV_NOPTS_VALUE)
1871 int64_t tmp_pos = pos_max + 1;
1872 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1873 &tmp_pos, INT64_MAX, read_timestamp);
1874 if (tmp_ts == AV_NOPTS_VALUE)
1876 av_assert0(tmp_pos > pos_max);
1879 if (tmp_pos >= filesize)
1891 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1892 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1893 int64_t ts_min, int64_t ts_max,
1894 int flags, int64_t *ts_ret,
1895 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1896 int64_t *, int64_t))
1903 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1905 if (ts_min == AV_NOPTS_VALUE) {
1906 pos_min = s->internal->data_offset;
1907 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1908 if (ts_min == AV_NOPTS_VALUE)
1912 if (ts_min >= target_ts) {
1917 if (ts_max == AV_NOPTS_VALUE) {
1918 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1920 pos_limit = pos_max;
1923 if (ts_max <= target_ts) {
1928 av_assert0(ts_min < ts_max);
1931 while (pos_min < pos_limit) {
1933 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1934 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1935 av_assert0(pos_limit <= pos_max);
1937 if (no_change == 0) {
1938 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1939 // interpolate position (better than dichotomy)
1940 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1942 pos_min - approximate_keyframe_distance;
1943 } else if (no_change == 1) {
1944 // bisection if interpolation did not change min / max pos last time
1945 pos = (pos_min + pos_limit) >> 1;
1947 /* linear search if bisection failed, can only happen if there
1948 * are very few or no keyframes between min/max */
1953 else if (pos > pos_limit)
1957 // May pass pos_limit instead of -1.
1958 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1963 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1964 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1965 pos_min, pos, pos_max,
1966 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1967 pos_limit, start_pos, no_change);
1968 if (ts == AV_NOPTS_VALUE) {
1969 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1972 if (target_ts <= ts) {
1973 pos_limit = start_pos - 1;
1977 if (target_ts >= ts) {
1983 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1984 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1987 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1989 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1990 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1991 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1997 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1998 int64_t pos, int flags)
2000 int64_t pos_min, pos_max;
2002 pos_min = s->internal->data_offset;
2003 pos_max = avio_size(s->pb) - 1;
2007 else if (pos > pos_max)
2010 avio_seek(s->pb, pos, SEEK_SET);
2012 s->io_repositioned = 1;
2017 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2018 int64_t timestamp, int flags)
2025 st = s->streams[stream_index];
2027 index = av_index_search_timestamp(st, timestamp, flags);
2029 if (index < 0 && st->nb_index_entries &&
2030 timestamp < st->index_entries[0].timestamp)
2033 if (index < 0 || index == st->nb_index_entries - 1) {
2037 if (st->nb_index_entries) {
2038 av_assert0(st->index_entries);
2039 ie = &st->index_entries[st->nb_index_entries - 1];
2040 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2042 ff_update_cur_dts(s, st, ie->timestamp);
2044 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2050 read_status = av_read_frame(s, &pkt);
2051 } while (read_status == AVERROR(EAGAIN));
2052 if (read_status < 0)
2054 av_free_packet(&pkt);
2055 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2056 if (pkt.flags & AV_PKT_FLAG_KEY)
2058 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2059 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);
2064 index = av_index_search_timestamp(st, timestamp, flags);
2069 ff_read_frame_flush(s);
2070 if (s->iformat->read_seek)
2071 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2073 ie = &st->index_entries[index];
2074 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2076 ff_update_cur_dts(s, st, ie->timestamp);
2081 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2082 int64_t timestamp, int flags)
2087 if (flags & AVSEEK_FLAG_BYTE) {
2088 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2090 ff_read_frame_flush(s);
2091 return seek_frame_byte(s, stream_index, timestamp, flags);
2094 if (stream_index < 0) {
2095 stream_index = av_find_default_stream_index(s);
2096 if (stream_index < 0)
2099 st = s->streams[stream_index];
2100 /* timestamp for default must be expressed in AV_TIME_BASE units */
2101 timestamp = av_rescale(timestamp, st->time_base.den,
2102 AV_TIME_BASE * (int64_t) st->time_base.num);
2105 /* first, we try the format specific seek */
2106 if (s->iformat->read_seek) {
2107 ff_read_frame_flush(s);
2108 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2114 if (s->iformat->read_timestamp &&
2115 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2116 ff_read_frame_flush(s);
2117 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2118 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2119 ff_read_frame_flush(s);
2120 return seek_frame_generic(s, stream_index, timestamp, flags);
2125 int av_seek_frame(AVFormatContext *s, int stream_index,
2126 int64_t timestamp, int flags)
2130 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2131 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2132 if ((flags & AVSEEK_FLAG_BACKWARD))
2136 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2137 flags & ~AVSEEK_FLAG_BACKWARD);
2140 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2143 ret = avformat_queue_attached_pictures(s);
2148 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2149 int64_t ts, int64_t max_ts, int flags)
2151 if (min_ts > ts || max_ts < ts)
2153 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2154 return AVERROR(EINVAL);
2157 flags |= AVSEEK_FLAG_ANY;
2158 flags &= ~AVSEEK_FLAG_BACKWARD;
2160 if (s->iformat->read_seek2) {
2162 ff_read_frame_flush(s);
2164 if (stream_index == -1 && s->nb_streams == 1) {
2165 AVRational time_base = s->streams[0]->time_base;
2166 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2167 min_ts = av_rescale_rnd(min_ts, time_base.den,
2168 time_base.num * (int64_t)AV_TIME_BASE,
2169 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2170 max_ts = av_rescale_rnd(max_ts, time_base.den,
2171 time_base.num * (int64_t)AV_TIME_BASE,
2172 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2175 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2179 ret = avformat_queue_attached_pictures(s);
2183 if (s->iformat->read_timestamp) {
2184 // try to seek via read_timestamp()
2187 // Fall back on old API if new is not implemented but old is.
2188 // Note the old API has somewhat different semantics.
2189 if (s->iformat->read_seek || 1) {
2190 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2191 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2192 if (ret<0 && ts != min_ts && max_ts != ts) {
2193 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2195 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2200 // try some generic seek like seek_frame_generic() but with new ts semantics
2201 return -1; //unreachable
2204 /*******************************************************/
2207 * Return TRUE if the stream has accurate duration in any stream.
2209 * @return TRUE if the stream has accurate duration for at least one component.
2211 static int has_duration(AVFormatContext *ic)
2216 for (i = 0; i < ic->nb_streams; i++) {
2217 st = ic->streams[i];
2218 if (st->duration != AV_NOPTS_VALUE)
2221 if (ic->duration != AV_NOPTS_VALUE)
2227 * Estimate the stream timings from the one of each components.
2229 * Also computes the global bitrate if possible.
2231 static void update_stream_timings(AVFormatContext *ic)
2233 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2234 int64_t duration, duration1, filesize;
2239 start_time = INT64_MAX;
2240 start_time_text = INT64_MAX;
2241 end_time = INT64_MIN;
2242 duration = INT64_MIN;
2243 for (i = 0; i < ic->nb_streams; i++) {
2244 st = ic->streams[i];
2245 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2246 start_time1 = av_rescale_q(st->start_time, st->time_base,
2248 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2249 if (start_time1 < start_time_text)
2250 start_time_text = start_time1;
2252 start_time = FFMIN(start_time, start_time1);
2253 end_time1 = AV_NOPTS_VALUE;
2254 if (st->duration != AV_NOPTS_VALUE) {
2255 end_time1 = start_time1 +
2256 av_rescale_q(st->duration, st->time_base,
2258 end_time = FFMAX(end_time, end_time1);
2260 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2261 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2262 p->start_time = start_time1;
2263 if (p->end_time < end_time1)
2264 p->end_time = end_time1;
2267 if (st->duration != AV_NOPTS_VALUE) {
2268 duration1 = av_rescale_q(st->duration, st->time_base,
2270 duration = FFMAX(duration, duration1);
2273 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2274 start_time = start_time_text;
2275 else if (start_time > start_time_text)
2276 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2278 if (start_time != INT64_MAX) {
2279 ic->start_time = start_time;
2280 if (end_time != INT64_MIN) {
2281 if (ic->nb_programs) {
2282 for (i = 0; i < ic->nb_programs; i++) {
2283 p = ic->programs[i];
2284 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2285 duration = FFMAX(duration, p->end_time - p->start_time);
2288 duration = FFMAX(duration, end_time - start_time);
2291 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2292 ic->duration = duration;
2294 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2295 /* compute the bitrate */
2296 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2297 (double) ic->duration;
2298 if (bitrate >= 0 && bitrate <= INT_MAX)
2299 ic->bit_rate = bitrate;
2303 static void fill_all_stream_timings(AVFormatContext *ic)
2308 update_stream_timings(ic);
2309 for (i = 0; i < ic->nb_streams; i++) {
2310 st = ic->streams[i];
2311 if (st->start_time == AV_NOPTS_VALUE) {
2312 if (ic->start_time != AV_NOPTS_VALUE)
2313 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2315 if (ic->duration != AV_NOPTS_VALUE)
2316 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2322 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2324 int64_t filesize, duration;
2325 int i, show_warning = 0;
2328 /* if bit_rate is already set, we believe it */
2329 if (ic->bit_rate <= 0) {
2331 for (i = 0; i < ic->nb_streams; i++) {
2332 st = ic->streams[i];
2333 if (st->codec->bit_rate > 0) {
2334 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2338 bit_rate += st->codec->bit_rate;
2339 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2340 // If we have a videostream with packets but without a bitrate
2341 // then consider the sum not known
2346 ic->bit_rate = bit_rate;
2349 /* if duration is already set, we believe it */
2350 if (ic->duration == AV_NOPTS_VALUE &&
2351 ic->bit_rate != 0) {
2352 filesize = ic->pb ? avio_size(ic->pb) : 0;
2353 if (filesize > ic->internal->data_offset) {
2354 filesize -= ic->internal->data_offset;
2355 for (i = 0; i < ic->nb_streams; i++) {
2356 st = ic->streams[i];
2357 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2358 && st->duration == AV_NOPTS_VALUE) {
2359 duration = av_rescale(8 * filesize, st->time_base.den,
2361 (int64_t) st->time_base.num);
2362 st->duration = duration;
2369 av_log(ic, AV_LOG_WARNING,
2370 "Estimating duration from bitrate, this may be inaccurate\n");
2373 #define DURATION_MAX_READ_SIZE 250000LL
2374 #define DURATION_MAX_RETRY 4
2376 /* only usable for MPEG-PS streams */
2377 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2379 AVPacket pkt1, *pkt = &pkt1;
2381 int num, den, read_size, i, ret;
2382 int found_duration = 0;
2384 int64_t filesize, offset, duration;
2387 /* flush packet queue */
2388 flush_packet_queue(ic);
2390 for (i = 0; i < ic->nb_streams; i++) {
2391 st = ic->streams[i];
2392 if (st->start_time == AV_NOPTS_VALUE &&
2393 st->first_dts == AV_NOPTS_VALUE &&
2394 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2395 av_log(st->codec, AV_LOG_WARNING,
2396 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2399 av_parser_close(st->parser);
2404 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2405 /* estimate the end time (duration) */
2406 /* XXX: may need to support wrapping */
2407 filesize = ic->pb ? avio_size(ic->pb) : 0;
2409 is_end = found_duration;
2410 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2414 avio_seek(ic->pb, offset, SEEK_SET);
2417 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2421 ret = ff_read_packet(ic, pkt);
2422 } while (ret == AVERROR(EAGAIN));
2425 read_size += pkt->size;
2426 st = ic->streams[pkt->stream_index];
2427 if (pkt->pts != AV_NOPTS_VALUE &&
2428 (st->start_time != AV_NOPTS_VALUE ||
2429 st->first_dts != AV_NOPTS_VALUE)) {
2430 if (pkt->duration == 0) {
2431 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2433 pkt->duration = av_rescale_rnd(1,
2434 num * (int64_t) st->time_base.den,
2435 den * (int64_t) st->time_base.num,
2439 duration = pkt->pts + pkt->duration;
2441 if (st->start_time != AV_NOPTS_VALUE)
2442 duration -= st->start_time;
2444 duration -= st->first_dts;
2446 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2447 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2448 st->duration = duration;
2449 st->info->last_duration = duration;
2452 av_free_packet(pkt);
2455 /* check if all audio/video streams have valid duration */
2458 for (i = 0; i < ic->nb_streams; i++) {
2459 st = ic->streams[i];
2460 switch (st->codec->codec_type) {
2461 case AVMEDIA_TYPE_VIDEO:
2462 case AVMEDIA_TYPE_AUDIO:
2463 if (st->duration == AV_NOPTS_VALUE)
2470 ++retry <= DURATION_MAX_RETRY);
2472 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2474 /* warn about audio/video streams which duration could not be estimated */
2475 for (i = 0; i < ic->nb_streams; i++) {
2476 st = ic->streams[i];
2477 if (st->duration == AV_NOPTS_VALUE) {
2478 switch (st->codec->codec_type) {
2479 case AVMEDIA_TYPE_VIDEO:
2480 case AVMEDIA_TYPE_AUDIO:
2481 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2482 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2484 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2488 fill_all_stream_timings(ic);
2490 avio_seek(ic->pb, old_offset, SEEK_SET);
2491 for (i = 0; i < ic->nb_streams; i++) {
2494 st = ic->streams[i];
2495 st->cur_dts = st->first_dts;
2496 st->last_IP_pts = AV_NOPTS_VALUE;
2497 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2498 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2499 st->pts_buffer[j] = AV_NOPTS_VALUE;
2503 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2507 /* get the file size, if possible */
2508 if (ic->iformat->flags & AVFMT_NOFILE) {
2511 file_size = avio_size(ic->pb);
2512 file_size = FFMAX(0, file_size);
2515 if ((!strcmp(ic->iformat->name, "mpeg") ||
2516 !strcmp(ic->iformat->name, "mpegts")) &&
2517 file_size && ic->pb->seekable) {
2518 /* get accurate estimate from the PTSes */
2519 estimate_timings_from_pts(ic, old_offset);
2520 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2521 } else if (has_duration(ic)) {
2522 /* at least one component has timings - we use them for all
2524 fill_all_stream_timings(ic);
2525 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2527 /* less precise: use bitrate info */
2528 estimate_timings_from_bit_rate(ic);
2529 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2531 update_stream_timings(ic);
2535 AVStream av_unused *st;
2536 for (i = 0; i < ic->nb_streams; i++) {
2537 st = ic->streams[i];
2538 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2539 (double) st->start_time / AV_TIME_BASE,
2540 (double) st->duration / AV_TIME_BASE);
2543 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2544 (double) ic->start_time / AV_TIME_BASE,
2545 (double) ic->duration / AV_TIME_BASE,
2546 ic->bit_rate / 1000);
2550 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2552 AVCodecContext *avctx = st->codec;
2554 #define FAIL(errmsg) do { \
2556 *errmsg_ptr = errmsg; \
2560 if ( avctx->codec_id == AV_CODEC_ID_NONE
2561 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2562 FAIL("unknown codec");
2563 switch (avctx->codec_type) {
2564 case AVMEDIA_TYPE_AUDIO:
2565 if (!avctx->frame_size && determinable_frame_size(avctx))
2566 FAIL("unspecified frame size");
2567 if (st->info->found_decoder >= 0 &&
2568 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2569 FAIL("unspecified sample format");
2570 if (!avctx->sample_rate)
2571 FAIL("unspecified sample rate");
2572 if (!avctx->channels)
2573 FAIL("unspecified number of channels");
2574 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2575 FAIL("no decodable DTS frames");
2577 case AVMEDIA_TYPE_VIDEO:
2579 FAIL("unspecified size");
2580 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2581 FAIL("unspecified pixel format");
2582 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2583 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2584 FAIL("no frame in rv30/40 and no sar");
2586 case AVMEDIA_TYPE_SUBTITLE:
2587 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2588 FAIL("unspecified size");
2590 case AVMEDIA_TYPE_DATA:
2591 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2597 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2598 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2599 AVDictionary **options)
2601 const AVCodec *codec;
2602 int got_picture = 1, ret = 0;
2603 AVFrame *frame = av_frame_alloc();
2604 AVSubtitle subtitle;
2605 AVPacket pkt = *avpkt;
2608 return AVERROR(ENOMEM);
2610 if (!avcodec_is_open(st->codec) &&
2611 st->info->found_decoder <= 0 &&
2612 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2613 AVDictionary *thread_opt = NULL;
2615 codec = find_decoder(s, st, st->codec->codec_id);
2618 st->info->found_decoder = -st->codec->codec_id;
2623 /* Force thread count to 1 since the H.264 decoder will not extract
2624 * SPS and PPS to extradata during multi-threaded decoding. */
2625 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2626 if (s->codec_whitelist)
2627 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2628 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2630 av_dict_free(&thread_opt);
2632 st->info->found_decoder = -st->codec->codec_id;
2635 st->info->found_decoder = 1;
2636 } else if (!st->info->found_decoder)
2637 st->info->found_decoder = 1;
2639 if (st->info->found_decoder < 0) {
2644 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2646 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2647 (!st->codec_info_nb_frames &&
2648 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2650 switch (st->codec->codec_type) {
2651 case AVMEDIA_TYPE_VIDEO:
2652 ret = avcodec_decode_video2(st->codec, frame,
2653 &got_picture, &pkt);
2655 case AVMEDIA_TYPE_AUDIO:
2656 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2658 case AVMEDIA_TYPE_SUBTITLE:
2659 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2660 &got_picture, &pkt);
2668 st->nb_decoded_frames++;
2675 if (!pkt.data && !got_picture)
2679 av_frame_free(&frame);
2683 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2685 while (tags->id != AV_CODEC_ID_NONE) {
2693 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2696 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2697 if (tag == tags[i].tag)
2699 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2700 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2702 return AV_CODEC_ID_NONE;
2705 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2710 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2712 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2714 return AV_CODEC_ID_NONE;
2719 if (sflags & (1 << (bps - 1))) {
2722 return AV_CODEC_ID_PCM_S8;
2724 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2726 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2728 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2730 return AV_CODEC_ID_NONE;
2735 return AV_CODEC_ID_PCM_U8;
2737 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2739 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2741 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2743 return AV_CODEC_ID_NONE;
2749 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2752 if (!av_codec_get_tag2(tags, id, &tag))
2757 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2761 for (i = 0; tags && tags[i]; i++) {
2762 const AVCodecTag *codec_tags = tags[i];
2763 while (codec_tags->id != AV_CODEC_ID_NONE) {
2764 if (codec_tags->id == id) {
2765 *tag = codec_tags->tag;
2774 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2777 for (i = 0; tags && tags[i]; i++) {
2778 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2779 if (id != AV_CODEC_ID_NONE)
2782 return AV_CODEC_ID_NONE;
2785 static void compute_chapters_end(AVFormatContext *s)
2788 int64_t max_time = s->duration +
2789 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2791 for (i = 0; i < s->nb_chapters; i++)
2792 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2793 AVChapter *ch = s->chapters[i];
2794 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2798 for (j = 0; j < s->nb_chapters; j++) {
2799 AVChapter *ch1 = s->chapters[j];
2800 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2802 if (j != i && next_start > ch->start && next_start < end)
2805 ch->end = (end == INT64_MAX) ? ch->start : end;
2809 static int get_std_framerate(int i)
2812 return (i + 1) * 1001;
2816 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2820 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2823 /* Is the time base unreliable?
2824 * This is a heuristic to balance between quick acceptance of the values in
2825 * the headers vs. some extra checks.
2826 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2827 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2828 * And there are "variable" fps files this needs to detect as well. */
2829 static int tb_unreliable(AVCodecContext *c)
2831 if (c->time_base.den >= 101LL * c->time_base.num ||
2832 c->time_base.den < 5LL * c->time_base.num ||
2833 // c->codec_tag == AV_RL32("DIVX") ||
2834 // c->codec_tag == AV_RL32("XVID") ||
2835 c->codec_tag == AV_RL32("mp4v") ||
2836 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2837 c->codec_id == AV_CODEC_ID_GIF ||
2838 c->codec_id == AV_CODEC_ID_H264)
2843 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2847 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2848 avctx->extradata = NULL;
2849 avctx->extradata_size = 0;
2850 return AVERROR(EINVAL);
2852 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2853 if (avctx->extradata) {
2854 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2855 avctx->extradata_size = size;
2858 avctx->extradata_size = 0;
2859 ret = AVERROR(ENOMEM);
2864 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2866 int ret = ff_alloc_extradata(avctx, size);
2869 ret = avio_read(pb, avctx->extradata, size);
2871 av_freep(&avctx->extradata);
2872 avctx->extradata_size = 0;
2873 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2874 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2880 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2883 int64_t last = st->info->last_dts;
2885 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2886 && ts - (uint64_t)last < INT64_MAX) {
2887 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2888 int64_t duration = ts - last;
2890 if (!st->info->duration_error)
2891 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2892 if (!st->info->duration_error)
2893 return AVERROR(ENOMEM);
2895 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2896 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2897 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2898 if (st->info->duration_error[0][1][i] < 1e10) {
2899 int framerate = get_std_framerate(i);
2900 double sdts = dts*framerate/(1001*12);
2901 for (j= 0; j<2; j++) {
2902 int64_t ticks = llrint(sdts+j*0.5);
2903 double error= sdts - ticks + j*0.5;
2904 st->info->duration_error[j][0][i] += error;
2905 st->info->duration_error[j][1][i] += error*error;
2909 st->info->duration_count++;
2910 st->info->rfps_duration_sum += duration;
2912 if (st->info->duration_count % 10 == 0) {
2913 int n = st->info->duration_count;
2914 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2915 if (st->info->duration_error[0][1][i] < 1e10) {
2916 double a0 = st->info->duration_error[0][0][i] / n;
2917 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2918 double a1 = st->info->duration_error[1][0][i] / n;
2919 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2920 if (error0 > 0.04 && error1 > 0.04) {
2921 st->info->duration_error[0][1][i] = 2e10;
2922 st->info->duration_error[1][1][i] = 2e10;
2928 // ignore the first 4 values, they might have some random jitter
2929 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2930 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2932 if (ts != AV_NOPTS_VALUE)
2933 st->info->last_dts = ts;
2938 void ff_rfps_calculate(AVFormatContext *ic)
2942 for (i = 0; i < ic->nb_streams; i++) {
2943 AVStream *st = ic->streams[i];
2945 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2947 // the check for tb_unreliable() is not completely correct, since this is not about handling
2948 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2949 // ipmovie.c produces.
2950 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)
2951 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);
2952 if (st->info->duration_count>1 && !st->r_frame_rate.num
2953 && tb_unreliable(st->codec)) {
2955 double best_error= 0.01;
2956 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2958 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2961 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2963 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2966 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2969 for (k= 0; k<2; k++) {
2970 int n = st->info->duration_count;
2971 double a= st->info->duration_error[k][0][j] / n;
2972 double error= st->info->duration_error[k][1][j]/n - a*a;
2974 if (error < best_error && best_error> 0.000000001) {
2976 num = get_std_framerate(j);
2979 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2982 // do not increase frame rate by more than 1 % in order to match a standard rate.
2983 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2984 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2986 if ( !st->avg_frame_rate.num
2987 && st->r_frame_rate.num && st->info->rfps_duration_sum
2988 && st->info->codec_info_duration <= 0
2989 && st->info->duration_count > 2
2990 && 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
2992 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2993 st->avg_frame_rate = st->r_frame_rate;
2996 av_freep(&st->info->duration_error);
2997 st->info->last_dts = AV_NOPTS_VALUE;
2998 st->info->duration_count = 0;
2999 st->info->rfps_duration_sum = 0;
3003 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3005 int i, count, ret = 0, j;
3008 AVPacket pkt1, *pkt;
3009 int64_t old_offset = avio_tell(ic->pb);
3010 // new streams might appear, no options for those
3011 int orig_nb_streams = ic->nb_streams;
3013 int64_t max_analyze_duration = ic->max_analyze_duration2;
3014 int64_t max_stream_analyze_duration;
3015 int64_t probesize = ic->probesize2;
3017 if (!max_analyze_duration)
3018 max_analyze_duration = ic->max_analyze_duration;
3020 probesize = ic->probesize;
3021 flush_codecs = probesize > 0;
3023 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3025 max_stream_analyze_duration = max_analyze_duration;
3026 if (!max_analyze_duration) {
3027 max_stream_analyze_duration =
3028 max_analyze_duration = 5*AV_TIME_BASE;
3029 if (!strcmp(ic->iformat->name, "flv"))
3030 max_stream_analyze_duration = 30*AV_TIME_BASE;
3034 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3035 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3037 for (i = 0; i < ic->nb_streams; i++) {
3038 const AVCodec *codec;
3039 AVDictionary *thread_opt = NULL;
3040 st = ic->streams[i];
3042 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3043 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3044 /* if (!st->time_base.num)
3046 if (!st->codec->time_base.num)
3047 st->codec->time_base = st->time_base;
3049 // only for the split stuff
3050 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3051 st->parser = av_parser_init(st->codec->codec_id);
3053 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3054 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3055 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3056 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3058 } else if (st->need_parsing) {
3059 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3060 "%s, packets or times may be invalid.\n",
3061 avcodec_get_name(st->codec->codec_id));
3064 codec = find_decoder(ic, st, st->codec->codec_id);
3066 /* Force thread count to 1 since the H.264 decoder will not extract
3067 * SPS and PPS to extradata during multi-threaded decoding. */
3068 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3070 if (ic->codec_whitelist)
3071 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3073 /* Ensure that subtitle_header is properly set. */
3074 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3075 && codec && !st->codec->codec) {
3076 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3077 av_log(ic, AV_LOG_WARNING,
3078 "Failed to open codec in av_find_stream_info\n");
3081 // Try to just open decoders, in case this is enough to get parameters.
3082 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3083 if (codec && !st->codec->codec)
3084 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3085 av_log(ic, AV_LOG_WARNING,
3086 "Failed to open codec in av_find_stream_info\n");
3089 av_dict_free(&thread_opt);
3092 for (i = 0; i < ic->nb_streams; i++) {
3093 #if FF_API_R_FRAME_RATE
3094 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3096 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3097 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3103 int analyzed_all_streams;
3104 if (ff_check_interrupt(&ic->interrupt_callback)) {
3106 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3110 /* check if one codec still needs to be handled */
3111 for (i = 0; i < ic->nb_streams; i++) {
3112 int fps_analyze_framecount = 20;
3114 st = ic->streams[i];
3115 if (!has_codec_parameters(st, NULL))
3117 /* If the timebase is coarse (like the usual millisecond precision
3118 * of mkv), we need to analyze more frames to reliably arrive at
3119 * the correct fps. */
3120 if (av_q2d(st->time_base) > 0.0005)
3121 fps_analyze_framecount *= 2;
3122 if (!tb_unreliable(st->codec))
3123 fps_analyze_framecount = 0;
3124 if (ic->fps_probe_size >= 0)
3125 fps_analyze_framecount = ic->fps_probe_size;
3126 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3127 fps_analyze_framecount = 0;
3128 /* variable fps and no guess at the real fps */
3129 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3130 st->info->duration_count < fps_analyze_framecount &&
3131 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3133 if (st->parser && st->parser->parser->split &&
3134 !st->codec->extradata)
3136 if (st->first_dts == AV_NOPTS_VALUE &&
3137 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3138 st->codec_info_nb_frames < ic->max_ts_probe &&
3139 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3140 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3143 analyzed_all_streams = 0;
3144 if (i == ic->nb_streams) {
3145 analyzed_all_streams = 1;
3146 /* NOTE: If the format has no header, then we need to read some
3147 * packets to get most of the streams, so we cannot stop here. */
3148 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3149 /* If we found the info for all the codecs, we can stop. */
3151 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3156 /* We did not get all the codec info, but we read too much data. */
3157 if (read_size >= probesize) {
3159 av_log(ic, AV_LOG_DEBUG,
3160 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3161 for (i = 0; i < ic->nb_streams; i++)
3162 if (!ic->streams[i]->r_frame_rate.num &&
3163 ic->streams[i]->info->duration_count <= 1 &&
3164 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3165 strcmp(ic->iformat->name, "image2"))
3166 av_log(ic, AV_LOG_WARNING,
3167 "Stream #%d: not enough frames to estimate rate; "
3168 "consider increasing probesize\n", i);
3172 /* NOTE: A new stream can be added there if no header in file
3173 * (AVFMTCTX_NOHEADER). */
3174 ret = read_frame_internal(ic, &pkt1);
3175 if (ret == AVERROR(EAGAIN))
3183 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3184 free_packet_buffer(&ic->internal->packet_buffer,
3185 &ic->internal->packet_buffer_end);
3187 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3188 &ic->internal->packet_buffer_end);
3190 ret = AVERROR(ENOMEM);
3191 goto find_stream_info_err;
3193 if ((ret = av_dup_packet(pkt)) < 0)
3194 goto find_stream_info_err;
3197 st = ic->streams[pkt->stream_index];
3198 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3199 read_size += pkt->size;
3201 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3202 /* check for non-increasing dts */
3203 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3204 st->info->fps_last_dts >= pkt->dts) {
3205 av_log(ic, AV_LOG_DEBUG,
3206 "Non-increasing DTS in stream %d: packet %d with DTS "
3207 "%"PRId64", packet %d with DTS %"PRId64"\n",
3208 st->index, st->info->fps_last_dts_idx,
3209 st->info->fps_last_dts, st->codec_info_nb_frames,
3211 st->info->fps_first_dts =
3212 st->info->fps_last_dts = AV_NOPTS_VALUE;
3214 /* Check for a discontinuity in dts. If the difference in dts
3215 * is more than 1000 times the average packet duration in the
3216 * sequence, we treat it as a discontinuity. */
3217 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3218 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3219 (pkt->dts - st->info->fps_last_dts) / 1000 >
3220 (st->info->fps_last_dts - st->info->fps_first_dts) /
3221 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3222 av_log(ic, AV_LOG_WARNING,
3223 "DTS discontinuity in stream %d: packet %d with DTS "
3224 "%"PRId64", packet %d with DTS %"PRId64"\n",
3225 st->index, st->info->fps_last_dts_idx,
3226 st->info->fps_last_dts, st->codec_info_nb_frames,
3228 st->info->fps_first_dts =
3229 st->info->fps_last_dts = AV_NOPTS_VALUE;
3232 /* update stored dts values */
3233 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3234 st->info->fps_first_dts = pkt->dts;
3235 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3237 st->info->fps_last_dts = pkt->dts;
3238 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3240 if (st->codec_info_nb_frames>1) {
3243 if (st->time_base.den > 0)
3244 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3245 if (st->avg_frame_rate.num > 0)
3246 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3249 && st->codec_info_nb_frames>30
3250 && st->info->fps_first_dts != AV_NOPTS_VALUE
3251 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3252 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3254 if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3255 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3256 max_analyze_duration,
3258 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3259 av_packet_unref(pkt);
3262 if (pkt->duration) {
3263 st->info->codec_info_duration += pkt->duration;
3264 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3267 #if FF_API_R_FRAME_RATE
3268 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3269 ff_rfps_add_frame(ic, st, pkt->dts);
3271 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3272 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3273 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3274 if (ff_alloc_extradata(st->codec, i))
3275 return AVERROR(ENOMEM);
3276 memcpy(st->codec->extradata, pkt->data,
3277 st->codec->extradata_size);
3281 /* If still no information, we try to open the codec and to
3282 * decompress the frame. We try to avoid that in most cases as
3283 * it takes longer and uses more memory. For MPEG-4, we need to
3284 * decompress for QuickTime.
3286 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3287 * least one frame of codec data, this makes sure the codec initializes
3288 * the channel configuration and does not only trust the values from
3290 try_decode_frame(ic, st, pkt,
3291 (options && i < orig_nb_streams) ? &options[i] : NULL);
3293 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3294 av_packet_unref(pkt);
3296 st->codec_info_nb_frames++;
3301 AVPacket empty_pkt = { 0 };
3303 av_init_packet(&empty_pkt);
3305 for (i = 0; i < ic->nb_streams; i++) {
3307 st = ic->streams[i];
3309 /* flush the decoders */
3310 if (st->info->found_decoder == 1) {
3312 err = try_decode_frame(ic, st, &empty_pkt,
3313 (options && i < orig_nb_streams)
3314 ? &options[i] : NULL);
3315 } while (err > 0 && !has_codec_parameters(st, NULL));
3318 av_log(ic, AV_LOG_INFO,
3319 "decoding for stream %d failed\n", st->index);
3325 // close codecs which were opened in try_decode_frame()
3326 for (i = 0; i < ic->nb_streams; i++) {
3327 st = ic->streams[i];
3328 avcodec_close(st->codec);
3331 ff_rfps_calculate(ic);
3333 for (i = 0; i < ic->nb_streams; i++) {
3334 st = ic->streams[i];
3335 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3336 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3337 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3338 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3339 st->codec->codec_tag= tag;
3342 /* estimate average framerate if not set by demuxer */
3343 if (st->info->codec_info_duration_fields &&
3344 !st->avg_frame_rate.num &&
3345 st->info->codec_info_duration) {
3347 double best_error = 0.01;
3349 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3350 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3351 st->info->codec_info_duration < 0)
3353 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3354 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3355 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3357 /* Round guessed framerate to a "standard" framerate if it's
3358 * within 1% of the original estimate. */
3359 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3360 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3361 double error = fabs(av_q2d(st->avg_frame_rate) /
3362 av_q2d(std_fps) - 1);
3364 if (error < best_error) {
3366 best_fps = std_fps.num;
3370 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3371 best_fps, 12 * 1001, INT_MAX);
3374 if (!st->r_frame_rate.num) {
3375 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3376 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3377 st->r_frame_rate.num = st->codec->time_base.den;
3378 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3380 st->r_frame_rate.num = st->time_base.den;
3381 st->r_frame_rate.den = st->time_base.num;
3384 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3385 AVRational hw_ratio = { st->codec->height, st->codec->width };
3386 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3389 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3390 if (!st->codec->bits_per_coded_sample)
3391 st->codec->bits_per_coded_sample =
3392 av_get_bits_per_sample(st->codec->codec_id);
3393 // set stream disposition based on audio service type
3394 switch (st->codec->audio_service_type) {
3395 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3396 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3398 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3399 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3401 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3402 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3404 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3405 st->disposition = AV_DISPOSITION_COMMENT;
3407 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3408 st->disposition = AV_DISPOSITION_KARAOKE;
3415 estimate_timings(ic, old_offset);
3417 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3419 if (ret >= 0 && ic->nb_streams)
3420 /* We could not have all the codec parameters before EOF. */
3422 for (i = 0; i < ic->nb_streams; i++) {
3424 st = ic->streams[i];
3425 if (!has_codec_parameters(st, &errmsg)) {
3427 avcodec_string(buf, sizeof(buf), st->codec, 0);
3428 av_log(ic, AV_LOG_WARNING,
3429 "Could not find codec parameters for stream %d (%s): %s\n"
3430 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3437 compute_chapters_end(ic);
3439 find_stream_info_err:
3440 for (i = 0; i < ic->nb_streams; i++) {
3441 st = ic->streams[i];
3442 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3443 ic->streams[i]->codec->thread_count = 0;
3445 av_freep(&st->info->duration_error);
3446 av_freep(&ic->streams[i]->info);
3449 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3450 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3454 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3458 for (i = 0; i < ic->nb_programs; i++) {
3459 if (ic->programs[i] == last) {
3463 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3464 if (ic->programs[i]->stream_index[j] == s)
3465 return ic->programs[i];
3471 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3472 int wanted_stream_nb, int related_stream,
3473 AVCodec **decoder_ret, int flags)
3475 int i, nb_streams = ic->nb_streams;
3476 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3477 unsigned *program = NULL;
3478 const AVCodec *decoder = NULL, *best_decoder = NULL;
3480 if (related_stream >= 0 && wanted_stream_nb < 0) {
3481 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3483 program = p->stream_index;
3484 nb_streams = p->nb_stream_indexes;
3487 for (i = 0; i < nb_streams; i++) {
3488 int real_stream_index = program ? program[i] : i;
3489 AVStream *st = ic->streams[real_stream_index];
3490 AVCodecContext *avctx = st->codec;
3491 if (avctx->codec_type != type)
3493 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3495 if (wanted_stream_nb != real_stream_index &&
3496 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3497 AV_DISPOSITION_VISUAL_IMPAIRED))
3499 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3502 decoder = find_decoder(ic, st, st->codec->codec_id);
3505 ret = AVERROR_DECODER_NOT_FOUND;
3509 count = st->codec_info_nb_frames;
3510 bitrate = avctx->bit_rate;
3512 bitrate = avctx->rc_max_rate;
3513 multiframe = FFMIN(5, count);
3514 if ((best_multiframe > multiframe) ||
3515 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3516 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3519 best_bitrate = bitrate;
3520 best_multiframe = multiframe;
3521 ret = real_stream_index;
3522 best_decoder = decoder;
3523 if (program && i == nb_streams - 1 && ret < 0) {
3525 nb_streams = ic->nb_streams;
3526 /* no related stream found, try again with everything */
3531 *decoder_ret = (AVCodec*)best_decoder;
3535 /*******************************************************/
3537 int av_read_play(AVFormatContext *s)
3539 if (s->iformat->read_play)
3540 return s->iformat->read_play(s);
3542 return avio_pause(s->pb, 0);
3543 return AVERROR(ENOSYS);
3546 int av_read_pause(AVFormatContext *s)
3548 if (s->iformat->read_pause)
3549 return s->iformat->read_pause(s);
3551 return avio_pause(s->pb, 1);
3552 return AVERROR(ENOSYS);
3555 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3557 av_assert0(s->nb_streams>0);
3558 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3560 for (j = 0; j < st->nb_side_data; j++)
3561 av_freep(&st->side_data[j].data);
3562 av_freep(&st->side_data);
3563 st->nb_side_data = 0;
3566 av_parser_close(st->parser);
3568 if (st->attached_pic.data)
3569 av_free_packet(&st->attached_pic);
3570 av_dict_free(&st->metadata);
3571 av_freep(&st->probe_data.buf);
3572 av_freep(&st->index_entries);
3573 av_freep(&st->codec->extradata);
3574 av_freep(&st->codec->subtitle_header);
3575 av_freep(&st->codec);
3576 av_freep(&st->priv_data);
3578 av_freep(&st->info->duration_error);
3579 av_freep(&st->info);
3580 av_freep(&st->recommended_encoder_configuration);
3581 av_freep(&s->streams[ --s->nb_streams ]);
3584 void avformat_free_context(AVFormatContext *s)
3592 if (s->iformat && s->iformat->priv_class && s->priv_data)
3593 av_opt_free(s->priv_data);
3594 if (s->oformat && s->oformat->priv_class && s->priv_data)
3595 av_opt_free(s->priv_data);
3597 for (i = s->nb_streams - 1; i >= 0; i--) {
3598 ff_free_stream(s, s->streams[i]);
3600 for (i = s->nb_programs - 1; i >= 0; i--) {
3601 av_dict_free(&s->programs[i]->metadata);
3602 av_freep(&s->programs[i]->stream_index);
3603 av_freep(&s->programs[i]);
3605 av_freep(&s->programs);
3606 av_freep(&s->priv_data);
3607 while (s->nb_chapters--) {
3608 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3609 av_freep(&s->chapters[s->nb_chapters]);
3611 av_freep(&s->chapters);
3612 av_dict_free(&s->metadata);
3613 av_freep(&s->streams);
3614 av_freep(&s->internal);
3615 flush_packet_queue(s);
3619 void avformat_close_input(AVFormatContext **ps)
3630 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3631 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3634 flush_packet_queue(s);
3637 if (s->iformat->read_close)
3638 s->iformat->read_close(s);
3640 avformat_free_context(s);
3647 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3653 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3655 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3658 s->streams = streams;
3660 st = av_mallocz(sizeof(AVStream));
3663 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3667 st->info->last_dts = AV_NOPTS_VALUE;
3669 st->codec = avcodec_alloc_context3(c);
3676 /* no default bitrate if decoding */
3677 st->codec->bit_rate = 0;
3679 /* default pts setting is MPEG-like */
3680 avpriv_set_pts_info(st, 33, 1, 90000);
3683 st->index = s->nb_streams;
3684 st->start_time = AV_NOPTS_VALUE;
3685 st->duration = AV_NOPTS_VALUE;
3686 /* we set the current DTS to 0 so that formats without any timestamps
3687 * but durations get some timestamps, formats with some unknown
3688 * timestamps have their first few packets buffered and the
3689 * timestamps corrected before they are returned to the user */
3690 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3691 st->first_dts = AV_NOPTS_VALUE;
3692 st->probe_packets = MAX_PROBE_PACKETS;
3693 st->pts_wrap_reference = AV_NOPTS_VALUE;
3694 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3696 st->last_IP_pts = AV_NOPTS_VALUE;
3697 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3698 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3699 st->pts_buffer[i] = AV_NOPTS_VALUE;
3701 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3703 #if FF_API_R_FRAME_RATE
3704 st->info->last_dts = AV_NOPTS_VALUE;
3706 st->info->fps_first_dts = AV_NOPTS_VALUE;
3707 st->info->fps_last_dts = AV_NOPTS_VALUE;
3709 st->inject_global_side_data = s->internal->inject_global_side_data;
3711 s->streams[s->nb_streams++] = st;
3715 AVProgram *av_new_program(AVFormatContext *ac, int id)
3717 AVProgram *program = NULL;
3720 av_dlog(ac, "new_program: id=0x%04x\n", id);
3722 for (i = 0; i < ac->nb_programs; i++)
3723 if (ac->programs[i]->id == id)
3724 program = ac->programs[i];
3727 program = av_mallocz(sizeof(AVProgram));
3730 dynarray_add(&ac->programs, &ac->nb_programs, program);
3731 program->discard = AVDISCARD_NONE;
3734 program->pts_wrap_reference = AV_NOPTS_VALUE;
3735 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3737 program->start_time =
3738 program->end_time = AV_NOPTS_VALUE;
3743 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3744 int64_t start, int64_t end, const char *title)
3746 AVChapter *chapter = NULL;
3749 if (end != AV_NOPTS_VALUE && start > end) {
3750 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3754 for (i = 0; i < s->nb_chapters; i++)
3755 if (s->chapters[i]->id == id)
3756 chapter = s->chapters[i];
3759 chapter = av_mallocz(sizeof(AVChapter));
3762 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3764 av_dict_set(&chapter->metadata, "title", title, 0);
3766 chapter->time_base = time_base;
3767 chapter->start = start;
3773 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3776 AVProgram *program = NULL;
3779 if (idx >= ac->nb_streams) {
3780 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3784 for (i = 0; i < ac->nb_programs; i++) {
3785 if (ac->programs[i]->id != progid)
3787 program = ac->programs[i];
3788 for (j = 0; j < program->nb_stream_indexes; j++)
3789 if (program->stream_index[j] == idx)
3792 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3795 program->stream_index = tmp;
3796 program->stream_index[program->nb_stream_indexes++] = idx;
3801 uint64_t ff_ntp_time(void)
3803 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3806 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3809 char *q, buf1[20], c;
3810 int nd, len, percentd_found;
3822 while (av_isdigit(*p))
3823 nd = nd * 10 + *p++ - '0';
3825 } while (av_isdigit(c));
3836 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3838 if ((q - buf + len) > buf_size - 1)
3840 memcpy(q, buf1, len);
3848 if ((q - buf) < buf_size - 1)
3852 if (!percentd_found)
3861 void av_url_split(char *proto, int proto_size,
3862 char *authorization, int authorization_size,
3863 char *hostname, int hostname_size,
3864 int *port_ptr, char *path, int path_size, const char *url)
3866 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3872 if (authorization_size > 0)
3873 authorization[0] = 0;
3874 if (hostname_size > 0)
3879 /* parse protocol */
3880 if ((p = strchr(url, ':'))) {
3881 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3888 /* no protocol means plain filename */
3889 av_strlcpy(path, url, path_size);
3893 /* separate path from hostname */
3894 ls = strchr(p, '/');
3895 ls2 = strchr(p, '?');
3899 ls = FFMIN(ls, ls2);
3901 av_strlcpy(path, ls, path_size);
3903 ls = &p[strlen(p)]; // XXX
3905 /* the rest is hostname, use that to parse auth/port */
3907 /* authorization (user[:pass]@hostname) */
3909 while ((at = strchr(p, '@')) && at < ls) {
3910 av_strlcpy(authorization, at2,
3911 FFMIN(authorization_size, at + 1 - at2));
3912 p = at + 1; /* skip '@' */
3915 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3917 av_strlcpy(hostname, p + 1,
3918 FFMIN(hostname_size, brk - p));
3919 if (brk[1] == ':' && port_ptr)
3920 *port_ptr = atoi(brk + 2);
3921 } else if ((col = strchr(p, ':')) && col < ls) {
3922 av_strlcpy(hostname, p,
3923 FFMIN(col + 1 - p, hostname_size));
3925 *port_ptr = atoi(col + 1);
3927 av_strlcpy(hostname, p,
3928 FFMIN(ls + 1 - p, hostname_size));
3932 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3935 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3938 'C', 'D', 'E', 'F' };
3939 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3942 'c', 'd', 'e', 'f' };
3943 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3945 for (i = 0; i < s; i++) {
3946 buff[i * 2] = hex_table[src[i] >> 4];
3947 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3953 int ff_hex_to_data(uint8_t *data, const char *p)
3960 p += strspn(p, SPACE_CHARS);
3963 c = av_toupper((unsigned char) *p++);
3964 if (c >= '0' && c <= '9')
3966 else if (c >= 'A' && c <= 'F')
3981 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3982 unsigned int pts_num, unsigned int pts_den)
3985 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3986 if (new_tb.num != pts_num)
3987 av_log(NULL, AV_LOG_DEBUG,
3988 "st:%d removing common factor %d from timebase\n",
3989 s->index, pts_num / new_tb.num);
3991 av_log(NULL, AV_LOG_WARNING,
3992 "st:%d has too large timebase, reducing\n", s->index);
3994 if (new_tb.num <= 0 || new_tb.den <= 0) {
3995 av_log(NULL, AV_LOG_ERROR,
3996 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3997 new_tb.num, new_tb.den,
4001 s->time_base = new_tb;
4002 av_codec_set_pkt_timebase(s->codec, new_tb);
4003 s->pts_wrap_bits = pts_wrap_bits;
4006 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4009 const char *ptr = str;
4011 /* Parse key=value pairs. */
4014 char *dest = NULL, *dest_end;
4015 int key_len, dest_len = 0;
4017 /* Skip whitespace and potential commas. */
4018 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4025 if (!(ptr = strchr(key, '=')))
4028 key_len = ptr - key;
4030 callback_get_buf(context, key, key_len, &dest, &dest_len);
4031 dest_end = dest + dest_len - 1;
4035 while (*ptr && *ptr != '\"') {
4039 if (dest && dest < dest_end)
4043 if (dest && dest < dest_end)
4051 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4052 if (dest && dest < dest_end)
4060 int ff_find_stream_index(AVFormatContext *s, int id)
4063 for (i = 0; i < s->nb_streams; i++)
4064 if (s->streams[i]->id == id)
4069 int64_t ff_iso8601_to_unix_time(const char *datestr)
4071 struct tm time1 = { 0 }, time2 = { 0 };
4073 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4074 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4076 return av_timegm(&time2);
4078 return av_timegm(&time1);
4081 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4085 if (ofmt->query_codec)
4086 return ofmt->query_codec(codec_id, std_compliance);
4087 else if (ofmt->codec_tag)
4088 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4089 else if (codec_id == ofmt->video_codec ||
4090 codec_id == ofmt->audio_codec ||
4091 codec_id == ofmt->subtitle_codec)
4094 return AVERROR_PATCHWELCOME;
4097 int avformat_network_init(void)
4101 ff_network_inited_globally = 1;
4102 if ((ret = ff_network_init()) < 0)
4104 if ((ret = ff_tls_init()) < 0)
4110 int avformat_network_deinit(void)
4119 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4120 uint64_t channel_layout, int32_t sample_rate,
4121 int32_t width, int32_t height)
4127 return AVERROR(EINVAL);
4130 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4132 if (channel_layout) {
4134 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4138 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4140 if (width || height) {
4142 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4144 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4146 return AVERROR(ENOMEM);
4147 bytestream_put_le32(&data, flags);
4149 bytestream_put_le32(&data, channels);
4151 bytestream_put_le64(&data, channel_layout);
4153 bytestream_put_le32(&data, sample_rate);
4154 if (width || height) {
4155 bytestream_put_le32(&data, width);
4156 bytestream_put_le32(&data, height);
4161 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4163 AVRational undef = {0, 1};
4164 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4165 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4166 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4168 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4169 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4170 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4171 stream_sample_aspect_ratio = undef;
4173 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4174 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4175 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4176 frame_sample_aspect_ratio = undef;
4178 if (stream_sample_aspect_ratio.num)
4179 return stream_sample_aspect_ratio;
4181 return frame_sample_aspect_ratio;
4184 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4186 AVRational fr = st->r_frame_rate;
4187 AVRational codec_fr = st->codec->framerate;
4188 AVRational avg_fr = st->avg_frame_rate;
4190 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4191 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4196 if (st->codec->ticks_per_frame > 1) {
4197 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4198 (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))
4205 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4208 if (*spec <= '9' && *spec >= '0') /* opt:index */
4209 return strtol(spec, NULL, 0) == st->index;
4210 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4211 *spec == 't') { /* opt:[vasdt] */
4212 enum AVMediaType type;
4215 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4216 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4217 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4218 case 'd': type = AVMEDIA_TYPE_DATA; break;
4219 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4220 default: av_assert0(0);
4222 if (type != st->codec->codec_type)
4224 if (*spec++ == ':') { /* possibly followed by :index */
4225 int i, index = strtol(spec, NULL, 0);
4226 for (i = 0; i < s->nb_streams; i++)
4227 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4228 return i == st->index;
4232 } else if (*spec == 'p' && *(spec + 1) == ':') {
4236 prog_id = strtol(spec, &endptr, 0);
4237 for (i = 0; i < s->nb_programs; i++) {
4238 if (s->programs[i]->id != prog_id)
4241 if (*endptr++ == ':') {
4242 int stream_idx = strtol(endptr, NULL, 0);
4243 return stream_idx >= 0 &&
4244 stream_idx < s->programs[i]->nb_stream_indexes &&
4245 st->index == s->programs[i]->stream_index[stream_idx];
4248 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4249 if (st->index == s->programs[i]->stream_index[j])
4253 } else if (*spec == '#' ||
4254 (*spec == 'i' && *(spec + 1) == ':')) {
4257 spec += 1 + (*spec == 'i');
4258 stream_id = strtol(spec, &endptr, 0);
4260 return stream_id == st->id;
4261 } else if (*spec == 'm' && *(spec + 1) == ':') {
4262 AVDictionaryEntry *tag;
4267 val = strchr(spec, ':');
4269 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4271 return AVERROR(ENOMEM);
4273 tag = av_dict_get(st->metadata, key, NULL, 0);
4275 if (!val || !strcmp(tag->value, val + 1))
4284 } else if (!*spec) /* empty specifier, matches everything */
4287 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4288 return AVERROR(EINVAL);
4291 int ff_generate_avci_extradata(AVStream *st)
4293 static const uint8_t avci100_1080p_extradata[] = {
4295 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4296 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4297 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4298 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4299 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4300 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4301 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4302 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4303 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4305 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4308 static const uint8_t avci100_1080i_extradata[] = {
4310 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4311 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4312 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4313 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4314 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4315 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4316 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4317 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4318 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4319 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4320 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4322 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4325 static const uint8_t avci50_1080p_extradata[] = {
4327 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4328 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4329 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4330 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4331 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4332 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4333 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4334 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4335 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4337 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4340 static const uint8_t avci50_1080i_extradata[] = {
4342 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4343 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4344 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4345 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4346 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4347 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4348 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4349 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4350 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4351 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4352 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4354 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4357 static const uint8_t avci100_720p_extradata[] = {
4359 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4360 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4361 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4362 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4363 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4364 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4365 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4366 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4367 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4368 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4370 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4373 static const uint8_t avci50_720p_extradata[] = {
4375 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4376 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4377 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4378 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4379 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4380 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4381 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4382 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4383 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4385 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4389 const uint8_t *data = NULL;
4392 if (st->codec->width == 1920) {
4393 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4394 data = avci100_1080p_extradata;
4395 size = sizeof(avci100_1080p_extradata);
4397 data = avci100_1080i_extradata;
4398 size = sizeof(avci100_1080i_extradata);
4400 } else if (st->codec->width == 1440) {
4401 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4402 data = avci50_1080p_extradata;
4403 size = sizeof(avci50_1080p_extradata);
4405 data = avci50_1080i_extradata;
4406 size = sizeof(avci50_1080i_extradata);
4408 } else if (st->codec->width == 1280) {
4409 data = avci100_720p_extradata;
4410 size = sizeof(avci100_720p_extradata);
4411 } else if (st->codec->width == 960) {
4412 data = avci50_720p_extradata;
4413 size = sizeof(avci50_720p_extradata);
4419 av_freep(&st->codec->extradata);
4420 if (ff_alloc_extradata(st->codec, size))
4421 return AVERROR(ENOMEM);
4422 memcpy(st->codec->extradata, data, size);
4427 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4432 for (i = 0; i < st->nb_side_data; i++) {
4433 if (st->side_data[i].type == type) {
4435 *size = st->side_data[i].size;
4436 return st->side_data[i].data;
4442 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4445 AVPacketSideData *sd, *tmp;
4447 uint8_t *data = av_malloc(size);
4452 for (i = 0; i < st->nb_side_data; i++) {
4453 sd = &st->side_data[i];
4455 if (sd->type == type) {
4456 av_freep(&sd->data);
4463 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4469 st->side_data = tmp;
4472 sd = &st->side_data[st->nb_side_data - 1];