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 int avformat_flush(AVFormatContext *s)
2206 ff_read_frame_flush(s);
2210 /*******************************************************/
2213 * Return TRUE if the stream has accurate duration in any stream.
2215 * @return TRUE if the stream has accurate duration for at least one component.
2217 static int has_duration(AVFormatContext *ic)
2222 for (i = 0; i < ic->nb_streams; i++) {
2223 st = ic->streams[i];
2224 if (st->duration != AV_NOPTS_VALUE)
2227 if (ic->duration != AV_NOPTS_VALUE)
2233 * Estimate the stream timings from the one of each components.
2235 * Also computes the global bitrate if possible.
2237 static void update_stream_timings(AVFormatContext *ic)
2239 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2240 int64_t duration, duration1, filesize;
2245 start_time = INT64_MAX;
2246 start_time_text = INT64_MAX;
2247 end_time = INT64_MIN;
2248 duration = INT64_MIN;
2249 for (i = 0; i < ic->nb_streams; i++) {
2250 st = ic->streams[i];
2251 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2252 start_time1 = av_rescale_q(st->start_time, st->time_base,
2254 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2255 if (start_time1 < start_time_text)
2256 start_time_text = start_time1;
2258 start_time = FFMIN(start_time, start_time1);
2259 end_time1 = AV_NOPTS_VALUE;
2260 if (st->duration != AV_NOPTS_VALUE) {
2261 end_time1 = start_time1 +
2262 av_rescale_q(st->duration, st->time_base,
2264 end_time = FFMAX(end_time, end_time1);
2266 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2267 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2268 p->start_time = start_time1;
2269 if (p->end_time < end_time1)
2270 p->end_time = end_time1;
2273 if (st->duration != AV_NOPTS_VALUE) {
2274 duration1 = av_rescale_q(st->duration, st->time_base,
2276 duration = FFMAX(duration, duration1);
2279 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2280 start_time = start_time_text;
2281 else if (start_time > start_time_text)
2282 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2284 if (start_time != INT64_MAX) {
2285 ic->start_time = start_time;
2286 if (end_time != INT64_MIN) {
2287 if (ic->nb_programs) {
2288 for (i = 0; i < ic->nb_programs; i++) {
2289 p = ic->programs[i];
2290 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2291 duration = FFMAX(duration, p->end_time - p->start_time);
2294 duration = FFMAX(duration, end_time - start_time);
2297 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2298 ic->duration = duration;
2300 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2301 /* compute the bitrate */
2302 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2303 (double) ic->duration;
2304 if (bitrate >= 0 && bitrate <= INT_MAX)
2305 ic->bit_rate = bitrate;
2309 static void fill_all_stream_timings(AVFormatContext *ic)
2314 update_stream_timings(ic);
2315 for (i = 0; i < ic->nb_streams; i++) {
2316 st = ic->streams[i];
2317 if (st->start_time == AV_NOPTS_VALUE) {
2318 if (ic->start_time != AV_NOPTS_VALUE)
2319 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2321 if (ic->duration != AV_NOPTS_VALUE)
2322 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2328 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2330 int64_t filesize, duration;
2331 int i, show_warning = 0;
2334 /* if bit_rate is already set, we believe it */
2335 if (ic->bit_rate <= 0) {
2337 for (i = 0; i < ic->nb_streams; i++) {
2338 st = ic->streams[i];
2339 if (st->codec->bit_rate > 0) {
2340 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2344 bit_rate += st->codec->bit_rate;
2345 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2346 // If we have a videostream with packets but without a bitrate
2347 // then consider the sum not known
2352 ic->bit_rate = bit_rate;
2355 /* if duration is already set, we believe it */
2356 if (ic->duration == AV_NOPTS_VALUE &&
2357 ic->bit_rate != 0) {
2358 filesize = ic->pb ? avio_size(ic->pb) : 0;
2359 if (filesize > ic->internal->data_offset) {
2360 filesize -= ic->internal->data_offset;
2361 for (i = 0; i < ic->nb_streams; i++) {
2362 st = ic->streams[i];
2363 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2364 && st->duration == AV_NOPTS_VALUE) {
2365 duration = av_rescale(8 * filesize, st->time_base.den,
2367 (int64_t) st->time_base.num);
2368 st->duration = duration;
2375 av_log(ic, AV_LOG_WARNING,
2376 "Estimating duration from bitrate, this may be inaccurate\n");
2379 #define DURATION_MAX_READ_SIZE 250000LL
2380 #define DURATION_MAX_RETRY 4
2382 /* only usable for MPEG-PS streams */
2383 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2385 AVPacket pkt1, *pkt = &pkt1;
2387 int num, den, read_size, i, ret;
2388 int found_duration = 0;
2390 int64_t filesize, offset, duration;
2393 /* flush packet queue */
2394 flush_packet_queue(ic);
2396 for (i = 0; i < ic->nb_streams; i++) {
2397 st = ic->streams[i];
2398 if (st->start_time == AV_NOPTS_VALUE &&
2399 st->first_dts == AV_NOPTS_VALUE &&
2400 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2401 av_log(st->codec, AV_LOG_WARNING,
2402 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2405 av_parser_close(st->parser);
2410 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2411 /* estimate the end time (duration) */
2412 /* XXX: may need to support wrapping */
2413 filesize = ic->pb ? avio_size(ic->pb) : 0;
2415 is_end = found_duration;
2416 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2420 avio_seek(ic->pb, offset, SEEK_SET);
2423 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2427 ret = ff_read_packet(ic, pkt);
2428 } while (ret == AVERROR(EAGAIN));
2431 read_size += pkt->size;
2432 st = ic->streams[pkt->stream_index];
2433 if (pkt->pts != AV_NOPTS_VALUE &&
2434 (st->start_time != AV_NOPTS_VALUE ||
2435 st->first_dts != AV_NOPTS_VALUE)) {
2436 if (pkt->duration == 0) {
2437 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2439 pkt->duration = av_rescale_rnd(1,
2440 num * (int64_t) st->time_base.den,
2441 den * (int64_t) st->time_base.num,
2445 duration = pkt->pts + pkt->duration;
2447 if (st->start_time != AV_NOPTS_VALUE)
2448 duration -= st->start_time;
2450 duration -= st->first_dts;
2452 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2453 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2454 st->duration = duration;
2455 st->info->last_duration = duration;
2458 av_free_packet(pkt);
2461 /* check if all audio/video streams have valid duration */
2464 for (i = 0; i < ic->nb_streams; i++) {
2465 st = ic->streams[i];
2466 switch (st->codec->codec_type) {
2467 case AVMEDIA_TYPE_VIDEO:
2468 case AVMEDIA_TYPE_AUDIO:
2469 if (st->duration == AV_NOPTS_VALUE)
2476 ++retry <= DURATION_MAX_RETRY);
2478 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2480 /* warn about audio/video streams which duration could not be estimated */
2481 for (i = 0; i < ic->nb_streams; i++) {
2482 st = ic->streams[i];
2483 if (st->duration == AV_NOPTS_VALUE) {
2484 switch (st->codec->codec_type) {
2485 case AVMEDIA_TYPE_VIDEO:
2486 case AVMEDIA_TYPE_AUDIO:
2487 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2488 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2490 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2494 fill_all_stream_timings(ic);
2496 avio_seek(ic->pb, old_offset, SEEK_SET);
2497 for (i = 0; i < ic->nb_streams; i++) {
2500 st = ic->streams[i];
2501 st->cur_dts = st->first_dts;
2502 st->last_IP_pts = AV_NOPTS_VALUE;
2503 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2504 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2505 st->pts_buffer[j] = AV_NOPTS_VALUE;
2509 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2513 /* get the file size, if possible */
2514 if (ic->iformat->flags & AVFMT_NOFILE) {
2517 file_size = avio_size(ic->pb);
2518 file_size = FFMAX(0, file_size);
2521 if ((!strcmp(ic->iformat->name, "mpeg") ||
2522 !strcmp(ic->iformat->name, "mpegts")) &&
2523 file_size && ic->pb->seekable) {
2524 /* get accurate estimate from the PTSes */
2525 estimate_timings_from_pts(ic, old_offset);
2526 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2527 } else if (has_duration(ic)) {
2528 /* at least one component has timings - we use them for all
2530 fill_all_stream_timings(ic);
2531 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2533 /* less precise: use bitrate info */
2534 estimate_timings_from_bit_rate(ic);
2535 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2537 update_stream_timings(ic);
2541 AVStream av_unused *st;
2542 for (i = 0; i < ic->nb_streams; i++) {
2543 st = ic->streams[i];
2544 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2545 (double) st->start_time / AV_TIME_BASE,
2546 (double) st->duration / AV_TIME_BASE);
2549 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2550 (double) ic->start_time / AV_TIME_BASE,
2551 (double) ic->duration / AV_TIME_BASE,
2552 ic->bit_rate / 1000);
2556 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2558 AVCodecContext *avctx = st->codec;
2560 #define FAIL(errmsg) do { \
2562 *errmsg_ptr = errmsg; \
2566 if ( avctx->codec_id == AV_CODEC_ID_NONE
2567 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2568 FAIL("unknown codec");
2569 switch (avctx->codec_type) {
2570 case AVMEDIA_TYPE_AUDIO:
2571 if (!avctx->frame_size && determinable_frame_size(avctx))
2572 FAIL("unspecified frame size");
2573 if (st->info->found_decoder >= 0 &&
2574 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2575 FAIL("unspecified sample format");
2576 if (!avctx->sample_rate)
2577 FAIL("unspecified sample rate");
2578 if (!avctx->channels)
2579 FAIL("unspecified number of channels");
2580 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2581 FAIL("no decodable DTS frames");
2583 case AVMEDIA_TYPE_VIDEO:
2585 FAIL("unspecified size");
2586 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2587 FAIL("unspecified pixel format");
2588 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2589 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2590 FAIL("no frame in rv30/40 and no sar");
2592 case AVMEDIA_TYPE_SUBTITLE:
2593 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2594 FAIL("unspecified size");
2596 case AVMEDIA_TYPE_DATA:
2597 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2603 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2604 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2605 AVDictionary **options)
2607 const AVCodec *codec;
2608 int got_picture = 1, ret = 0;
2609 AVFrame *frame = av_frame_alloc();
2610 AVSubtitle subtitle;
2611 AVPacket pkt = *avpkt;
2614 return AVERROR(ENOMEM);
2616 if (!avcodec_is_open(st->codec) &&
2617 st->info->found_decoder <= 0 &&
2618 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2619 AVDictionary *thread_opt = NULL;
2621 codec = find_decoder(s, st, st->codec->codec_id);
2624 st->info->found_decoder = -st->codec->codec_id;
2629 /* Force thread count to 1 since the H.264 decoder will not extract
2630 * SPS and PPS to extradata during multi-threaded decoding. */
2631 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2632 if (s->codec_whitelist)
2633 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2634 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2636 av_dict_free(&thread_opt);
2638 st->info->found_decoder = -st->codec->codec_id;
2641 st->info->found_decoder = 1;
2642 } else if (!st->info->found_decoder)
2643 st->info->found_decoder = 1;
2645 if (st->info->found_decoder < 0) {
2650 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2652 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2653 (!st->codec_info_nb_frames &&
2654 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2656 switch (st->codec->codec_type) {
2657 case AVMEDIA_TYPE_VIDEO:
2658 ret = avcodec_decode_video2(st->codec, frame,
2659 &got_picture, &pkt);
2661 case AVMEDIA_TYPE_AUDIO:
2662 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2664 case AVMEDIA_TYPE_SUBTITLE:
2665 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2666 &got_picture, &pkt);
2674 st->nb_decoded_frames++;
2681 if (!pkt.data && !got_picture)
2685 av_frame_free(&frame);
2689 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2691 while (tags->id != AV_CODEC_ID_NONE) {
2699 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2702 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2703 if (tag == tags[i].tag)
2705 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2706 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2708 return AV_CODEC_ID_NONE;
2711 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2716 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2718 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2720 return AV_CODEC_ID_NONE;
2725 if (sflags & (1 << (bps - 1))) {
2728 return AV_CODEC_ID_PCM_S8;
2730 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2732 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2734 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2736 return AV_CODEC_ID_NONE;
2741 return AV_CODEC_ID_PCM_U8;
2743 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2745 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2747 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2749 return AV_CODEC_ID_NONE;
2755 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2758 if (!av_codec_get_tag2(tags, id, &tag))
2763 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2767 for (i = 0; tags && tags[i]; i++) {
2768 const AVCodecTag *codec_tags = tags[i];
2769 while (codec_tags->id != AV_CODEC_ID_NONE) {
2770 if (codec_tags->id == id) {
2771 *tag = codec_tags->tag;
2780 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2783 for (i = 0; tags && tags[i]; i++) {
2784 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2785 if (id != AV_CODEC_ID_NONE)
2788 return AV_CODEC_ID_NONE;
2791 static void compute_chapters_end(AVFormatContext *s)
2794 int64_t max_time = s->duration +
2795 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2797 for (i = 0; i < s->nb_chapters; i++)
2798 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2799 AVChapter *ch = s->chapters[i];
2800 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2804 for (j = 0; j < s->nb_chapters; j++) {
2805 AVChapter *ch1 = s->chapters[j];
2806 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2808 if (j != i && next_start > ch->start && next_start < end)
2811 ch->end = (end == INT64_MAX) ? ch->start : end;
2815 static int get_std_framerate(int i)
2818 return (i + 1) * 1001;
2822 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2826 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2829 /* Is the time base unreliable?
2830 * This is a heuristic to balance between quick acceptance of the values in
2831 * the headers vs. some extra checks.
2832 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2833 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2834 * And there are "variable" fps files this needs to detect as well. */
2835 static int tb_unreliable(AVCodecContext *c)
2837 if (c->time_base.den >= 101LL * c->time_base.num ||
2838 c->time_base.den < 5LL * c->time_base.num ||
2839 // c->codec_tag == AV_RL32("DIVX") ||
2840 // c->codec_tag == AV_RL32("XVID") ||
2841 c->codec_tag == AV_RL32("mp4v") ||
2842 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2843 c->codec_id == AV_CODEC_ID_GIF ||
2844 c->codec_id == AV_CODEC_ID_H264)
2849 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2853 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2854 avctx->extradata = NULL;
2855 avctx->extradata_size = 0;
2856 return AVERROR(EINVAL);
2858 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2859 if (avctx->extradata) {
2860 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2861 avctx->extradata_size = size;
2864 avctx->extradata_size = 0;
2865 ret = AVERROR(ENOMEM);
2870 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2872 int ret = ff_alloc_extradata(avctx, size);
2875 ret = avio_read(pb, avctx->extradata, size);
2877 av_freep(&avctx->extradata);
2878 avctx->extradata_size = 0;
2879 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2880 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2886 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2889 int64_t last = st->info->last_dts;
2891 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2892 && ts - (uint64_t)last < INT64_MAX) {
2893 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2894 int64_t duration = ts - last;
2896 if (!st->info->duration_error)
2897 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2898 if (!st->info->duration_error)
2899 return AVERROR(ENOMEM);
2901 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2902 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2903 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2904 if (st->info->duration_error[0][1][i] < 1e10) {
2905 int framerate = get_std_framerate(i);
2906 double sdts = dts*framerate/(1001*12);
2907 for (j= 0; j<2; j++) {
2908 int64_t ticks = llrint(sdts+j*0.5);
2909 double error= sdts - ticks + j*0.5;
2910 st->info->duration_error[j][0][i] += error;
2911 st->info->duration_error[j][1][i] += error*error;
2915 st->info->duration_count++;
2916 st->info->rfps_duration_sum += duration;
2918 if (st->info->duration_count % 10 == 0) {
2919 int n = st->info->duration_count;
2920 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2921 if (st->info->duration_error[0][1][i] < 1e10) {
2922 double a0 = st->info->duration_error[0][0][i] / n;
2923 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2924 double a1 = st->info->duration_error[1][0][i] / n;
2925 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2926 if (error0 > 0.04 && error1 > 0.04) {
2927 st->info->duration_error[0][1][i] = 2e10;
2928 st->info->duration_error[1][1][i] = 2e10;
2934 // ignore the first 4 values, they might have some random jitter
2935 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2936 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2938 if (ts != AV_NOPTS_VALUE)
2939 st->info->last_dts = ts;
2944 void ff_rfps_calculate(AVFormatContext *ic)
2948 for (i = 0; i < ic->nb_streams; i++) {
2949 AVStream *st = ic->streams[i];
2951 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2953 // the check for tb_unreliable() is not completely correct, since this is not about handling
2954 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2955 // ipmovie.c produces.
2956 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)
2957 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);
2958 if (st->info->duration_count>1 && !st->r_frame_rate.num
2959 && tb_unreliable(st->codec)) {
2961 double best_error= 0.01;
2962 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2964 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2967 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2969 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2972 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2975 for (k= 0; k<2; k++) {
2976 int n = st->info->duration_count;
2977 double a= st->info->duration_error[k][0][j] / n;
2978 double error= st->info->duration_error[k][1][j]/n - a*a;
2980 if (error < best_error && best_error> 0.000000001) {
2982 num = get_std_framerate(j);
2985 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2988 // do not increase frame rate by more than 1 % in order to match a standard rate.
2989 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2990 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2992 if ( !st->avg_frame_rate.num
2993 && st->r_frame_rate.num && st->info->rfps_duration_sum
2994 && st->info->codec_info_duration <= 0
2995 && st->info->duration_count > 2
2996 && 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
2998 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2999 st->avg_frame_rate = st->r_frame_rate;
3002 av_freep(&st->info->duration_error);
3003 st->info->last_dts = AV_NOPTS_VALUE;
3004 st->info->duration_count = 0;
3005 st->info->rfps_duration_sum = 0;
3009 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3011 int i, count, ret = 0, j;
3014 AVPacket pkt1, *pkt;
3015 int64_t old_offset = avio_tell(ic->pb);
3016 // new streams might appear, no options for those
3017 int orig_nb_streams = ic->nb_streams;
3019 int64_t max_analyze_duration = ic->max_analyze_duration2;
3020 int64_t max_stream_analyze_duration;
3021 int64_t probesize = ic->probesize2;
3023 if (!max_analyze_duration)
3024 max_analyze_duration = ic->max_analyze_duration;
3026 probesize = ic->probesize;
3027 flush_codecs = probesize > 0;
3029 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3031 max_stream_analyze_duration = max_analyze_duration;
3032 if (!max_analyze_duration) {
3033 max_stream_analyze_duration =
3034 max_analyze_duration = 5*AV_TIME_BASE;
3035 if (!strcmp(ic->iformat->name, "flv"))
3036 max_stream_analyze_duration = 30*AV_TIME_BASE;
3040 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3041 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3043 for (i = 0; i < ic->nb_streams; i++) {
3044 const AVCodec *codec;
3045 AVDictionary *thread_opt = NULL;
3046 st = ic->streams[i];
3048 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3049 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3050 /* if (!st->time_base.num)
3052 if (!st->codec->time_base.num)
3053 st->codec->time_base = st->time_base;
3055 // only for the split stuff
3056 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3057 st->parser = av_parser_init(st->codec->codec_id);
3059 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3060 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3061 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3062 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3064 } else if (st->need_parsing) {
3065 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3066 "%s, packets or times may be invalid.\n",
3067 avcodec_get_name(st->codec->codec_id));
3070 codec = find_decoder(ic, st, st->codec->codec_id);
3072 /* Force thread count to 1 since the H.264 decoder will not extract
3073 * SPS and PPS to extradata during multi-threaded decoding. */
3074 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3076 if (ic->codec_whitelist)
3077 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3079 /* Ensure that subtitle_header is properly set. */
3080 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3081 && codec && !st->codec->codec) {
3082 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3083 av_log(ic, AV_LOG_WARNING,
3084 "Failed to open codec in av_find_stream_info\n");
3087 // Try to just open decoders, in case this is enough to get parameters.
3088 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3089 if (codec && !st->codec->codec)
3090 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3091 av_log(ic, AV_LOG_WARNING,
3092 "Failed to open codec in av_find_stream_info\n");
3095 av_dict_free(&thread_opt);
3098 for (i = 0; i < ic->nb_streams; i++) {
3099 #if FF_API_R_FRAME_RATE
3100 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3102 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3103 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3109 int analyzed_all_streams;
3110 if (ff_check_interrupt(&ic->interrupt_callback)) {
3112 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3116 /* check if one codec still needs to be handled */
3117 for (i = 0; i < ic->nb_streams; i++) {
3118 int fps_analyze_framecount = 20;
3120 st = ic->streams[i];
3121 if (!has_codec_parameters(st, NULL))
3123 /* If the timebase is coarse (like the usual millisecond precision
3124 * of mkv), we need to analyze more frames to reliably arrive at
3125 * the correct fps. */
3126 if (av_q2d(st->time_base) > 0.0005)
3127 fps_analyze_framecount *= 2;
3128 if (!tb_unreliable(st->codec))
3129 fps_analyze_framecount = 0;
3130 if (ic->fps_probe_size >= 0)
3131 fps_analyze_framecount = ic->fps_probe_size;
3132 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3133 fps_analyze_framecount = 0;
3134 /* variable fps and no guess at the real fps */
3135 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3136 st->info->duration_count < fps_analyze_framecount &&
3137 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3139 if (st->parser && st->parser->parser->split &&
3140 !st->codec->extradata)
3142 if (st->first_dts == AV_NOPTS_VALUE &&
3143 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3144 st->codec_info_nb_frames < ic->max_ts_probe &&
3145 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3146 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3149 analyzed_all_streams = 0;
3150 if (i == ic->nb_streams) {
3151 analyzed_all_streams = 1;
3152 /* NOTE: If the format has no header, then we need to read some
3153 * packets to get most of the streams, so we cannot stop here. */
3154 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3155 /* If we found the info for all the codecs, we can stop. */
3157 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3162 /* We did not get all the codec info, but we read too much data. */
3163 if (read_size >= probesize) {
3165 av_log(ic, AV_LOG_DEBUG,
3166 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3167 for (i = 0; i < ic->nb_streams; i++)
3168 if (!ic->streams[i]->r_frame_rate.num &&
3169 ic->streams[i]->info->duration_count <= 1 &&
3170 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3171 strcmp(ic->iformat->name, "image2"))
3172 av_log(ic, AV_LOG_WARNING,
3173 "Stream #%d: not enough frames to estimate rate; "
3174 "consider increasing probesize\n", i);
3178 /* NOTE: A new stream can be added there if no header in file
3179 * (AVFMTCTX_NOHEADER). */
3180 ret = read_frame_internal(ic, &pkt1);
3181 if (ret == AVERROR(EAGAIN))
3189 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3190 free_packet_buffer(&ic->internal->packet_buffer,
3191 &ic->internal->packet_buffer_end);
3193 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3194 &ic->internal->packet_buffer_end);
3196 ret = AVERROR(ENOMEM);
3197 goto find_stream_info_err;
3199 if ((ret = av_dup_packet(pkt)) < 0)
3200 goto find_stream_info_err;
3203 st = ic->streams[pkt->stream_index];
3204 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3205 read_size += pkt->size;
3207 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3208 /* check for non-increasing dts */
3209 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3210 st->info->fps_last_dts >= pkt->dts) {
3211 av_log(ic, AV_LOG_DEBUG,
3212 "Non-increasing DTS in stream %d: packet %d with DTS "
3213 "%"PRId64", packet %d with DTS %"PRId64"\n",
3214 st->index, st->info->fps_last_dts_idx,
3215 st->info->fps_last_dts, st->codec_info_nb_frames,
3217 st->info->fps_first_dts =
3218 st->info->fps_last_dts = AV_NOPTS_VALUE;
3220 /* Check for a discontinuity in dts. If the difference in dts
3221 * is more than 1000 times the average packet duration in the
3222 * sequence, we treat it as a discontinuity. */
3223 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3224 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3225 (pkt->dts - st->info->fps_last_dts) / 1000 >
3226 (st->info->fps_last_dts - st->info->fps_first_dts) /
3227 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3228 av_log(ic, AV_LOG_WARNING,
3229 "DTS discontinuity in stream %d: packet %d with DTS "
3230 "%"PRId64", packet %d with DTS %"PRId64"\n",
3231 st->index, st->info->fps_last_dts_idx,
3232 st->info->fps_last_dts, st->codec_info_nb_frames,
3234 st->info->fps_first_dts =
3235 st->info->fps_last_dts = AV_NOPTS_VALUE;
3238 /* update stored dts values */
3239 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3240 st->info->fps_first_dts = pkt->dts;
3241 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3243 st->info->fps_last_dts = pkt->dts;
3244 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3246 if (st->codec_info_nb_frames>1) {
3249 if (st->time_base.den > 0)
3250 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3251 if (st->avg_frame_rate.num > 0)
3252 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3255 && st->codec_info_nb_frames>30
3256 && st->info->fps_first_dts != AV_NOPTS_VALUE
3257 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3258 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3260 if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3261 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3262 max_analyze_duration,
3264 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3265 av_packet_unref(pkt);
3268 if (pkt->duration) {
3269 st->info->codec_info_duration += pkt->duration;
3270 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3273 #if FF_API_R_FRAME_RATE
3274 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3275 ff_rfps_add_frame(ic, st, pkt->dts);
3277 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3278 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3279 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3280 if (ff_alloc_extradata(st->codec, i))
3281 return AVERROR(ENOMEM);
3282 memcpy(st->codec->extradata, pkt->data,
3283 st->codec->extradata_size);
3287 /* If still no information, we try to open the codec and to
3288 * decompress the frame. We try to avoid that in most cases as
3289 * it takes longer and uses more memory. For MPEG-4, we need to
3290 * decompress for QuickTime.
3292 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3293 * least one frame of codec data, this makes sure the codec initializes
3294 * the channel configuration and does not only trust the values from
3296 try_decode_frame(ic, st, pkt,
3297 (options && i < orig_nb_streams) ? &options[i] : NULL);
3299 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3300 av_packet_unref(pkt);
3302 st->codec_info_nb_frames++;
3307 AVPacket empty_pkt = { 0 };
3309 av_init_packet(&empty_pkt);
3311 for (i = 0; i < ic->nb_streams; i++) {
3313 st = ic->streams[i];
3315 /* flush the decoders */
3316 if (st->info->found_decoder == 1) {
3318 err = try_decode_frame(ic, st, &empty_pkt,
3319 (options && i < orig_nb_streams)
3320 ? &options[i] : NULL);
3321 } while (err > 0 && !has_codec_parameters(st, NULL));
3324 av_log(ic, AV_LOG_INFO,
3325 "decoding for stream %d failed\n", st->index);
3331 // close codecs which were opened in try_decode_frame()
3332 for (i = 0; i < ic->nb_streams; i++) {
3333 st = ic->streams[i];
3334 avcodec_close(st->codec);
3337 ff_rfps_calculate(ic);
3339 for (i = 0; i < ic->nb_streams; i++) {
3340 st = ic->streams[i];
3341 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3342 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3343 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3344 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3345 st->codec->codec_tag= tag;
3348 /* estimate average framerate if not set by demuxer */
3349 if (st->info->codec_info_duration_fields &&
3350 !st->avg_frame_rate.num &&
3351 st->info->codec_info_duration) {
3353 double best_error = 0.01;
3355 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3356 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3357 st->info->codec_info_duration < 0)
3359 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3360 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3361 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3363 /* Round guessed framerate to a "standard" framerate if it's
3364 * within 1% of the original estimate. */
3365 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3366 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3367 double error = fabs(av_q2d(st->avg_frame_rate) /
3368 av_q2d(std_fps) - 1);
3370 if (error < best_error) {
3372 best_fps = std_fps.num;
3376 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3377 best_fps, 12 * 1001, INT_MAX);
3380 if (!st->r_frame_rate.num) {
3381 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3382 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3383 st->r_frame_rate.num = st->codec->time_base.den;
3384 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3386 st->r_frame_rate.num = st->time_base.den;
3387 st->r_frame_rate.den = st->time_base.num;
3390 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3391 AVRational hw_ratio = { st->codec->height, st->codec->width };
3392 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3395 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3396 if (!st->codec->bits_per_coded_sample)
3397 st->codec->bits_per_coded_sample =
3398 av_get_bits_per_sample(st->codec->codec_id);
3399 // set stream disposition based on audio service type
3400 switch (st->codec->audio_service_type) {
3401 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3402 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3404 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3405 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3407 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3408 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3410 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3411 st->disposition = AV_DISPOSITION_COMMENT;
3413 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3414 st->disposition = AV_DISPOSITION_KARAOKE;
3421 estimate_timings(ic, old_offset);
3423 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3425 if (ret >= 0 && ic->nb_streams)
3426 /* We could not have all the codec parameters before EOF. */
3428 for (i = 0; i < ic->nb_streams; i++) {
3430 st = ic->streams[i];
3431 if (!has_codec_parameters(st, &errmsg)) {
3433 avcodec_string(buf, sizeof(buf), st->codec, 0);
3434 av_log(ic, AV_LOG_WARNING,
3435 "Could not find codec parameters for stream %d (%s): %s\n"
3436 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3443 compute_chapters_end(ic);
3445 find_stream_info_err:
3446 for (i = 0; i < ic->nb_streams; i++) {
3447 st = ic->streams[i];
3448 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3449 ic->streams[i]->codec->thread_count = 0;
3451 av_freep(&st->info->duration_error);
3452 av_freep(&ic->streams[i]->info);
3455 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3456 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3460 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3464 for (i = 0; i < ic->nb_programs; i++) {
3465 if (ic->programs[i] == last) {
3469 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3470 if (ic->programs[i]->stream_index[j] == s)
3471 return ic->programs[i];
3477 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3478 int wanted_stream_nb, int related_stream,
3479 AVCodec **decoder_ret, int flags)
3481 int i, nb_streams = ic->nb_streams;
3482 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3483 unsigned *program = NULL;
3484 const AVCodec *decoder = NULL, *best_decoder = NULL;
3486 if (related_stream >= 0 && wanted_stream_nb < 0) {
3487 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3489 program = p->stream_index;
3490 nb_streams = p->nb_stream_indexes;
3493 for (i = 0; i < nb_streams; i++) {
3494 int real_stream_index = program ? program[i] : i;
3495 AVStream *st = ic->streams[real_stream_index];
3496 AVCodecContext *avctx = st->codec;
3497 if (avctx->codec_type != type)
3499 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3501 if (wanted_stream_nb != real_stream_index &&
3502 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3503 AV_DISPOSITION_VISUAL_IMPAIRED))
3505 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3508 decoder = find_decoder(ic, st, st->codec->codec_id);
3511 ret = AVERROR_DECODER_NOT_FOUND;
3515 count = st->codec_info_nb_frames;
3516 bitrate = avctx->bit_rate;
3518 bitrate = avctx->rc_max_rate;
3519 multiframe = FFMIN(5, count);
3520 if ((best_multiframe > multiframe) ||
3521 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3522 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3525 best_bitrate = bitrate;
3526 best_multiframe = multiframe;
3527 ret = real_stream_index;
3528 best_decoder = decoder;
3529 if (program && i == nb_streams - 1 && ret < 0) {
3531 nb_streams = ic->nb_streams;
3532 /* no related stream found, try again with everything */
3537 *decoder_ret = (AVCodec*)best_decoder;
3541 /*******************************************************/
3543 int av_read_play(AVFormatContext *s)
3545 if (s->iformat->read_play)
3546 return s->iformat->read_play(s);
3548 return avio_pause(s->pb, 0);
3549 return AVERROR(ENOSYS);
3552 int av_read_pause(AVFormatContext *s)
3554 if (s->iformat->read_pause)
3555 return s->iformat->read_pause(s);
3557 return avio_pause(s->pb, 1);
3558 return AVERROR(ENOSYS);
3561 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3563 av_assert0(s->nb_streams>0);
3564 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3566 for (j = 0; j < st->nb_side_data; j++)
3567 av_freep(&st->side_data[j].data);
3568 av_freep(&st->side_data);
3569 st->nb_side_data = 0;
3572 av_parser_close(st->parser);
3574 if (st->attached_pic.data)
3575 av_free_packet(&st->attached_pic);
3576 av_dict_free(&st->metadata);
3577 av_freep(&st->probe_data.buf);
3578 av_freep(&st->index_entries);
3579 av_freep(&st->codec->extradata);
3580 av_freep(&st->codec->subtitle_header);
3581 av_freep(&st->codec);
3582 av_freep(&st->priv_data);
3584 av_freep(&st->info->duration_error);
3585 av_freep(&st->info);
3586 av_freep(&st->recommended_encoder_configuration);
3587 av_freep(&s->streams[ --s->nb_streams ]);
3590 void avformat_free_context(AVFormatContext *s)
3598 if (s->iformat && s->iformat->priv_class && s->priv_data)
3599 av_opt_free(s->priv_data);
3600 if (s->oformat && s->oformat->priv_class && s->priv_data)
3601 av_opt_free(s->priv_data);
3603 for (i = s->nb_streams - 1; i >= 0; i--) {
3604 ff_free_stream(s, s->streams[i]);
3606 for (i = s->nb_programs - 1; i >= 0; i--) {
3607 av_dict_free(&s->programs[i]->metadata);
3608 av_freep(&s->programs[i]->stream_index);
3609 av_freep(&s->programs[i]);
3611 av_freep(&s->programs);
3612 av_freep(&s->priv_data);
3613 while (s->nb_chapters--) {
3614 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3615 av_freep(&s->chapters[s->nb_chapters]);
3617 av_freep(&s->chapters);
3618 av_dict_free(&s->metadata);
3619 av_freep(&s->streams);
3620 av_freep(&s->internal);
3621 flush_packet_queue(s);
3625 void avformat_close_input(AVFormatContext **ps)
3636 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3637 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3640 flush_packet_queue(s);
3643 if (s->iformat->read_close)
3644 s->iformat->read_close(s);
3646 avformat_free_context(s);
3653 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3659 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3661 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3664 s->streams = streams;
3666 st = av_mallocz(sizeof(AVStream));
3669 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3673 st->info->last_dts = AV_NOPTS_VALUE;
3675 st->codec = avcodec_alloc_context3(c);
3682 /* no default bitrate if decoding */
3683 st->codec->bit_rate = 0;
3685 /* default pts setting is MPEG-like */
3686 avpriv_set_pts_info(st, 33, 1, 90000);
3689 st->index = s->nb_streams;
3690 st->start_time = AV_NOPTS_VALUE;
3691 st->duration = AV_NOPTS_VALUE;
3692 /* we set the current DTS to 0 so that formats without any timestamps
3693 * but durations get some timestamps, formats with some unknown
3694 * timestamps have their first few packets buffered and the
3695 * timestamps corrected before they are returned to the user */
3696 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3697 st->first_dts = AV_NOPTS_VALUE;
3698 st->probe_packets = MAX_PROBE_PACKETS;
3699 st->pts_wrap_reference = AV_NOPTS_VALUE;
3700 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3702 st->last_IP_pts = AV_NOPTS_VALUE;
3703 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3704 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3705 st->pts_buffer[i] = AV_NOPTS_VALUE;
3707 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3709 #if FF_API_R_FRAME_RATE
3710 st->info->last_dts = AV_NOPTS_VALUE;
3712 st->info->fps_first_dts = AV_NOPTS_VALUE;
3713 st->info->fps_last_dts = AV_NOPTS_VALUE;
3715 st->inject_global_side_data = s->internal->inject_global_side_data;
3717 s->streams[s->nb_streams++] = st;
3721 AVProgram *av_new_program(AVFormatContext *ac, int id)
3723 AVProgram *program = NULL;
3726 av_dlog(ac, "new_program: id=0x%04x\n", id);
3728 for (i = 0; i < ac->nb_programs; i++)
3729 if (ac->programs[i]->id == id)
3730 program = ac->programs[i];
3733 program = av_mallocz(sizeof(AVProgram));
3736 dynarray_add(&ac->programs, &ac->nb_programs, program);
3737 program->discard = AVDISCARD_NONE;
3740 program->pts_wrap_reference = AV_NOPTS_VALUE;
3741 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3743 program->start_time =
3744 program->end_time = AV_NOPTS_VALUE;
3749 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3750 int64_t start, int64_t end, const char *title)
3752 AVChapter *chapter = NULL;
3755 if (end != AV_NOPTS_VALUE && start > end) {
3756 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3760 for (i = 0; i < s->nb_chapters; i++)
3761 if (s->chapters[i]->id == id)
3762 chapter = s->chapters[i];
3765 chapter = av_mallocz(sizeof(AVChapter));
3768 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3770 av_dict_set(&chapter->metadata, "title", title, 0);
3772 chapter->time_base = time_base;
3773 chapter->start = start;
3779 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3782 AVProgram *program = NULL;
3785 if (idx >= ac->nb_streams) {
3786 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3790 for (i = 0; i < ac->nb_programs; i++) {
3791 if (ac->programs[i]->id != progid)
3793 program = ac->programs[i];
3794 for (j = 0; j < program->nb_stream_indexes; j++)
3795 if (program->stream_index[j] == idx)
3798 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3801 program->stream_index = tmp;
3802 program->stream_index[program->nb_stream_indexes++] = idx;
3807 uint64_t ff_ntp_time(void)
3809 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3812 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3815 char *q, buf1[20], c;
3816 int nd, len, percentd_found;
3828 while (av_isdigit(*p))
3829 nd = nd * 10 + *p++ - '0';
3831 } while (av_isdigit(c));
3842 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3844 if ((q - buf + len) > buf_size - 1)
3846 memcpy(q, buf1, len);
3854 if ((q - buf) < buf_size - 1)
3858 if (!percentd_found)
3867 void av_url_split(char *proto, int proto_size,
3868 char *authorization, int authorization_size,
3869 char *hostname, int hostname_size,
3870 int *port_ptr, char *path, int path_size, const char *url)
3872 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3878 if (authorization_size > 0)
3879 authorization[0] = 0;
3880 if (hostname_size > 0)
3885 /* parse protocol */
3886 if ((p = strchr(url, ':'))) {
3887 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3894 /* no protocol means plain filename */
3895 av_strlcpy(path, url, path_size);
3899 /* separate path from hostname */
3900 ls = strchr(p, '/');
3901 ls2 = strchr(p, '?');
3905 ls = FFMIN(ls, ls2);
3907 av_strlcpy(path, ls, path_size);
3909 ls = &p[strlen(p)]; // XXX
3911 /* the rest is hostname, use that to parse auth/port */
3913 /* authorization (user[:pass]@hostname) */
3915 while ((at = strchr(p, '@')) && at < ls) {
3916 av_strlcpy(authorization, at2,
3917 FFMIN(authorization_size, at + 1 - at2));
3918 p = at + 1; /* skip '@' */
3921 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3923 av_strlcpy(hostname, p + 1,
3924 FFMIN(hostname_size, brk - p));
3925 if (brk[1] == ':' && port_ptr)
3926 *port_ptr = atoi(brk + 2);
3927 } else if ((col = strchr(p, ':')) && col < ls) {
3928 av_strlcpy(hostname, p,
3929 FFMIN(col + 1 - p, hostname_size));
3931 *port_ptr = atoi(col + 1);
3933 av_strlcpy(hostname, p,
3934 FFMIN(ls + 1 - p, hostname_size));
3938 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3941 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3944 'C', 'D', 'E', 'F' };
3945 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3948 'c', 'd', 'e', 'f' };
3949 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3951 for (i = 0; i < s; i++) {
3952 buff[i * 2] = hex_table[src[i] >> 4];
3953 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3959 int ff_hex_to_data(uint8_t *data, const char *p)
3966 p += strspn(p, SPACE_CHARS);
3969 c = av_toupper((unsigned char) *p++);
3970 if (c >= '0' && c <= '9')
3972 else if (c >= 'A' && c <= 'F')
3987 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3988 unsigned int pts_num, unsigned int pts_den)
3991 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3992 if (new_tb.num != pts_num)
3993 av_log(NULL, AV_LOG_DEBUG,
3994 "st:%d removing common factor %d from timebase\n",
3995 s->index, pts_num / new_tb.num);
3997 av_log(NULL, AV_LOG_WARNING,
3998 "st:%d has too large timebase, reducing\n", s->index);
4000 if (new_tb.num <= 0 || new_tb.den <= 0) {
4001 av_log(NULL, AV_LOG_ERROR,
4002 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4003 new_tb.num, new_tb.den,
4007 s->time_base = new_tb;
4008 av_codec_set_pkt_timebase(s->codec, new_tb);
4009 s->pts_wrap_bits = pts_wrap_bits;
4012 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4015 const char *ptr = str;
4017 /* Parse key=value pairs. */
4020 char *dest = NULL, *dest_end;
4021 int key_len, dest_len = 0;
4023 /* Skip whitespace and potential commas. */
4024 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4031 if (!(ptr = strchr(key, '=')))
4034 key_len = ptr - key;
4036 callback_get_buf(context, key, key_len, &dest, &dest_len);
4037 dest_end = dest + dest_len - 1;
4041 while (*ptr && *ptr != '\"') {
4045 if (dest && dest < dest_end)
4049 if (dest && dest < dest_end)
4057 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4058 if (dest && dest < dest_end)
4066 int ff_find_stream_index(AVFormatContext *s, int id)
4069 for (i = 0; i < s->nb_streams; i++)
4070 if (s->streams[i]->id == id)
4075 int64_t ff_iso8601_to_unix_time(const char *datestr)
4077 struct tm time1 = { 0 }, time2 = { 0 };
4079 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4080 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4082 return av_timegm(&time2);
4084 return av_timegm(&time1);
4087 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4091 if (ofmt->query_codec)
4092 return ofmt->query_codec(codec_id, std_compliance);
4093 else if (ofmt->codec_tag)
4094 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4095 else if (codec_id == ofmt->video_codec ||
4096 codec_id == ofmt->audio_codec ||
4097 codec_id == ofmt->subtitle_codec)
4100 return AVERROR_PATCHWELCOME;
4103 int avformat_network_init(void)
4107 ff_network_inited_globally = 1;
4108 if ((ret = ff_network_init()) < 0)
4110 if ((ret = ff_tls_init()) < 0)
4116 int avformat_network_deinit(void)
4125 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4126 uint64_t channel_layout, int32_t sample_rate,
4127 int32_t width, int32_t height)
4133 return AVERROR(EINVAL);
4136 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4138 if (channel_layout) {
4140 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4144 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4146 if (width || height) {
4148 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4150 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4152 return AVERROR(ENOMEM);
4153 bytestream_put_le32(&data, flags);
4155 bytestream_put_le32(&data, channels);
4157 bytestream_put_le64(&data, channel_layout);
4159 bytestream_put_le32(&data, sample_rate);
4160 if (width || height) {
4161 bytestream_put_le32(&data, width);
4162 bytestream_put_le32(&data, height);
4167 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4169 AVRational undef = {0, 1};
4170 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4171 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4172 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4174 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4175 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4176 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4177 stream_sample_aspect_ratio = undef;
4179 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4180 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4181 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4182 frame_sample_aspect_ratio = undef;
4184 if (stream_sample_aspect_ratio.num)
4185 return stream_sample_aspect_ratio;
4187 return frame_sample_aspect_ratio;
4190 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4192 AVRational fr = st->r_frame_rate;
4193 AVRational codec_fr = st->codec->framerate;
4194 AVRational avg_fr = st->avg_frame_rate;
4196 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4197 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4202 if (st->codec->ticks_per_frame > 1) {
4203 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4204 (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))
4211 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4214 if (*spec <= '9' && *spec >= '0') /* opt:index */
4215 return strtol(spec, NULL, 0) == st->index;
4216 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4217 *spec == 't') { /* opt:[vasdt] */
4218 enum AVMediaType type;
4221 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4222 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4223 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4224 case 'd': type = AVMEDIA_TYPE_DATA; break;
4225 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4226 default: av_assert0(0);
4228 if (type != st->codec->codec_type)
4230 if (*spec++ == ':') { /* possibly followed by :index */
4231 int i, index = strtol(spec, NULL, 0);
4232 for (i = 0; i < s->nb_streams; i++)
4233 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4234 return i == st->index;
4238 } else if (*spec == 'p' && *(spec + 1) == ':') {
4242 prog_id = strtol(spec, &endptr, 0);
4243 for (i = 0; i < s->nb_programs; i++) {
4244 if (s->programs[i]->id != prog_id)
4247 if (*endptr++ == ':') {
4248 int stream_idx = strtol(endptr, NULL, 0);
4249 return stream_idx >= 0 &&
4250 stream_idx < s->programs[i]->nb_stream_indexes &&
4251 st->index == s->programs[i]->stream_index[stream_idx];
4254 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4255 if (st->index == s->programs[i]->stream_index[j])
4259 } else if (*spec == '#' ||
4260 (*spec == 'i' && *(spec + 1) == ':')) {
4263 spec += 1 + (*spec == 'i');
4264 stream_id = strtol(spec, &endptr, 0);
4266 return stream_id == st->id;
4267 } else if (*spec == 'm' && *(spec + 1) == ':') {
4268 AVDictionaryEntry *tag;
4273 val = strchr(spec, ':');
4275 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4277 return AVERROR(ENOMEM);
4279 tag = av_dict_get(st->metadata, key, NULL, 0);
4281 if (!val || !strcmp(tag->value, val + 1))
4290 } else if (!*spec) /* empty specifier, matches everything */
4293 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4294 return AVERROR(EINVAL);
4297 int ff_generate_avci_extradata(AVStream *st)
4299 static const uint8_t avci100_1080p_extradata[] = {
4301 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4302 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4303 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4304 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4305 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4306 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4307 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4308 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4309 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4311 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4314 static const uint8_t avci100_1080i_extradata[] = {
4316 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4317 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4318 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4319 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4320 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4321 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4322 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4323 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4324 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4325 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4326 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4328 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4331 static const uint8_t avci50_1080p_extradata[] = {
4333 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4334 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4335 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4336 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4337 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4338 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4339 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4340 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4341 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4343 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4346 static const uint8_t avci50_1080i_extradata[] = {
4348 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4349 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4350 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4351 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4352 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4353 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4354 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4355 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4356 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4357 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4358 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4360 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4363 static const uint8_t avci100_720p_extradata[] = {
4365 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4366 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4367 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4368 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4369 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4370 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4371 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4372 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4373 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4374 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4376 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4379 static const uint8_t avci50_720p_extradata[] = {
4381 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4382 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4383 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4384 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4385 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4386 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4387 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4388 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4389 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4391 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4395 const uint8_t *data = NULL;
4398 if (st->codec->width == 1920) {
4399 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4400 data = avci100_1080p_extradata;
4401 size = sizeof(avci100_1080p_extradata);
4403 data = avci100_1080i_extradata;
4404 size = sizeof(avci100_1080i_extradata);
4406 } else if (st->codec->width == 1440) {
4407 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4408 data = avci50_1080p_extradata;
4409 size = sizeof(avci50_1080p_extradata);
4411 data = avci50_1080i_extradata;
4412 size = sizeof(avci50_1080i_extradata);
4414 } else if (st->codec->width == 1280) {
4415 data = avci100_720p_extradata;
4416 size = sizeof(avci100_720p_extradata);
4417 } else if (st->codec->width == 960) {
4418 data = avci50_720p_extradata;
4419 size = sizeof(avci50_720p_extradata);
4425 av_freep(&st->codec->extradata);
4426 if (ff_alloc_extradata(st->codec, size))
4427 return AVERROR(ENOMEM);
4428 memcpy(st->codec->extradata, data, size);
4433 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4438 for (i = 0; i < st->nb_side_data; i++) {
4439 if (st->side_data[i].type == type) {
4441 *size = st->side_data[i].size;
4442 return st->side_data[i].data;
4448 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4451 AVPacketSideData *sd, *tmp;
4453 uint8_t *data = av_malloc(size);
4458 for (i = 0; i < st->nb_side_data; i++) {
4459 sd = &st->side_data[i];
4461 if (sd->type == type) {
4462 av_freep(&sd->data);
4469 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4475 st->side_data = tmp;
4478 sd = &st->side_data[st->nb_side_data - 1];