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
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
64 return LIBAVFORMAT_VERSION_INT;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts) {
81 return ts > (RELATIVE_TS_BASE - (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
94 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
95 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
96 timestamp < st->pts_wrap_reference)
97 return timestamp + (1ULL << st->pts_wrap_bits);
98 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99 timestamp >= st->pts_wrap_reference)
100 return timestamp - (1ULL << st->pts_wrap_bits);
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
113 int64_t av_stream_get_end_pts(const AVStream *st)
118 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
123 void av_format_inject_global_side_data(AVFormatContext *s)
126 s->internal->inject_global_side_data = 1;
127 for (i = 0; i < s->nb_streams; i++) {
128 AVStream *st = s->streams[i];
129 st->inject_global_side_data = 1;
133 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
135 if (st->codec->codec)
136 return st->codec->codec;
138 switch (st->codec->codec_type) {
139 case AVMEDIA_TYPE_VIDEO:
140 if (s->video_codec) return s->video_codec;
142 case AVMEDIA_TYPE_AUDIO:
143 if (s->audio_codec) return s->audio_codec;
145 case AVMEDIA_TYPE_SUBTITLE:
146 if (s->subtitle_codec) return s->subtitle_codec;
150 return avcodec_find_decoder(codec_id);
153 int av_format_get_probe_score(const AVFormatContext *s)
155 return s->probe_score;
158 /* an arbitrarily chosen "sane" max packet size -- 50M */
159 #define SANE_CHUNK_SIZE (50000000)
161 int ffio_limit(AVIOContext *s, int size)
163 if (s->maxsize>= 0) {
164 int64_t remaining= s->maxsize - avio_tell(s);
165 if (remaining < size) {
166 int64_t newsize = avio_size(s);
167 if (!s->maxsize || s->maxsize<newsize)
168 s->maxsize = newsize - !newsize;
169 remaining= s->maxsize - avio_tell(s);
170 remaining= FFMAX(remaining, 0);
173 if (s->maxsize>= 0 && remaining+1 < size) {
174 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
181 /* Read the data in sane-sized chunks and append to pkt.
182 * Return the number of bytes read or an error. */
183 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
185 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
186 int orig_size = pkt->size;
190 int prev_size = pkt->size;
193 /* When the caller requests a lot of data, limit it to the amount
194 * left in file or SANE_CHUNK_SIZE when it is not known. */
196 if (read_size > SANE_CHUNK_SIZE/10) {
197 read_size = ffio_limit(s, read_size);
198 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
200 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
203 ret = av_grow_packet(pkt, read_size);
207 ret = avio_read(s, pkt->data + prev_size, read_size);
208 if (ret != read_size) {
209 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
216 pkt->flags |= AV_PKT_FLAG_CORRUPT;
221 return pkt->size > orig_size ? pkt->size - orig_size : ret;
224 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
229 pkt->pos = avio_tell(s);
231 return append_packet_chunked(s, pkt, size);
234 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
237 return av_get_packet(s, pkt, size);
238 return append_packet_chunked(s, pkt, size);
241 int av_filename_number_test(const char *filename)
245 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
248 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
251 AVProbeData lpd = *pd;
252 AVInputFormat *fmt1 = NULL, *fmt;
253 int score, nodat = 0, score_max = 0;
254 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
257 lpd.buf = zerobuffer;
259 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
260 int id3len = ff_id3v2_tag_len(lpd.buf);
261 if (lpd.buf_size > id3len + 16) {
263 lpd.buf_size -= id3len;
264 } else if (id3len >= PROBE_BUF_MAX) {
271 while ((fmt1 = av_iformat_next(fmt1))) {
272 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
275 if (fmt1->read_probe) {
276 score = fmt1->read_probe(&lpd);
277 if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
278 if (nodat == 0) score = FFMAX(score, 1);
279 else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
280 else score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
282 } else if (fmt1->extensions) {
283 if (av_match_ext(lpd.filename, fmt1->extensions))
284 score = AVPROBE_SCORE_EXTENSION;
286 if (score > score_max) {
289 } else if (score == score_max)
293 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
294 *score_ret = score_max;
299 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
302 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
303 if (score_ret > *score_max) {
304 *score_max = score_ret;
310 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
313 return av_probe_input_format2(pd, is_opened, &score);
316 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
319 static const struct {
322 enum AVMediaType type;
324 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
325 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
326 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
327 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
328 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
329 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
330 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
331 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
332 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
333 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
337 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
339 if (fmt && st->request_probe <= score) {
341 av_log(s, AV_LOG_DEBUG,
342 "Probe with size=%d, packets=%d detected %s with score=%d\n",
343 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
345 for (i = 0; fmt_id_type[i].name; i++) {
346 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
347 st->codec->codec_id = fmt_id_type[i].id;
348 st->codec->codec_type = fmt_id_type[i].type;
356 /************************************************************/
357 /* input media file */
359 int av_demuxer_open(AVFormatContext *ic) {
362 if (ic->iformat->read_header) {
363 err = ic->iformat->read_header(ic);
368 if (ic->pb && !ic->data_offset)
369 ic->data_offset = avio_tell(ic->pb);
375 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
376 const char *filename, void *logctx,
377 unsigned int offset, unsigned int max_probe_size)
379 AVProbeData pd = { filename ? filename : "" };
382 int ret = 0, probe_size, buf_offset = 0;
386 max_probe_size = PROBE_BUF_MAX;
387 else if (max_probe_size < PROBE_BUF_MIN) {
388 av_log(logctx, AV_LOG_ERROR,
389 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
390 return AVERROR(EINVAL);
393 if (offset >= max_probe_size)
394 return AVERROR(EINVAL);
396 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
397 if (!av_strcasecmp(mime_type, "audio/aacp")) {
398 *fmt = av_find_input_format("aac");
400 av_freep(&mime_type);
403 for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
404 probe_size = FFMIN(probe_size << 1,
405 FFMAX(max_probe_size, probe_size + 1))) {
406 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
408 /* Read probe data. */
409 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
411 if ((ret = avio_read(pb, buf + buf_offset,
412 probe_size - buf_offset)) < 0) {
413 /* Fail if error was not end of file, otherwise, lower score. */
414 if (ret != AVERROR_EOF) {
419 ret = 0; /* error was end of file, nothing read */
422 if (buf_offset < offset)
424 pd.buf_size = buf_offset - offset;
425 pd.buf = &buf[offset];
427 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
429 /* Guess file format. */
430 *fmt = av_probe_input_format2(&pd, 1, &score);
432 /* This can only be true in the last iteration. */
433 if (score <= AVPROBE_SCORE_RETRY) {
434 av_log(logctx, AV_LOG_WARNING,
435 "Format %s detected only with low score of %d, "
436 "misdetection possible!\n", (*fmt)->name, score);
438 av_log(logctx, AV_LOG_DEBUG,
439 "Format %s probed with size=%d and score=%d\n",
440 (*fmt)->name, probe_size, score);
442 FILE *f = fopen("probestat.tmp", "ab");
443 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
451 return AVERROR_INVALIDDATA;
454 /* Rewind. Reuse probe buffer to avoid seeking. */
455 ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
457 return ret < 0 ? ret : score;
460 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
461 const char *filename, void *logctx,
462 unsigned int offset, unsigned int max_probe_size)
464 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
465 return ret < 0 ? ret : 0;
468 /* Open input file and probe the format if necessary. */
469 static int init_input(AVFormatContext *s, const char *filename,
470 AVDictionary **options)
473 AVProbeData pd = { filename, NULL, 0 };
474 int score = AVPROBE_SCORE_RETRY;
477 s->flags |= AVFMT_FLAG_CUSTOM_IO;
479 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
480 s, 0, s->format_probesize);
481 else if (s->iformat->flags & AVFMT_NOFILE)
482 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
483 "will be ignored with AVFMT_NOFILE format.\n");
487 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
488 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
491 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
492 &s->interrupt_callback, options)) < 0)
496 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
497 s, 0, s->format_probesize);
500 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
501 AVPacketList **plast_pktl)
503 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
508 (*plast_pktl)->next = pktl;
510 *packet_buffer = pktl;
512 /* Add the packet in the buffered packet list. */
518 int avformat_queue_attached_pictures(AVFormatContext *s)
521 for (i = 0; i < s->nb_streams; i++)
522 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
523 s->streams[i]->discard < AVDISCARD_ALL) {
524 AVPacket copy = s->streams[i]->attached_pic;
525 if (copy.size <= 0) {
526 av_log(s, AV_LOG_WARNING,
527 "Attached picture on stream %d has invalid size, "
531 copy.buf = av_buffer_ref(copy.buf);
533 return AVERROR(ENOMEM);
535 add_to_pktbuf(&s->raw_packet_buffer, ©,
536 &s->raw_packet_buffer_end);
541 int avformat_open_input(AVFormatContext **ps, const char *filename,
542 AVInputFormat *fmt, AVDictionary **options)
544 AVFormatContext *s = *ps;
546 AVDictionary *tmp = NULL;
547 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
549 if (!s && !(s = avformat_alloc_context()))
550 return AVERROR(ENOMEM);
552 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
553 return AVERROR(EINVAL);
559 av_dict_copy(&tmp, *options, 0);
561 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
564 if ((ret = init_input(s, filename, &tmp)) < 0)
566 s->probe_score = ret;
567 avio_skip(s->pb, s->skip_initial_bytes);
569 /* Check filename in case an image number is expected. */
570 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
571 if (!av_filename_number_test(filename)) {
572 ret = AVERROR(EINVAL);
577 s->duration = s->start_time = AV_NOPTS_VALUE;
578 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
580 /* Allocate private data. */
581 if (s->iformat->priv_data_size > 0) {
582 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
583 ret = AVERROR(ENOMEM);
586 if (s->iformat->priv_class) {
587 *(const AVClass **) s->priv_data = s->iformat->priv_class;
588 av_opt_set_defaults(s->priv_data);
589 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
594 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
596 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
598 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
599 if ((ret = s->iformat->read_header(s)) < 0)
602 if (id3v2_extra_meta) {
603 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
604 !strcmp(s->iformat->name, "tta")) {
605 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
608 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
610 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
612 if ((ret = avformat_queue_attached_pictures(s)) < 0)
615 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
616 s->data_offset = avio_tell(s->pb);
618 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
621 av_dict_free(options);
628 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
630 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
632 avformat_free_context(s);
637 /*******************************************************/
639 static void force_codec_ids(AVFormatContext *s, AVStream *st)
641 switch (st->codec->codec_type) {
642 case AVMEDIA_TYPE_VIDEO:
643 if (s->video_codec_id)
644 st->codec->codec_id = s->video_codec_id;
646 case AVMEDIA_TYPE_AUDIO:
647 if (s->audio_codec_id)
648 st->codec->codec_id = s->audio_codec_id;
650 case AVMEDIA_TYPE_SUBTITLE:
651 if (s->subtitle_codec_id)
652 st->codec->codec_id = s->subtitle_codec_id;
657 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
659 if (st->request_probe>0) {
660 AVProbeData *pd = &st->probe_data;
662 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
666 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
668 av_log(s, AV_LOG_WARNING,
669 "Failed to reallocate probe buffer for stream %d\n",
674 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
675 pd->buf_size += pkt->size;
676 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
679 st->probe_packets = 0;
681 av_log(s, AV_LOG_WARNING,
682 "nothing to probe for stream %d\n", st->index);
686 end= s->raw_packet_buffer_remaining_size <= 0
687 || st->probe_packets<= 0;
689 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
690 int score = set_codec_from_probe_data(s, st, pd);
691 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
695 st->request_probe = -1;
696 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
697 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
699 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
701 force_codec_ids(s, st);
707 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
709 int64_t ref = pkt->dts;
710 int i, pts_wrap_behavior;
711 int64_t pts_wrap_reference;
712 AVProgram *first_program;
714 if (ref == AV_NOPTS_VALUE)
716 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
718 ref &= (1LL << st->pts_wrap_bits)-1;
720 // reference time stamp should be 60 s before first time stamp
721 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
722 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
723 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
724 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
725 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
727 first_program = av_find_program_from_stream(s, NULL, stream_index);
729 if (!first_program) {
730 int default_stream_index = av_find_default_stream_index(s);
731 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
732 for (i = 0; i < s->nb_streams; i++) {
733 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
734 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
738 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
739 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
743 AVProgram *program = first_program;
745 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
746 pts_wrap_reference = program->pts_wrap_reference;
747 pts_wrap_behavior = program->pts_wrap_behavior;
750 program = av_find_program_from_stream(s, program, stream_index);
753 // update every program with differing pts_wrap_reference
754 program = first_program;
756 if (program->pts_wrap_reference != pts_wrap_reference) {
757 for (i = 0; i<program->nb_stream_indexes; i++) {
758 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
759 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
762 program->pts_wrap_reference = pts_wrap_reference;
763 program->pts_wrap_behavior = pts_wrap_behavior;
765 program = av_find_program_from_stream(s, program, stream_index);
771 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
777 AVPacketList *pktl = s->raw_packet_buffer;
781 st = s->streams[pkt->stream_index];
782 if (s->raw_packet_buffer_remaining_size <= 0)
783 if ((err = probe_codec(s, st, NULL)) < 0)
785 if (st->request_probe <= 0) {
786 s->raw_packet_buffer = pktl->next;
787 s->raw_packet_buffer_remaining_size += pkt->size;
796 ret = s->iformat->read_packet(s, pkt);
798 if (!pktl || ret == AVERROR(EAGAIN))
800 for (i = 0; i < s->nb_streams; i++) {
802 if (st->probe_packets)
803 if ((err = probe_codec(s, st, NULL)) < 0)
805 av_assert0(st->request_probe <= 0);
810 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
811 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
812 av_log(s, AV_LOG_WARNING,
813 "Dropped corrupted packet (stream = %d)\n",
819 if (pkt->stream_index >= (unsigned)s->nb_streams) {
820 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
824 st = s->streams[pkt->stream_index];
826 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
827 // correct first time stamps to negative values
828 if (!is_relative(st->first_dts))
829 st->first_dts = wrap_timestamp(st, st->first_dts);
830 if (!is_relative(st->start_time))
831 st->start_time = wrap_timestamp(st, st->start_time);
832 if (!is_relative(st->cur_dts))
833 st->cur_dts = wrap_timestamp(st, st->cur_dts);
836 pkt->dts = wrap_timestamp(st, pkt->dts);
837 pkt->pts = wrap_timestamp(st, pkt->pts);
839 force_codec_ids(s, st);
841 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
842 if (s->use_wallclock_as_timestamps)
843 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
845 if (!pktl && st->request_probe <= 0)
848 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
849 s->raw_packet_buffer_remaining_size -= pkt->size;
851 if ((err = probe_codec(s, st, pkt)) < 0)
856 #if FF_API_READ_PACKET
857 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
859 return ff_read_packet(s, pkt);
864 /**********************************************************/
866 static int determinable_frame_size(AVCodecContext *avctx)
868 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
869 avctx->codec_id == AV_CODEC_ID_MP1 ||
870 avctx->codec_id == AV_CODEC_ID_MP2 ||
871 avctx->codec_id == AV_CODEC_ID_MP3/* ||
872 avctx->codec_id == AV_CODEC_ID_CELT*/)
878 * Get the number of samples of an audio frame. Return -1 on error.
880 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
884 /* give frame_size priority if demuxing */
885 if (!mux && enc->frame_size > 1)
886 return enc->frame_size;
888 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
891 /* Fall back on using frame_size if muxing. */
892 if (enc->frame_size > 1)
893 return enc->frame_size;
895 //For WMA we currently have no other means to calculate duration thus we
896 //do it here by assuming CBR, which is true for all known cases.
897 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
898 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
899 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
906 * Return the frame duration in seconds. Return 0 if not available.
908 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
909 AVCodecParserContext *pc, AVPacket *pkt)
915 switch (st->codec->codec_type) {
916 case AVMEDIA_TYPE_VIDEO:
917 if (st->r_frame_rate.num && !pc) {
918 *pnum = st->r_frame_rate.den;
919 *pden = st->r_frame_rate.num;
920 } else if (st->time_base.num * 1000LL > st->time_base.den) {
921 *pnum = st->time_base.num;
922 *pden = st->time_base.den;
923 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
924 *pnum = st->codec->time_base.num;
925 *pden = st->codec->time_base.den;
926 if (pc && pc->repeat_pict) {
927 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
928 *pden /= 1 + pc->repeat_pict;
930 *pnum *= 1 + pc->repeat_pict;
932 /* If this codec can be interlaced or progressive then we need
933 * a parser to compute duration of a packet. Thus if we have
934 * no parser in such case leave duration undefined. */
935 if (st->codec->ticks_per_frame > 1 && !pc)
939 case AVMEDIA_TYPE_AUDIO:
940 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
941 if (frame_size <= 0 || st->codec->sample_rate <= 0)
944 *pden = st->codec->sample_rate;
951 static int is_intra_only(AVCodecContext *enc) {
952 const AVCodecDescriptor *desc;
954 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
957 desc = av_codec_get_codec_descriptor(enc);
959 desc = avcodec_descriptor_get(enc->codec_id);
960 av_codec_set_codec_descriptor(enc, desc);
963 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
967 static int has_decode_delay_been_guessed(AVStream *st)
969 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
970 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
972 #if CONFIG_H264_DECODER
973 if (st->codec->has_b_frames &&
974 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
977 if (st->codec->has_b_frames<3)
978 return st->nb_decoded_frames >= 7;
979 else if (st->codec->has_b_frames<4)
980 return st->nb_decoded_frames >= 18;
982 return st->nb_decoded_frames >= 20;
985 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
989 if (pktl == s->packet_buffer_end)
990 return s->parse_queue;
994 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
995 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
996 st->codec->codec_id != AV_CODEC_ID_HEVC;
999 int delay = st->codec->has_b_frames;
1002 if (dts == AV_NOPTS_VALUE) {
1003 int64_t best_score = INT64_MAX;
1004 for (i = 0; i<delay; i++) {
1005 if (st->pts_reorder_error_count[i]) {
1006 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1007 if (score < best_score) {
1009 dts = pts_buffer[i];
1014 for (i = 0; i<delay; i++) {
1015 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1016 int64_t diff = FFABS(pts_buffer[i] - dts)
1017 + (uint64_t)st->pts_reorder_error[i];
1018 diff = FFMAX(diff, st->pts_reorder_error[i]);
1019 st->pts_reorder_error[i] = diff;
1020 st->pts_reorder_error_count[i]++;
1021 if (st->pts_reorder_error_count[i] > 250) {
1022 st->pts_reorder_error[i] >>= 1;
1023 st->pts_reorder_error_count[i] >>= 1;
1030 if (dts == AV_NOPTS_VALUE)
1031 dts = pts_buffer[0];
1036 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1037 int64_t dts, int64_t pts, AVPacket *pkt)
1039 AVStream *st = s->streams[stream_index];
1040 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1041 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1045 if (st->first_dts != AV_NOPTS_VALUE ||
1046 dts == AV_NOPTS_VALUE ||
1047 st->cur_dts == AV_NOPTS_VALUE ||
1051 delay = st->codec->has_b_frames;
1052 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1054 shift = st->first_dts - RELATIVE_TS_BASE;
1056 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1057 pts_buffer[i] = AV_NOPTS_VALUE;
1059 if (is_relative(pts))
1062 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1063 if (pktl->pkt.stream_index != stream_index)
1065 if (is_relative(pktl->pkt.pts))
1066 pktl->pkt.pts += shift;
1068 if (is_relative(pktl->pkt.dts))
1069 pktl->pkt.dts += shift;
1071 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1072 st->start_time = pktl->pkt.pts;
1074 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1075 pts_buffer[0] = pktl->pkt.pts;
1076 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1077 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1079 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
1083 if (st->start_time == AV_NOPTS_VALUE)
1084 st->start_time = pts;
1087 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1088 int stream_index, int duration)
1090 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1091 int64_t cur_dts = RELATIVE_TS_BASE;
1093 if (st->first_dts != AV_NOPTS_VALUE) {
1094 if (st->update_initial_durations_done)
1096 st->update_initial_durations_done = 1;
1097 cur_dts = st->first_dts;
1098 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1099 if (pktl->pkt.stream_index == stream_index) {
1100 if (pktl->pkt.pts != pktl->pkt.dts ||
1101 pktl->pkt.dts != AV_NOPTS_VALUE ||
1104 cur_dts -= duration;
1107 if (pktl && pktl->pkt.dts != st->first_dts) {
1108 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1109 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1113 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1116 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1117 st->first_dts = cur_dts;
1118 } else if (st->cur_dts != RELATIVE_TS_BASE)
1121 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1122 if (pktl->pkt.stream_index != stream_index)
1124 if (pktl->pkt.pts == pktl->pkt.dts &&
1125 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1126 !pktl->pkt.duration) {
1127 pktl->pkt.dts = cur_dts;
1128 if (!st->codec->has_b_frames)
1129 pktl->pkt.pts = cur_dts;
1130 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1131 pktl->pkt.duration = duration;
1134 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1137 st->cur_dts = cur_dts;
1140 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1141 AVCodecParserContext *pc, AVPacket *pkt)
1143 int num, den, presentation_delayed, delay, i;
1145 AVRational duration;
1146 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1147 st->codec->codec_id != AV_CODEC_ID_HEVC;
1149 if (s->flags & AVFMT_FLAG_NOFILLIN)
1152 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1153 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1154 if (st->last_dts_for_order_check <= pkt->dts) {
1157 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1158 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1160 st->last_dts_for_order_check);
1161 st->dts_misordered++;
1163 if (st->dts_ordered + st->dts_misordered > 250) {
1164 st->dts_ordered >>= 1;
1165 st->dts_misordered >>= 1;
1169 st->last_dts_for_order_check = pkt->dts;
1170 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1171 pkt->dts = AV_NOPTS_VALUE;
1174 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1175 pkt->dts = AV_NOPTS_VALUE;
1177 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1178 && !st->codec->has_b_frames)
1179 //FIXME Set low_delay = 0 when has_b_frames = 1
1180 st->codec->has_b_frames = 1;
1182 /* do we have a video B-frame ? */
1183 delay = st->codec->has_b_frames;
1184 presentation_delayed = 0;
1186 /* XXX: need has_b_frame, but cannot get it if the codec is
1187 * not initialized */
1189 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1190 presentation_delayed = 1;
1192 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1193 st->pts_wrap_bits < 63 &&
1194 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1195 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1196 pkt->dts -= 1LL << st->pts_wrap_bits;
1198 pkt->pts += 1LL << st->pts_wrap_bits;
1201 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1202 * We take the conservative approach and discard both.
1203 * Note: If this is misbehaving for an H.264 file, then possibly
1204 * presentation_delayed is not set correctly. */
1205 if (delay == 1 && pkt->dts == pkt->pts &&
1206 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1207 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1208 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1209 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1210 pkt->dts = AV_NOPTS_VALUE;
1213 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1214 if (pkt->duration == 0) {
1215 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1217 duration = (AVRational) {num, den};
1218 pkt->duration = av_rescale_rnd(1,
1219 num * (int64_t) st->time_base.den,
1220 den * (int64_t) st->time_base.num,
1225 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1226 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1228 /* Correct timestamps with byte offset if demuxers only have timestamps
1229 * on packet boundaries */
1230 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1231 /* this will estimate bitrate based on this frame's duration and size */
1232 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1233 if (pkt->pts != AV_NOPTS_VALUE)
1235 if (pkt->dts != AV_NOPTS_VALUE)
1239 /* This may be redundant, but it should not hurt. */
1240 if (pkt->dts != AV_NOPTS_VALUE &&
1241 pkt->pts != AV_NOPTS_VALUE &&
1242 pkt->pts > pkt->dts)
1243 presentation_delayed = 1;
1246 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1247 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1248 pkt->stream_index, pc, pkt->duration);
1249 /* Interpolate PTS and DTS if they are not present. We skip H264
1250 * currently because delay and has_b_frames are not reliably set. */
1251 if ((delay == 0 || (delay == 1 && pc)) &&
1253 if (presentation_delayed) {
1254 /* DTS = decompression timestamp */
1255 /* PTS = presentation timestamp */
1256 if (pkt->dts == AV_NOPTS_VALUE)
1257 pkt->dts = st->last_IP_pts;
1258 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1259 if (pkt->dts == AV_NOPTS_VALUE)
1260 pkt->dts = st->cur_dts;
1262 /* This is tricky: the dts must be incremented by the duration
1263 * of the frame we are displaying, i.e. the last I- or P-frame. */
1264 if (st->last_IP_duration == 0)
1265 st->last_IP_duration = pkt->duration;
1266 if (pkt->dts != AV_NOPTS_VALUE)
1267 st->cur_dts = pkt->dts + st->last_IP_duration;
1268 st->last_IP_duration = pkt->duration;
1269 st->last_IP_pts = pkt->pts;
1270 /* Cannot compute PTS if not present (we can compute it only
1271 * by knowing the future. */
1272 } else if (pkt->pts != AV_NOPTS_VALUE ||
1273 pkt->dts != AV_NOPTS_VALUE ||
1276 /* presentation is not delayed : PTS and DTS are the same */
1277 if (pkt->pts == AV_NOPTS_VALUE)
1278 pkt->pts = pkt->dts;
1279 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1281 if (pkt->pts == AV_NOPTS_VALUE)
1282 pkt->pts = st->cur_dts;
1283 pkt->dts = pkt->pts;
1284 if (pkt->pts != AV_NOPTS_VALUE)
1285 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1289 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1290 st->pts_buffer[0] = pkt->pts;
1291 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1292 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1294 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1296 // We skipped it above so we try here.
1298 // This should happen on the first packet
1299 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1300 if (pkt->dts > st->cur_dts)
1301 st->cur_dts = pkt->dts;
1303 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1304 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1307 if (is_intra_only(st->codec))
1308 pkt->flags |= AV_PKT_FLAG_KEY;
1310 pkt->convergence_duration = pc->convergence_duration;
1313 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1316 AVPacketList *pktl = *pkt_buf;
1317 *pkt_buf = pktl->next;
1318 av_free_packet(&pktl->pkt);
1321 *pkt_buf_end = NULL;
1325 * Parse a packet, add all split parts to parse_queue.
1327 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1329 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1331 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1332 AVStream *st = s->streams[stream_index];
1333 uint8_t *data = pkt ? pkt->data : NULL;
1334 int size = pkt ? pkt->size : 0;
1335 int ret = 0, got_output = 0;
1338 av_init_packet(&flush_pkt);
1341 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1342 // preserve 0-size sync packets
1343 compute_pkt_fields(s, st, st->parser, pkt);
1346 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1349 av_init_packet(&out_pkt);
1350 len = av_parser_parse2(st->parser, st->codec,
1351 &out_pkt.data, &out_pkt.size, data, size,
1352 pkt->pts, pkt->dts, pkt->pos);
1354 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1356 /* increment read pointer */
1360 got_output = !!out_pkt.size;
1365 if (pkt->side_data) {
1366 out_pkt.side_data = pkt->side_data;
1367 out_pkt.side_data_elems = pkt->side_data_elems;
1368 pkt->side_data = NULL;
1369 pkt->side_data_elems = 0;
1372 /* set the duration */
1373 out_pkt.duration = 0;
1374 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1375 if (st->codec->sample_rate > 0) {
1377 av_rescale_q_rnd(st->parser->duration,
1378 (AVRational) { 1, st->codec->sample_rate },
1384 out_pkt.stream_index = st->index;
1385 out_pkt.pts = st->parser->pts;
1386 out_pkt.dts = st->parser->dts;
1387 out_pkt.pos = st->parser->pos;
1389 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1390 out_pkt.pos = st->parser->frame_offset;
1392 if (st->parser->key_frame == 1 ||
1393 (st->parser->key_frame == -1 &&
1394 st->parser->pict_type == AV_PICTURE_TYPE_I))
1395 out_pkt.flags |= AV_PKT_FLAG_KEY;
1397 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1398 out_pkt.flags |= AV_PKT_FLAG_KEY;
1400 compute_pkt_fields(s, st, st->parser, &out_pkt);
1402 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1403 out_pkt.buf = pkt->buf;
1405 #if FF_API_DESTRUCT_PACKET
1406 FF_DISABLE_DEPRECATION_WARNINGS
1407 out_pkt.destruct = pkt->destruct;
1408 pkt->destruct = NULL;
1409 FF_ENABLE_DEPRECATION_WARNINGS
1412 if ((ret = av_dup_packet(&out_pkt)) < 0)
1415 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1416 av_free_packet(&out_pkt);
1417 ret = AVERROR(ENOMEM);
1422 /* end of the stream => close and free the parser */
1423 if (pkt == &flush_pkt) {
1424 av_parser_close(st->parser);
1429 av_free_packet(pkt);
1433 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1434 AVPacketList **pkt_buffer_end,
1438 av_assert0(*pkt_buffer);
1441 *pkt_buffer = pktl->next;
1443 *pkt_buffer_end = NULL;
1448 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1450 int ret = 0, i, got_packet = 0;
1452 av_init_packet(pkt);
1454 while (!got_packet && !s->parse_queue) {
1458 /* read next packet */
1459 ret = ff_read_packet(s, &cur_pkt);
1461 if (ret == AVERROR(EAGAIN))
1463 /* flush the parsers */
1464 for (i = 0; i < s->nb_streams; i++) {
1466 if (st->parser && st->need_parsing)
1467 parse_packet(s, NULL, st->index);
1469 /* all remaining packets are now in parse_queue =>
1470 * really terminate parsing */
1474 st = s->streams[cur_pkt.stream_index];
1476 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1477 cur_pkt.dts != AV_NOPTS_VALUE &&
1478 cur_pkt.pts < cur_pkt.dts) {
1479 av_log(s, AV_LOG_WARNING,
1480 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1481 cur_pkt.stream_index,
1482 av_ts2str(cur_pkt.pts),
1483 av_ts2str(cur_pkt.dts),
1486 if (s->debug & FF_FDEBUG_TS)
1487 av_log(s, AV_LOG_DEBUG,
1488 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1489 cur_pkt.stream_index,
1490 av_ts2str(cur_pkt.pts),
1491 av_ts2str(cur_pkt.dts),
1492 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1494 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1495 st->parser = av_parser_init(st->codec->codec_id);
1497 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1498 "%s, packets or times may be invalid.\n",
1499 avcodec_get_name(st->codec->codec_id));
1500 /* no parser available: just output the raw packets */
1501 st->need_parsing = AVSTREAM_PARSE_NONE;
1502 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1503 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1504 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1505 st->parser->flags |= PARSER_FLAG_ONCE;
1506 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1507 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1510 if (!st->need_parsing || !st->parser) {
1511 /* no parsing needed: we just output the packet as is */
1513 compute_pkt_fields(s, st, NULL, pkt);
1514 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1515 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1516 ff_reduce_index(s, st->index);
1517 av_add_index_entry(st, pkt->pos, pkt->dts,
1518 0, 0, AVINDEX_KEYFRAME);
1521 } else if (st->discard < AVDISCARD_ALL) {
1522 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1526 av_free_packet(&cur_pkt);
1528 if (pkt->flags & AV_PKT_FLAG_KEY)
1529 st->skip_to_keyframe = 0;
1530 if (st->skip_to_keyframe) {
1531 av_free_packet(&cur_pkt);
1539 if (!got_packet && s->parse_queue)
1540 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1543 AVStream *st = s->streams[pkt->stream_index];
1544 if (st->skip_samples) {
1545 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1547 AV_WL32(p, st->skip_samples);
1548 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1550 st->skip_samples = 0;
1553 if (st->inject_global_side_data) {
1554 for (i = 0; i < st->nb_side_data; i++) {
1555 AVPacketSideData *src_sd = &st->side_data[i];
1558 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1561 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1563 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1567 memcpy(dst_data, src_sd->data, src_sd->size);
1569 st->inject_global_side_data = 0;
1572 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1573 av_packet_merge_side_data(pkt);
1576 if (s->debug & FF_FDEBUG_TS)
1577 av_log(s, AV_LOG_DEBUG,
1578 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1579 "size=%d, duration=%d, flags=%d\n",
1581 av_ts2str(pkt->pts),
1582 av_ts2str(pkt->dts),
1583 pkt->size, pkt->duration, pkt->flags);
1588 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1590 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1596 ret = s->packet_buffer
1597 ? read_from_packet_buffer(&s->packet_buffer,
1598 &s->packet_buffer_end, pkt)
1599 : read_frame_internal(s, pkt);
1606 AVPacketList *pktl = s->packet_buffer;
1609 AVPacket *next_pkt = &pktl->pkt;
1611 if (next_pkt->dts != AV_NOPTS_VALUE) {
1612 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1613 // last dts seen for this stream. if any of packets following
1614 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1615 int64_t last_dts = next_pkt->dts;
1616 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1617 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1618 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1619 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1621 next_pkt->pts = pktl->pkt.dts;
1623 if (last_dts != AV_NOPTS_VALUE) {
1624 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1625 last_dts = pktl->pkt.dts;
1630 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1631 // Fixing the last reference frame had none pts issue (For MXF etc).
1632 // We only do this when
1634 // 2. we are not able to resolve a pts value for current packet.
1635 // 3. the packets for this stream at the end of the files had valid dts.
1636 next_pkt->pts = last_dts + next_pkt->duration;
1638 pktl = s->packet_buffer;
1641 /* read packet from packet buffer, if there is data */
1642 st = s->streams[next_pkt->stream_index];
1643 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1644 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1645 ret = read_from_packet_buffer(&s->packet_buffer,
1646 &s->packet_buffer_end, pkt);
1651 ret = read_frame_internal(s, pkt);
1653 if (pktl && ret != AVERROR(EAGAIN)) {
1660 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1661 &s->packet_buffer_end)) < 0)
1662 return AVERROR(ENOMEM);
1667 st = s->streams[pkt->stream_index];
1668 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1669 ff_reduce_index(s, st->index);
1670 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1673 if (is_relative(pkt->dts))
1674 pkt->dts -= RELATIVE_TS_BASE;
1675 if (is_relative(pkt->pts))
1676 pkt->pts -= RELATIVE_TS_BASE;
1681 /* XXX: suppress the packet queue */
1682 static void flush_packet_queue(AVFormatContext *s)
1684 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1685 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1686 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1688 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1691 /*******************************************************/
1694 int av_find_default_stream_index(AVFormatContext *s)
1696 int first_audio_index = -1;
1700 if (s->nb_streams <= 0)
1702 for (i = 0; i < s->nb_streams; i++) {
1704 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1705 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1708 if (first_audio_index < 0 &&
1709 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1710 first_audio_index = i;
1712 return first_audio_index >= 0 ? first_audio_index : 0;
1715 /** Flush the frame reader. */
1716 void ff_read_frame_flush(AVFormatContext *s)
1721 flush_packet_queue(s);
1723 /* Reset read state for each stream. */
1724 for (i = 0; i < s->nb_streams; i++) {
1728 av_parser_close(st->parser);
1731 st->last_IP_pts = AV_NOPTS_VALUE;
1732 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1733 if (st->first_dts == AV_NOPTS_VALUE)
1734 st->cur_dts = RELATIVE_TS_BASE;
1736 /* We set the current DTS to an unspecified origin. */
1737 st->cur_dts = AV_NOPTS_VALUE;
1739 st->probe_packets = MAX_PROBE_PACKETS;
1741 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1742 st->pts_buffer[j] = AV_NOPTS_VALUE;
1744 if (s->internal->inject_global_side_data)
1745 st->inject_global_side_data = 1;
1749 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1753 for (i = 0; i < s->nb_streams; i++) {
1754 AVStream *st = s->streams[i];
1757 av_rescale(timestamp,
1758 st->time_base.den * (int64_t) ref_st->time_base.num,
1759 st->time_base.num * (int64_t) ref_st->time_base.den);
1763 void ff_reduce_index(AVFormatContext *s, int stream_index)
1765 AVStream *st = s->streams[stream_index];
1766 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1768 if ((unsigned) st->nb_index_entries >= max_entries) {
1770 for (i = 0; 2 * i < st->nb_index_entries; i++)
1771 st->index_entries[i] = st->index_entries[2 * i];
1772 st->nb_index_entries = i;
1776 int ff_add_index_entry(AVIndexEntry **index_entries,
1777 int *nb_index_entries,
1778 unsigned int *index_entries_allocated_size,
1779 int64_t pos, int64_t timestamp,
1780 int size, int distance, int flags)
1782 AVIndexEntry *entries, *ie;
1785 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1788 if (timestamp == AV_NOPTS_VALUE)
1789 return AVERROR(EINVAL);
1791 if (size < 0 || size > 0x3FFFFFFF)
1792 return AVERROR(EINVAL);
1794 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1795 timestamp -= RELATIVE_TS_BASE;
1797 entries = av_fast_realloc(*index_entries,
1798 index_entries_allocated_size,
1799 (*nb_index_entries + 1) *
1800 sizeof(AVIndexEntry));
1804 *index_entries = entries;
1806 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1807 timestamp, AVSEEK_FLAG_ANY);
1810 index = (*nb_index_entries)++;
1811 ie = &entries[index];
1812 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1814 ie = &entries[index];
1815 if (ie->timestamp != timestamp) {
1816 if (ie->timestamp <= timestamp)
1818 memmove(entries + index + 1, entries + index,
1819 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1820 (*nb_index_entries)++;
1821 } else if (ie->pos == pos && distance < ie->min_distance)
1822 // do not reduce the distance
1823 distance = ie->min_distance;
1827 ie->timestamp = timestamp;
1828 ie->min_distance = distance;
1835 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1836 int size, int distance, int flags)
1838 timestamp = wrap_timestamp(st, timestamp);
1839 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1840 &st->index_entries_allocated_size, pos,
1841 timestamp, size, distance, flags);
1844 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1845 int64_t wanted_timestamp, int flags)
1853 // Optimize appending index entries at the end.
1854 if (b && entries[b - 1].timestamp < wanted_timestamp)
1859 timestamp = entries[m].timestamp;
1860 if (timestamp >= wanted_timestamp)
1862 if (timestamp <= wanted_timestamp)
1865 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1867 if (!(flags & AVSEEK_FLAG_ANY))
1868 while (m >= 0 && m < nb_entries &&
1869 !(entries[m].flags & AVINDEX_KEYFRAME))
1870 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1872 if (m == nb_entries)
1877 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1879 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1880 wanted_timestamp, flags);
1883 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1884 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1886 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1887 if (stream_index >= 0)
1888 ts = wrap_timestamp(s->streams[stream_index], ts);
1892 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1893 int64_t target_ts, int flags)
1895 AVInputFormat *avif = s->iformat;
1896 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1897 int64_t ts_min, ts_max, ts;
1902 if (stream_index < 0)
1905 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1908 ts_min = AV_NOPTS_VALUE;
1909 pos_limit = -1; // GCC falsely says it may be uninitialized.
1911 st = s->streams[stream_index];
1912 if (st->index_entries) {
1915 /* FIXME: Whole function must be checked for non-keyframe entries in
1916 * index case, especially read_timestamp(). */
1917 index = av_index_search_timestamp(st, target_ts,
1918 flags | AVSEEK_FLAG_BACKWARD);
1919 index = FFMAX(index, 0);
1920 e = &st->index_entries[index];
1922 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1924 ts_min = e->timestamp;
1925 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1926 pos_min, av_ts2str(ts_min));
1928 av_assert1(index == 0);
1931 index = av_index_search_timestamp(st, target_ts,
1932 flags & ~AVSEEK_FLAG_BACKWARD);
1933 av_assert0(index < st->nb_index_entries);
1935 e = &st->index_entries[index];
1936 av_assert1(e->timestamp >= target_ts);
1938 ts_max = e->timestamp;
1939 pos_limit = pos_max - e->min_distance;
1940 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1941 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1945 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1946 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1951 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1954 ff_read_frame_flush(s);
1955 ff_update_cur_dts(s, st, ts);
1960 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1961 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1963 int64_t step = 1024;
1964 int64_t limit, ts_max;
1965 int64_t filesize = avio_size(s->pb);
1966 int64_t pos_max = filesize - 1;
1969 pos_max = FFMAX(0, (pos_max) - step);
1970 ts_max = ff_read_timestamp(s, stream_index,
1971 &pos_max, limit, read_timestamp);
1973 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1974 if (ts_max == AV_NOPTS_VALUE)
1978 int64_t tmp_pos = pos_max + 1;
1979 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1980 &tmp_pos, INT64_MAX, read_timestamp);
1981 if (tmp_ts == AV_NOPTS_VALUE)
1983 av_assert0(tmp_pos > pos_max);
1986 if (tmp_pos >= filesize)
1998 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1999 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2000 int64_t ts_min, int64_t ts_max,
2001 int flags, int64_t *ts_ret,
2002 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2003 int64_t *, int64_t))
2010 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2012 if (ts_min == AV_NOPTS_VALUE) {
2013 pos_min = s->data_offset;
2014 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2015 if (ts_min == AV_NOPTS_VALUE)
2019 if (ts_min >= target_ts) {
2024 if (ts_max == AV_NOPTS_VALUE) {
2025 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2027 pos_limit = pos_max;
2030 if (ts_max <= target_ts) {
2035 if (ts_min > ts_max)
2037 else if (ts_min == ts_max)
2038 pos_limit = pos_min;
2041 while (pos_min < pos_limit) {
2043 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2044 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2045 assert(pos_limit <= pos_max);
2047 if (no_change == 0) {
2048 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2049 // interpolate position (better than dichotomy)
2050 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2052 pos_min - approximate_keyframe_distance;
2053 } else if (no_change == 1) {
2054 // bisection if interpolation did not change min / max pos last time
2055 pos = (pos_min + pos_limit) >> 1;
2057 /* linear search if bisection failed, can only happen if there
2058 * are very few or no keyframes between min/max */
2063 else if (pos > pos_limit)
2067 // May pass pos_limit instead of -1.
2068 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2073 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2074 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2075 pos_min, pos, pos_max,
2076 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2077 pos_limit, start_pos, no_change);
2078 if (ts == AV_NOPTS_VALUE) {
2079 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2082 assert(ts != AV_NOPTS_VALUE);
2083 if (target_ts <= ts) {
2084 pos_limit = start_pos - 1;
2088 if (target_ts >= ts) {
2094 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2095 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2098 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2100 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2101 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2102 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2108 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2109 int64_t pos, int flags)
2111 int64_t pos_min, pos_max;
2113 pos_min = s->data_offset;
2114 pos_max = avio_size(s->pb) - 1;
2118 else if (pos > pos_max)
2121 avio_seek(s->pb, pos, SEEK_SET);
2123 s->io_repositioned = 1;
2128 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2129 int64_t timestamp, int flags)
2136 st = s->streams[stream_index];
2138 index = av_index_search_timestamp(st, timestamp, flags);
2140 if (index < 0 && st->nb_index_entries &&
2141 timestamp < st->index_entries[0].timestamp)
2144 if (index < 0 || index == st->nb_index_entries - 1) {
2148 if (st->nb_index_entries) {
2149 av_assert0(st->index_entries);
2150 ie = &st->index_entries[st->nb_index_entries - 1];
2151 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2153 ff_update_cur_dts(s, st, ie->timestamp);
2155 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2161 read_status = av_read_frame(s, &pkt);
2162 } while (read_status == AVERROR(EAGAIN));
2163 if (read_status < 0)
2165 av_free_packet(&pkt);
2166 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2167 if (pkt.flags & AV_PKT_FLAG_KEY)
2169 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2170 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);
2175 index = av_index_search_timestamp(st, timestamp, flags);
2180 ff_read_frame_flush(s);
2181 if (s->iformat->read_seek)
2182 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2184 ie = &st->index_entries[index];
2185 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2187 ff_update_cur_dts(s, st, ie->timestamp);
2192 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2193 int64_t timestamp, int flags)
2198 if (flags & AVSEEK_FLAG_BYTE) {
2199 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2201 ff_read_frame_flush(s);
2202 return seek_frame_byte(s, stream_index, timestamp, flags);
2205 if (stream_index < 0) {
2206 stream_index = av_find_default_stream_index(s);
2207 if (stream_index < 0)
2210 st = s->streams[stream_index];
2211 /* timestamp for default must be expressed in AV_TIME_BASE units */
2212 timestamp = av_rescale(timestamp, st->time_base.den,
2213 AV_TIME_BASE * (int64_t) st->time_base.num);
2216 /* first, we try the format specific seek */
2217 if (s->iformat->read_seek) {
2218 ff_read_frame_flush(s);
2219 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2225 if (s->iformat->read_timestamp &&
2226 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2227 ff_read_frame_flush(s);
2228 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2229 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2230 ff_read_frame_flush(s);
2231 return seek_frame_generic(s, stream_index, timestamp, flags);
2236 int av_seek_frame(AVFormatContext *s, int stream_index,
2237 int64_t timestamp, int flags)
2241 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2242 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2243 if ((flags & AVSEEK_FLAG_BACKWARD))
2247 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2248 flags & ~AVSEEK_FLAG_BACKWARD);
2251 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2254 ret = avformat_queue_attached_pictures(s);
2259 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2260 int64_t ts, int64_t max_ts, int flags)
2262 if (min_ts > ts || max_ts < ts)
2264 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2265 return AVERROR(EINVAL);
2268 flags |= AVSEEK_FLAG_ANY;
2269 flags &= ~AVSEEK_FLAG_BACKWARD;
2271 if (s->iformat->read_seek2) {
2273 ff_read_frame_flush(s);
2275 if (stream_index == -1 && s->nb_streams == 1) {
2276 AVRational time_base = s->streams[0]->time_base;
2277 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2278 min_ts = av_rescale_rnd(min_ts, time_base.den,
2279 time_base.num * (int64_t)AV_TIME_BASE,
2280 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2281 max_ts = av_rescale_rnd(max_ts, time_base.den,
2282 time_base.num * (int64_t)AV_TIME_BASE,
2283 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2286 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2290 ret = avformat_queue_attached_pictures(s);
2294 if (s->iformat->read_timestamp) {
2295 // try to seek via read_timestamp()
2298 // Fall back on old API if new is not implemented but old is.
2299 // Note the old API has somewhat different semantics.
2300 if (s->iformat->read_seek || 1) {
2301 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2302 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2303 if (ret<0 && ts != min_ts && max_ts != ts) {
2304 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2306 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2311 // try some generic seek like seek_frame_generic() but with new ts semantics
2312 return -1; //unreachable
2315 /*******************************************************/
2318 * Return TRUE if the stream has accurate duration in any stream.
2320 * @return TRUE if the stream has accurate duration for at least one component.
2322 static int has_duration(AVFormatContext *ic)
2327 for (i = 0; i < ic->nb_streams; i++) {
2328 st = ic->streams[i];
2329 if (st->duration != AV_NOPTS_VALUE)
2332 if (ic->duration != AV_NOPTS_VALUE)
2338 * Estimate the stream timings from the one of each components.
2340 * Also computes the global bitrate if possible.
2342 static void update_stream_timings(AVFormatContext *ic)
2344 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2345 int64_t duration, duration1, filesize;
2350 start_time = INT64_MAX;
2351 start_time_text = INT64_MAX;
2352 end_time = INT64_MIN;
2353 duration = INT64_MIN;
2354 for (i = 0; i < ic->nb_streams; i++) {
2355 st = ic->streams[i];
2356 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2357 start_time1 = av_rescale_q(st->start_time, st->time_base,
2359 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2360 if (start_time1 < start_time_text)
2361 start_time_text = start_time1;
2363 start_time = FFMIN(start_time, start_time1);
2364 end_time1 = AV_NOPTS_VALUE;
2365 if (st->duration != AV_NOPTS_VALUE) {
2366 end_time1 = start_time1 +
2367 av_rescale_q(st->duration, st->time_base,
2369 end_time = FFMAX(end_time, end_time1);
2371 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2372 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2373 p->start_time = start_time1;
2374 if (p->end_time < end_time1)
2375 p->end_time = end_time1;
2378 if (st->duration != AV_NOPTS_VALUE) {
2379 duration1 = av_rescale_q(st->duration, st->time_base,
2381 duration = FFMAX(duration, duration1);
2384 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2385 start_time = start_time_text;
2386 else if (start_time > start_time_text)
2387 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2389 if (start_time != INT64_MAX) {
2390 ic->start_time = start_time;
2391 if (end_time != INT64_MIN) {
2392 if (ic->nb_programs) {
2393 for (i = 0; i < ic->nb_programs; i++) {
2394 p = ic->programs[i];
2395 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2396 duration = FFMAX(duration, p->end_time - p->start_time);
2399 duration = FFMAX(duration, end_time - start_time);
2402 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2403 ic->duration = duration;
2405 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2406 /* compute the bitrate */
2407 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2408 (double) ic->duration;
2409 if (bitrate >= 0 && bitrate <= INT_MAX)
2410 ic->bit_rate = bitrate;
2414 static void fill_all_stream_timings(AVFormatContext *ic)
2419 update_stream_timings(ic);
2420 for (i = 0; i < ic->nb_streams; i++) {
2421 st = ic->streams[i];
2422 if (st->start_time == AV_NOPTS_VALUE) {
2423 if (ic->start_time != AV_NOPTS_VALUE)
2424 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2426 if (ic->duration != AV_NOPTS_VALUE)
2427 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2433 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2435 int64_t filesize, duration;
2436 int i, show_warning = 0;
2439 /* if bit_rate is already set, we believe it */
2440 if (ic->bit_rate <= 0) {
2442 for (i = 0; i < ic->nb_streams; i++) {
2443 st = ic->streams[i];
2444 if (st->codec->bit_rate > 0) {
2445 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2449 bit_rate += st->codec->bit_rate;
2452 ic->bit_rate = bit_rate;
2455 /* if duration is already set, we believe it */
2456 if (ic->duration == AV_NOPTS_VALUE &&
2457 ic->bit_rate != 0) {
2458 filesize = ic->pb ? avio_size(ic->pb) : 0;
2460 for (i = 0; i < ic->nb_streams; i++) {
2461 st = ic->streams[i];
2462 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2463 && st->duration == AV_NOPTS_VALUE) {
2464 duration = av_rescale(8 * filesize, st->time_base.den,
2466 (int64_t) st->time_base.num);
2467 st->duration = duration;
2474 av_log(ic, AV_LOG_WARNING,
2475 "Estimating duration from bitrate, this may be inaccurate\n");
2478 #define DURATION_MAX_READ_SIZE 250000LL
2479 #define DURATION_MAX_RETRY 4
2481 /* only usable for MPEG-PS streams */
2482 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2484 AVPacket pkt1, *pkt = &pkt1;
2486 int num, den, read_size, i, ret;
2487 int found_duration = 0;
2489 int64_t filesize, offset, duration;
2492 /* flush packet queue */
2493 flush_packet_queue(ic);
2495 for (i = 0; i < ic->nb_streams; i++) {
2496 st = ic->streams[i];
2497 if (st->start_time == AV_NOPTS_VALUE &&
2498 st->first_dts == AV_NOPTS_VALUE &&
2499 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2500 av_log(st->codec, AV_LOG_WARNING,
2501 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2504 av_parser_close(st->parser);
2509 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2510 /* estimate the end time (duration) */
2511 /* XXX: may need to support wrapping */
2512 filesize = ic->pb ? avio_size(ic->pb) : 0;
2514 is_end = found_duration;
2515 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2519 avio_seek(ic->pb, offset, SEEK_SET);
2522 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2526 ret = ff_read_packet(ic, pkt);
2527 } while (ret == AVERROR(EAGAIN));
2530 read_size += pkt->size;
2531 st = ic->streams[pkt->stream_index];
2532 if (pkt->pts != AV_NOPTS_VALUE &&
2533 (st->start_time != AV_NOPTS_VALUE ||
2534 st->first_dts != AV_NOPTS_VALUE)) {
2535 if (pkt->duration == 0) {
2536 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2538 pkt->duration = av_rescale_rnd(1,
2539 num * (int64_t) st->time_base.den,
2540 den * (int64_t) st->time_base.num,
2544 duration = pkt->pts + pkt->duration;
2546 if (st->start_time != AV_NOPTS_VALUE)
2547 duration -= st->start_time;
2549 duration -= st->first_dts;
2551 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2552 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2553 st->duration = duration;
2554 st->info->last_duration = duration;
2557 av_free_packet(pkt);
2560 /* check if all audio/video streams have valid duration */
2563 for (i = 0; i < ic->nb_streams; i++) {
2564 st = ic->streams[i];
2565 switch (st->codec->codec_type) {
2566 case AVMEDIA_TYPE_VIDEO:
2567 case AVMEDIA_TYPE_AUDIO:
2568 if (st->duration == AV_NOPTS_VALUE)
2575 ++retry <= DURATION_MAX_RETRY);
2577 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2579 /* warn about audio/video streams which duration could not be estimated */
2580 for (i = 0; i < ic->nb_streams; i++) {
2581 st = ic->streams[i];
2582 if (st->duration == AV_NOPTS_VALUE) {
2583 switch (st->codec->codec_type) {
2584 case AVMEDIA_TYPE_VIDEO:
2585 case AVMEDIA_TYPE_AUDIO:
2586 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2587 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2589 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2593 fill_all_stream_timings(ic);
2595 avio_seek(ic->pb, old_offset, SEEK_SET);
2596 for (i = 0; i < ic->nb_streams; i++) {
2599 st = ic->streams[i];
2600 st->cur_dts = st->first_dts;
2601 st->last_IP_pts = AV_NOPTS_VALUE;
2602 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2603 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2604 st->pts_buffer[j] = AV_NOPTS_VALUE;
2608 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2612 /* get the file size, if possible */
2613 if (ic->iformat->flags & AVFMT_NOFILE) {
2616 file_size = avio_size(ic->pb);
2617 file_size = FFMAX(0, file_size);
2620 if ((!strcmp(ic->iformat->name, "mpeg") ||
2621 !strcmp(ic->iformat->name, "mpegts")) &&
2622 file_size && ic->pb->seekable) {
2623 /* get accurate estimate from the PTSes */
2624 estimate_timings_from_pts(ic, old_offset);
2625 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2626 } else if (has_duration(ic)) {
2627 /* at least one component has timings - we use them for all
2629 fill_all_stream_timings(ic);
2630 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2632 /* less precise: use bitrate info */
2633 estimate_timings_from_bit_rate(ic);
2634 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2636 update_stream_timings(ic);
2640 AVStream av_unused *st;
2641 for (i = 0; i < ic->nb_streams; i++) {
2642 st = ic->streams[i];
2643 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2644 (double) st->start_time / AV_TIME_BASE,
2645 (double) st->duration / AV_TIME_BASE);
2648 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2649 (double) ic->start_time / AV_TIME_BASE,
2650 (double) ic->duration / AV_TIME_BASE,
2651 ic->bit_rate / 1000);
2655 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2657 AVCodecContext *avctx = st->codec;
2659 #define FAIL(errmsg) do { \
2661 *errmsg_ptr = errmsg; \
2665 if ( avctx->codec_id == AV_CODEC_ID_NONE
2666 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2667 FAIL("unknown codec");
2668 switch (avctx->codec_type) {
2669 case AVMEDIA_TYPE_AUDIO:
2670 if (!avctx->frame_size && determinable_frame_size(avctx))
2671 FAIL("unspecified frame size");
2672 if (st->info->found_decoder >= 0 &&
2673 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2674 FAIL("unspecified sample format");
2675 if (!avctx->sample_rate)
2676 FAIL("unspecified sample rate");
2677 if (!avctx->channels)
2678 FAIL("unspecified number of channels");
2679 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2680 FAIL("no decodable DTS frames");
2682 case AVMEDIA_TYPE_VIDEO:
2684 FAIL("unspecified size");
2685 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2686 FAIL("unspecified pixel format");
2687 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2688 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2689 FAIL("no frame in rv30/40 and no sar");
2691 case AVMEDIA_TYPE_SUBTITLE:
2692 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2693 FAIL("unspecified size");
2695 case AVMEDIA_TYPE_DATA:
2696 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2702 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2703 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2704 AVDictionary **options)
2706 const AVCodec *codec;
2707 int got_picture = 1, ret = 0;
2708 AVFrame *frame = av_frame_alloc();
2709 AVSubtitle subtitle;
2710 AVPacket pkt = *avpkt;
2713 return AVERROR(ENOMEM);
2715 if (!avcodec_is_open(st->codec) &&
2716 st->info->found_decoder <= 0 &&
2717 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2718 AVDictionary *thread_opt = NULL;
2720 codec = find_decoder(s, st, st->codec->codec_id);
2723 st->info->found_decoder = -st->codec->codec_id;
2728 /* Force thread count to 1 since the H.264 decoder will not extract
2729 * SPS and PPS to extradata during multi-threaded decoding. */
2730 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2731 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2733 av_dict_free(&thread_opt);
2735 st->info->found_decoder = -st->codec->codec_id;
2738 st->info->found_decoder = 1;
2739 } else if (!st->info->found_decoder)
2740 st->info->found_decoder = 1;
2742 if (st->info->found_decoder < 0) {
2747 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2749 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2750 (!st->codec_info_nb_frames &&
2751 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2753 switch (st->codec->codec_type) {
2754 case AVMEDIA_TYPE_VIDEO:
2755 ret = avcodec_decode_video2(st->codec, frame,
2756 &got_picture, &pkt);
2758 case AVMEDIA_TYPE_AUDIO:
2759 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2761 case AVMEDIA_TYPE_SUBTITLE:
2762 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2763 &got_picture, &pkt);
2771 st->nb_decoded_frames++;
2778 if (!pkt.data && !got_picture)
2782 av_frame_free(&frame);
2786 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2788 while (tags->id != AV_CODEC_ID_NONE) {
2796 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2799 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2800 if (tag == tags[i].tag)
2802 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2803 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2805 return AV_CODEC_ID_NONE;
2808 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2813 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2815 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2817 return AV_CODEC_ID_NONE;
2822 if (sflags & (1 << (bps - 1))) {
2825 return AV_CODEC_ID_PCM_S8;
2827 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2829 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2831 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2833 return AV_CODEC_ID_NONE;
2838 return AV_CODEC_ID_PCM_U8;
2840 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2842 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2844 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2846 return AV_CODEC_ID_NONE;
2852 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2855 if (!av_codec_get_tag2(tags, id, &tag))
2860 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2864 for (i = 0; tags && tags[i]; i++) {
2865 const AVCodecTag *codec_tags = tags[i];
2866 while (codec_tags->id != AV_CODEC_ID_NONE) {
2867 if (codec_tags->id == id) {
2868 *tag = codec_tags->tag;
2877 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2880 for (i = 0; tags && tags[i]; i++) {
2881 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2882 if (id != AV_CODEC_ID_NONE)
2885 return AV_CODEC_ID_NONE;
2888 static void compute_chapters_end(AVFormatContext *s)
2891 int64_t max_time = s->duration +
2892 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2894 for (i = 0; i < s->nb_chapters; i++)
2895 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2896 AVChapter *ch = s->chapters[i];
2897 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2901 for (j = 0; j < s->nb_chapters; j++) {
2902 AVChapter *ch1 = s->chapters[j];
2903 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2905 if (j != i && next_start > ch->start && next_start < end)
2908 ch->end = (end == INT64_MAX) ? ch->start : end;
2912 static int get_std_framerate(int i)
2915 return (i + 1) * 1001;
2917 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2920 /* Is the time base unreliable?
2921 * This is a heuristic to balance between quick acceptance of the values in
2922 * the headers vs. some extra checks.
2923 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2924 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2925 * And there are "variable" fps files this needs to detect as well. */
2926 static int tb_unreliable(AVCodecContext *c)
2928 if (c->time_base.den >= 101L * c->time_base.num ||
2929 c->time_base.den < 5L * c->time_base.num ||
2930 // c->codec_tag == AV_RL32("DIVX") ||
2931 // c->codec_tag == AV_RL32("XVID") ||
2932 c->codec_tag == AV_RL32("mp4v") ||
2933 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2934 c->codec_id == AV_CODEC_ID_GIF ||
2935 c->codec_id == AV_CODEC_ID_H264)
2940 #if FF_API_FORMAT_PARAMETERS
2941 int av_find_stream_info(AVFormatContext *ic)
2943 return avformat_find_stream_info(ic, NULL);
2947 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2951 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2952 avctx->extradata_size = 0;
2953 return AVERROR(EINVAL);
2955 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2956 if (avctx->extradata) {
2957 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2958 avctx->extradata_size = size;
2961 avctx->extradata_size = 0;
2962 ret = AVERROR(ENOMEM);
2967 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2969 int ret = ff_alloc_extradata(avctx, size);
2972 ret = avio_read(pb, avctx->extradata, size);
2974 av_freep(&avctx->extradata);
2975 avctx->extradata_size = 0;
2976 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2977 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2983 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2986 int64_t last = st->info->last_dts;
2988 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2989 && ts - (uint64_t)last < INT64_MAX) {
2990 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2991 int64_t duration = ts - last;
2993 if (!st->info->duration_error)
2994 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2995 if (!st->info->duration_error)
2996 return AVERROR(ENOMEM);
2998 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2999 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3000 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3001 if (st->info->duration_error[0][1][i] < 1e10) {
3002 int framerate = get_std_framerate(i);
3003 double sdts = dts*framerate/(1001*12);
3004 for (j= 0; j<2; j++) {
3005 int64_t ticks = llrint(sdts+j*0.5);
3006 double error= sdts - ticks + j*0.5;
3007 st->info->duration_error[j][0][i] += error;
3008 st->info->duration_error[j][1][i] += error*error;
3012 st->info->duration_count++;
3013 st->info->rfps_duration_sum += duration;
3015 if (st->info->duration_count % 10 == 0) {
3016 int n = st->info->duration_count;
3017 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3018 if (st->info->duration_error[0][1][i] < 1e10) {
3019 double a0 = st->info->duration_error[0][0][i] / n;
3020 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3021 double a1 = st->info->duration_error[1][0][i] / n;
3022 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3023 if (error0 > 0.04 && error1 > 0.04) {
3024 st->info->duration_error[0][1][i] = 2e10;
3025 st->info->duration_error[1][1][i] = 2e10;
3031 // ignore the first 4 values, they might have some random jitter
3032 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3033 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3035 if (ts != AV_NOPTS_VALUE)
3036 st->info->last_dts = ts;
3041 void ff_rfps_calculate(AVFormatContext *ic)
3045 for (i = 0; i < ic->nb_streams; i++) {
3046 AVStream *st = ic->streams[i];
3048 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3050 // the check for tb_unreliable() is not completely correct, since this is not about handling
3051 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3052 // ipmovie.c produces.
3053 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)
3054 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);
3055 if (st->info->duration_count>1 && !st->r_frame_rate.num
3056 && tb_unreliable(st->codec)) {
3058 double best_error= 0.01;
3059 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3061 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3064 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3066 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3069 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3072 for (k= 0; k<2; k++) {
3073 int n = st->info->duration_count;
3074 double a= st->info->duration_error[k][0][j] / n;
3075 double error= st->info->duration_error[k][1][j]/n - a*a;
3077 if (error < best_error && best_error> 0.000000001) {
3079 num = get_std_framerate(j);
3082 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3085 // do not increase frame rate by more than 1 % in order to match a standard rate.
3086 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3087 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3089 if ( !st->avg_frame_rate.num
3090 && st->r_frame_rate.num && st->info->rfps_duration_sum
3091 && st->info->codec_info_duration <= 0
3092 && st->info->duration_count > 2
3093 && 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
3095 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3096 st->avg_frame_rate = st->r_frame_rate;
3099 av_freep(&st->info->duration_error);
3100 st->info->last_dts = AV_NOPTS_VALUE;
3101 st->info->duration_count = 0;
3102 st->info->rfps_duration_sum = 0;
3106 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3108 int i, count, ret = 0, j;
3111 AVPacket pkt1, *pkt;
3112 int64_t old_offset = avio_tell(ic->pb);
3113 // new streams might appear, no options for those
3114 int orig_nb_streams = ic->nb_streams;
3115 int flush_codecs = ic->probesize > 0;
3116 int64_t max_analyze_duration = ic->max_analyze_duration2;
3117 if (!max_analyze_duration)
3118 max_analyze_duration = ic->max_analyze_duration;
3120 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3122 if (!max_analyze_duration) {
3123 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3124 max_analyze_duration = 10*AV_TIME_BASE;
3126 max_analyze_duration = 5*AV_TIME_BASE;
3130 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3131 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3133 for (i = 0; i < ic->nb_streams; i++) {
3134 const AVCodec *codec;
3135 AVDictionary *thread_opt = NULL;
3136 st = ic->streams[i];
3138 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3139 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3140 /* if (!st->time_base.num)
3142 if (!st->codec->time_base.num)
3143 st->codec->time_base = st->time_base;
3145 // only for the split stuff
3146 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3147 st->parser = av_parser_init(st->codec->codec_id);
3149 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3150 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3151 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3152 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3154 } else if (st->need_parsing) {
3155 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3156 "%s, packets or times may be invalid.\n",
3157 avcodec_get_name(st->codec->codec_id));
3160 codec = find_decoder(ic, st, st->codec->codec_id);
3162 /* Force thread count to 1 since the H.264 decoder will not extract
3163 * SPS and PPS to extradata during multi-threaded decoding. */
3164 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3166 /* Ensure that subtitle_header is properly set. */
3167 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3168 && codec && !st->codec->codec) {
3169 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3170 av_log(ic, AV_LOG_WARNING,
3171 "Failed to open codec in av_find_stream_info\n");
3174 // Try to just open decoders, in case this is enough to get parameters.
3175 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3176 if (codec && !st->codec->codec)
3177 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3178 av_log(ic, AV_LOG_WARNING,
3179 "Failed to open codec in av_find_stream_info\n");
3182 av_dict_free(&thread_opt);
3185 for (i = 0; i < ic->nb_streams; i++) {
3186 #if FF_API_R_FRAME_RATE
3187 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3189 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3190 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3196 if (ff_check_interrupt(&ic->interrupt_callback)) {
3198 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3202 /* check if one codec still needs to be handled */
3203 for (i = 0; i < ic->nb_streams; i++) {
3204 int fps_analyze_framecount = 20;
3206 st = ic->streams[i];
3207 if (!has_codec_parameters(st, NULL))
3209 /* If the timebase is coarse (like the usual millisecond precision
3210 * of mkv), we need to analyze more frames to reliably arrive at
3211 * the correct fps. */
3212 if (av_q2d(st->time_base) > 0.0005)
3213 fps_analyze_framecount *= 2;
3214 if (!tb_unreliable(st->codec))
3215 fps_analyze_framecount = 0;
3216 if (ic->fps_probe_size >= 0)
3217 fps_analyze_framecount = ic->fps_probe_size;
3218 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3219 fps_analyze_framecount = 0;
3220 /* variable fps and no guess at the real fps */
3221 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3222 st->info->duration_count < fps_analyze_framecount &&
3223 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3225 if (st->parser && st->parser->parser->split &&
3226 !st->codec->extradata)
3228 if (st->first_dts == AV_NOPTS_VALUE &&
3229 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3230 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3231 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3234 if (i == ic->nb_streams) {
3235 /* NOTE: If the format has no header, then we need to read some
3236 * packets to get most of the streams, so we cannot stop here. */
3237 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3238 /* If we found the info for all the codecs, we can stop. */
3240 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3245 /* We did not get all the codec info, but we read too much data. */
3246 if (read_size >= ic->probesize) {
3248 av_log(ic, AV_LOG_DEBUG,
3249 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3250 for (i = 0; i < ic->nb_streams; i++)
3251 if (!ic->streams[i]->r_frame_rate.num &&
3252 ic->streams[i]->info->duration_count <= 1 &&
3253 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3254 strcmp(ic->iformat->name, "image2"))
3255 av_log(ic, AV_LOG_WARNING,
3256 "Stream #%d: not enough frames to estimate rate; "
3257 "consider increasing probesize\n", i);
3261 /* NOTE: A new stream can be added there if no header in file
3262 * (AVFMTCTX_NOHEADER). */
3263 ret = read_frame_internal(ic, &pkt1);
3264 if (ret == AVERROR(EAGAIN))
3272 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3273 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3275 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3276 &ic->packet_buffer_end);
3278 ret = AVERROR(ENOMEM);
3279 goto find_stream_info_err;
3281 if ((ret = av_dup_packet(pkt)) < 0)
3282 goto find_stream_info_err;
3285 st = ic->streams[pkt->stream_index];
3286 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3287 read_size += pkt->size;
3289 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3290 /* check for non-increasing dts */
3291 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3292 st->info->fps_last_dts >= pkt->dts) {
3293 av_log(ic, AV_LOG_DEBUG,
3294 "Non-increasing DTS in stream %d: packet %d with DTS "
3295 "%"PRId64", packet %d with DTS %"PRId64"\n",
3296 st->index, st->info->fps_last_dts_idx,
3297 st->info->fps_last_dts, st->codec_info_nb_frames,
3299 st->info->fps_first_dts =
3300 st->info->fps_last_dts = AV_NOPTS_VALUE;
3302 /* Check for a discontinuity in dts. If the difference in dts
3303 * is more than 1000 times the average packet duration in the
3304 * sequence, we treat it as a discontinuity. */
3305 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3306 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3307 (pkt->dts - st->info->fps_last_dts) / 1000 >
3308 (st->info->fps_last_dts - st->info->fps_first_dts) /
3309 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3310 av_log(ic, AV_LOG_WARNING,
3311 "DTS discontinuity in stream %d: packet %d with DTS "
3312 "%"PRId64", packet %d with DTS %"PRId64"\n",
3313 st->index, st->info->fps_last_dts_idx,
3314 st->info->fps_last_dts, st->codec_info_nb_frames,
3316 st->info->fps_first_dts =
3317 st->info->fps_last_dts = AV_NOPTS_VALUE;
3320 /* update stored dts values */
3321 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3322 st->info->fps_first_dts = pkt->dts;
3323 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3325 st->info->fps_last_dts = pkt->dts;
3326 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3328 if (st->codec_info_nb_frames>1) {
3331 if (st->time_base.den > 0)
3332 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3333 if (st->avg_frame_rate.num > 0)
3334 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3337 && st->codec_info_nb_frames>30
3338 && st->info->fps_first_dts != AV_NOPTS_VALUE
3339 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3340 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3342 if (t >= max_analyze_duration) {
3343 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3344 max_analyze_duration,
3348 if (pkt->duration) {
3349 st->info->codec_info_duration += pkt->duration;
3350 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3353 #if FF_API_R_FRAME_RATE
3354 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3355 ff_rfps_add_frame(ic, st, pkt->dts);
3357 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3358 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3359 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3360 if (ff_alloc_extradata(st->codec, i))
3361 return AVERROR(ENOMEM);
3362 memcpy(st->codec->extradata, pkt->data,
3363 st->codec->extradata_size);
3367 /* If still no information, we try to open the codec and to
3368 * decompress the frame. We try to avoid that in most cases as
3369 * it takes longer and uses more memory. For MPEG-4, we need to
3370 * decompress for QuickTime.
3372 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3373 * least one frame of codec data, this makes sure the codec initializes
3374 * the channel configuration and does not only trust the values from
3376 try_decode_frame(ic, st, pkt,
3377 (options && i < orig_nb_streams) ? &options[i] : NULL);
3379 st->codec_info_nb_frames++;
3384 AVPacket empty_pkt = { 0 };
3386 av_init_packet(&empty_pkt);
3388 for (i = 0; i < ic->nb_streams; i++) {
3390 st = ic->streams[i];
3392 /* flush the decoders */
3393 if (st->info->found_decoder == 1) {
3395 err = try_decode_frame(ic, st, &empty_pkt,
3396 (options && i < orig_nb_streams)
3397 ? &options[i] : NULL);
3398 } while (err > 0 && !has_codec_parameters(st, NULL));
3401 av_log(ic, AV_LOG_INFO,
3402 "decoding for stream %d failed\n", st->index);
3407 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3409 // close codecs which were opened in try_decode_frame()
3410 for (i = 0; i < ic->nb_streams; i++) {
3411 st = ic->streams[i];
3412 avcodec_close(st->codec);
3415 ff_rfps_calculate(ic);
3417 for (i = 0; i < ic->nb_streams; i++) {
3418 st = ic->streams[i];
3419 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3420 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3421 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3422 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3423 st->codec->codec_tag= tag;
3426 /* estimate average framerate if not set by demuxer */
3427 if (st->info->codec_info_duration_fields &&
3428 !st->avg_frame_rate.num &&
3429 st->info->codec_info_duration) {
3431 double best_error = 0.01;
3433 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3434 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3435 st->info->codec_info_duration < 0)
3437 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3438 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3439 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3441 /* Round guessed framerate to a "standard" framerate if it's
3442 * within 1% of the original estimate. */
3443 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3444 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3445 double error = fabs(av_q2d(st->avg_frame_rate) /
3446 av_q2d(std_fps) - 1);
3448 if (error < best_error) {
3450 best_fps = std_fps.num;
3454 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3455 best_fps, 12 * 1001, INT_MAX);
3458 if (!st->r_frame_rate.num) {
3459 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3460 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3461 st->r_frame_rate.num = st->codec->time_base.den;
3462 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3464 st->r_frame_rate.num = st->time_base.den;
3465 st->r_frame_rate.den = st->time_base.num;
3468 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3469 if (!st->codec->bits_per_coded_sample)
3470 st->codec->bits_per_coded_sample =
3471 av_get_bits_per_sample(st->codec->codec_id);
3472 // set stream disposition based on audio service type
3473 switch (st->codec->audio_service_type) {
3474 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3475 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3477 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3478 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3480 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3481 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3483 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3484 st->disposition = AV_DISPOSITION_COMMENT;
3486 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3487 st->disposition = AV_DISPOSITION_KARAOKE;
3494 estimate_timings(ic, old_offset);
3496 if (ret >= 0 && ic->nb_streams)
3497 /* We could not have all the codec parameters before EOF. */
3499 for (i = 0; i < ic->nb_streams; i++) {
3501 st = ic->streams[i];
3502 if (!has_codec_parameters(st, &errmsg)) {
3504 avcodec_string(buf, sizeof(buf), st->codec, 0);
3505 av_log(ic, AV_LOG_WARNING,
3506 "Could not find codec parameters for stream %d (%s): %s\n"
3507 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3514 compute_chapters_end(ic);
3516 find_stream_info_err:
3517 for (i = 0; i < ic->nb_streams; i++) {
3518 st = ic->streams[i];
3519 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3520 ic->streams[i]->codec->thread_count = 0;
3522 av_freep(&st->info->duration_error);
3523 av_freep(&ic->streams[i]->info);
3526 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3527 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3531 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3535 for (i = 0; i < ic->nb_programs; i++) {
3536 if (ic->programs[i] == last) {
3540 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3541 if (ic->programs[i]->stream_index[j] == s)
3542 return ic->programs[i];
3548 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3549 int wanted_stream_nb, int related_stream,
3550 AVCodec **decoder_ret, int flags)
3552 int i, nb_streams = ic->nb_streams;
3553 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3554 unsigned *program = NULL;
3555 const AVCodec *decoder = NULL, *best_decoder = NULL;
3557 if (related_stream >= 0 && wanted_stream_nb < 0) {
3558 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3560 program = p->stream_index;
3561 nb_streams = p->nb_stream_indexes;
3564 for (i = 0; i < nb_streams; i++) {
3565 int real_stream_index = program ? program[i] : i;
3566 AVStream *st = ic->streams[real_stream_index];
3567 AVCodecContext *avctx = st->codec;
3568 if (avctx->codec_type != type)
3570 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3572 if (wanted_stream_nb != real_stream_index &&
3573 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3574 AV_DISPOSITION_VISUAL_IMPAIRED))
3576 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3579 decoder = find_decoder(ic, st, st->codec->codec_id);
3582 ret = AVERROR_DECODER_NOT_FOUND;
3586 count = st->codec_info_nb_frames;
3587 bitrate = avctx->bit_rate;
3589 bitrate = avctx->rc_max_rate;
3590 multiframe = FFMIN(5, count);
3591 if ((best_multiframe > multiframe) ||
3592 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3593 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3596 best_bitrate = bitrate;
3597 best_multiframe = multiframe;
3598 ret = real_stream_index;
3599 best_decoder = decoder;
3600 if (program && i == nb_streams - 1 && ret < 0) {
3602 nb_streams = ic->nb_streams;
3603 /* no related stream found, try again with everything */
3608 *decoder_ret = (AVCodec*)best_decoder;
3612 /*******************************************************/
3614 int av_read_play(AVFormatContext *s)
3616 if (s->iformat->read_play)
3617 return s->iformat->read_play(s);
3619 return avio_pause(s->pb, 0);
3620 return AVERROR(ENOSYS);
3623 int av_read_pause(AVFormatContext *s)
3625 if (s->iformat->read_pause)
3626 return s->iformat->read_pause(s);
3628 return avio_pause(s->pb, 1);
3629 return AVERROR(ENOSYS);
3632 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3634 av_assert0(s->nb_streams>0);
3635 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3637 for (j = 0; j < st->nb_side_data; j++)
3638 av_freep(&st->side_data[j].data);
3639 av_freep(&st->side_data);
3640 st->nb_side_data = 0;
3643 av_parser_close(st->parser);
3645 if (st->attached_pic.data)
3646 av_free_packet(&st->attached_pic);
3647 av_dict_free(&st->metadata);
3648 av_freep(&st->probe_data.buf);
3649 av_freep(&st->index_entries);
3650 av_freep(&st->codec->extradata);
3651 av_freep(&st->codec->subtitle_header);
3652 av_freep(&st->codec);
3653 av_freep(&st->priv_data);
3655 av_freep(&st->info->duration_error);
3656 av_freep(&st->info);
3657 av_freep(&s->streams[ --s->nb_streams ]);
3660 void avformat_free_context(AVFormatContext *s)
3668 if (s->iformat && s->iformat->priv_class && s->priv_data)
3669 av_opt_free(s->priv_data);
3670 if (s->oformat && s->oformat->priv_class && s->priv_data)
3671 av_opt_free(s->priv_data);
3673 for (i = s->nb_streams - 1; i >= 0; i--) {
3674 ff_free_stream(s, s->streams[i]);
3676 for (i = s->nb_programs - 1; i >= 0; i--) {
3677 av_dict_free(&s->programs[i]->metadata);
3678 av_freep(&s->programs[i]->stream_index);
3679 av_freep(&s->programs[i]);
3681 av_freep(&s->programs);
3682 av_freep(&s->priv_data);
3683 while (s->nb_chapters--) {
3684 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3685 av_freep(&s->chapters[s->nb_chapters]);
3687 av_freep(&s->chapters);
3688 av_dict_free(&s->metadata);
3689 av_freep(&s->streams);
3690 av_freep(&s->internal);
3694 #if FF_API_CLOSE_INPUT_FILE
3695 void av_close_input_file(AVFormatContext *s)
3697 avformat_close_input(&s);
3701 void avformat_close_input(AVFormatContext **ps)
3712 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3713 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3716 flush_packet_queue(s);
3719 if (s->iformat->read_close)
3720 s->iformat->read_close(s);
3722 avformat_free_context(s);
3729 #if FF_API_NEW_STREAM
3730 AVStream *av_new_stream(AVFormatContext *s, int id)
3732 AVStream *st = avformat_new_stream(s, NULL);
3739 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3745 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3747 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3750 s->streams = streams;
3752 st = av_mallocz(sizeof(AVStream));
3755 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3759 st->info->last_dts = AV_NOPTS_VALUE;
3761 st->codec = avcodec_alloc_context3(c);
3763 /* no default bitrate if decoding */
3764 st->codec->bit_rate = 0;
3766 /* default pts setting is MPEG-like */
3767 avpriv_set_pts_info(st, 33, 1, 90000);
3770 st->index = s->nb_streams;
3771 st->start_time = AV_NOPTS_VALUE;
3772 st->duration = AV_NOPTS_VALUE;
3773 /* we set the current DTS to 0 so that formats without any timestamps
3774 * but durations get some timestamps, formats with some unknown
3775 * timestamps have their first few packets buffered and the
3776 * timestamps corrected before they are returned to the user */
3777 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3778 st->first_dts = AV_NOPTS_VALUE;
3779 st->probe_packets = MAX_PROBE_PACKETS;
3780 st->pts_wrap_reference = AV_NOPTS_VALUE;
3781 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3783 st->last_IP_pts = AV_NOPTS_VALUE;
3784 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3785 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3786 st->pts_buffer[i] = AV_NOPTS_VALUE;
3788 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3790 #if FF_API_R_FRAME_RATE
3791 st->info->last_dts = AV_NOPTS_VALUE;
3793 st->info->fps_first_dts = AV_NOPTS_VALUE;
3794 st->info->fps_last_dts = AV_NOPTS_VALUE;
3796 st->inject_global_side_data = s->internal->inject_global_side_data;
3798 s->streams[s->nb_streams++] = st;
3802 AVProgram *av_new_program(AVFormatContext *ac, int id)
3804 AVProgram *program = NULL;
3807 av_dlog(ac, "new_program: id=0x%04x\n", id);
3809 for (i = 0; i < ac->nb_programs; i++)
3810 if (ac->programs[i]->id == id)
3811 program = ac->programs[i];
3814 program = av_mallocz(sizeof(AVProgram));
3817 dynarray_add(&ac->programs, &ac->nb_programs, program);
3818 program->discard = AVDISCARD_NONE;
3821 program->pts_wrap_reference = AV_NOPTS_VALUE;
3822 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3824 program->start_time =
3825 program->end_time = AV_NOPTS_VALUE;
3830 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3831 int64_t start, int64_t end, const char *title)
3833 AVChapter *chapter = NULL;
3836 if (end != AV_NOPTS_VALUE && start > end) {
3837 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3841 for (i = 0; i < s->nb_chapters; i++)
3842 if (s->chapters[i]->id == id)
3843 chapter = s->chapters[i];
3846 chapter = av_mallocz(sizeof(AVChapter));
3849 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3851 av_dict_set(&chapter->metadata, "title", title, 0);
3853 chapter->time_base = time_base;
3854 chapter->start = start;
3860 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3863 AVProgram *program = NULL;
3866 if (idx >= ac->nb_streams) {
3867 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3871 for (i = 0; i < ac->nb_programs; i++) {
3872 if (ac->programs[i]->id != progid)
3874 program = ac->programs[i];
3875 for (j = 0; j < program->nb_stream_indexes; j++)
3876 if (program->stream_index[j] == idx)
3879 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3882 program->stream_index = tmp;
3883 program->stream_index[program->nb_stream_indexes++] = idx;
3888 uint64_t ff_ntp_time(void)
3890 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3893 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3896 char *q, buf1[20], c;
3897 int nd, len, percentd_found;
3909 while (av_isdigit(*p))
3910 nd = nd * 10 + *p++ - '0';
3912 } while (av_isdigit(c));
3921 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3923 if ((q - buf + len) > buf_size - 1)
3925 memcpy(q, buf1, len);
3933 if ((q - buf) < buf_size - 1)
3937 if (!percentd_found)
3946 void av_url_split(char *proto, int proto_size,
3947 char *authorization, int authorization_size,
3948 char *hostname, int hostname_size,
3949 int *port_ptr, char *path, int path_size, const char *url)
3951 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3957 if (authorization_size > 0)
3958 authorization[0] = 0;
3959 if (hostname_size > 0)
3964 /* parse protocol */
3965 if ((p = strchr(url, ':'))) {
3966 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3973 /* no protocol means plain filename */
3974 av_strlcpy(path, url, path_size);
3978 /* separate path from hostname */
3979 ls = strchr(p, '/');
3980 ls2 = strchr(p, '?');
3984 ls = FFMIN(ls, ls2);
3986 av_strlcpy(path, ls, path_size);
3988 ls = &p[strlen(p)]; // XXX
3990 /* the rest is hostname, use that to parse auth/port */
3992 /* authorization (user[:pass]@hostname) */
3994 while ((at = strchr(p, '@')) && at < ls) {
3995 av_strlcpy(authorization, at2,
3996 FFMIN(authorization_size, at + 1 - at2));
3997 p = at + 1; /* skip '@' */
4000 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4002 av_strlcpy(hostname, p + 1,
4003 FFMIN(hostname_size, brk - p));
4004 if (brk[1] == ':' && port_ptr)
4005 *port_ptr = atoi(brk + 2);
4006 } else if ((col = strchr(p, ':')) && col < ls) {
4007 av_strlcpy(hostname, p,
4008 FFMIN(col + 1 - p, hostname_size));
4010 *port_ptr = atoi(col + 1);
4012 av_strlcpy(hostname, p,
4013 FFMIN(ls + 1 - p, hostname_size));
4017 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4020 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4023 'C', 'D', 'E', 'F' };
4024 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4027 'c', 'd', 'e', 'f' };
4028 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4030 for (i = 0; i < s; i++) {
4031 buff[i * 2] = hex_table[src[i] >> 4];
4032 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4038 int ff_hex_to_data(uint8_t *data, const char *p)
4045 p += strspn(p, SPACE_CHARS);
4048 c = av_toupper((unsigned char) *p++);
4049 if (c >= '0' && c <= '9')
4051 else if (c >= 'A' && c <= 'F')
4066 #if FF_API_SET_PTS_INFO
4067 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4068 unsigned int pts_num, unsigned int pts_den)
4070 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4074 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4075 unsigned int pts_num, unsigned int pts_den)
4078 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4079 if (new_tb.num != pts_num)
4080 av_log(NULL, AV_LOG_DEBUG,
4081 "st:%d removing common factor %d from timebase\n",
4082 s->index, pts_num / new_tb.num);
4084 av_log(NULL, AV_LOG_WARNING,
4085 "st:%d has too large timebase, reducing\n", s->index);
4087 if (new_tb.num <= 0 || new_tb.den <= 0) {
4088 av_log(NULL, AV_LOG_ERROR,
4089 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4090 new_tb.num, new_tb.den,
4094 s->time_base = new_tb;
4095 av_codec_set_pkt_timebase(s->codec, new_tb);
4096 s->pts_wrap_bits = pts_wrap_bits;
4099 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4102 const char *ptr = str;
4104 /* Parse key=value pairs. */
4107 char *dest = NULL, *dest_end;
4108 int key_len, dest_len = 0;
4110 /* Skip whitespace and potential commas. */
4111 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4118 if (!(ptr = strchr(key, '=')))
4121 key_len = ptr - key;
4123 callback_get_buf(context, key, key_len, &dest, &dest_len);
4124 dest_end = dest + dest_len - 1;
4128 while (*ptr && *ptr != '\"') {
4132 if (dest && dest < dest_end)
4136 if (dest && dest < dest_end)
4144 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4145 if (dest && dest < dest_end)
4153 int ff_find_stream_index(AVFormatContext *s, int id)
4156 for (i = 0; i < s->nb_streams; i++)
4157 if (s->streams[i]->id == id)
4162 int64_t ff_iso8601_to_unix_time(const char *datestr)
4164 struct tm time1 = { 0 }, time2 = { 0 };
4166 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4167 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4169 return av_timegm(&time2);
4171 return av_timegm(&time1);
4174 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4178 if (ofmt->query_codec)
4179 return ofmt->query_codec(codec_id, std_compliance);
4180 else if (ofmt->codec_tag)
4181 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4182 else if (codec_id == ofmt->video_codec ||
4183 codec_id == ofmt->audio_codec ||
4184 codec_id == ofmt->subtitle_codec)
4187 return AVERROR_PATCHWELCOME;
4190 int avformat_network_init(void)
4194 ff_network_inited_globally = 1;
4195 if ((ret = ff_network_init()) < 0)
4202 int avformat_network_deinit(void)
4211 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4212 uint64_t channel_layout, int32_t sample_rate,
4213 int32_t width, int32_t height)
4219 return AVERROR(EINVAL);
4222 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4224 if (channel_layout) {
4226 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4230 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4232 if (width || height) {
4234 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4236 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4238 return AVERROR(ENOMEM);
4239 bytestream_put_le32(&data, flags);
4241 bytestream_put_le32(&data, channels);
4243 bytestream_put_le64(&data, channel_layout);
4245 bytestream_put_le32(&data, sample_rate);
4246 if (width || height) {
4247 bytestream_put_le32(&data, width);
4248 bytestream_put_le32(&data, height);
4253 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4255 AVRational undef = {0, 1};
4256 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4257 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4258 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4260 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4261 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4262 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4263 stream_sample_aspect_ratio = undef;
4265 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4266 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4267 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4268 frame_sample_aspect_ratio = undef;
4270 if (stream_sample_aspect_ratio.num)
4271 return stream_sample_aspect_ratio;
4273 return frame_sample_aspect_ratio;
4276 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4278 AVRational fr = st->r_frame_rate;
4279 AVRational codec_fr = av_inv_q(st->codec->time_base);
4280 AVRational avg_fr = st->avg_frame_rate;
4282 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4283 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4288 if (st->codec->ticks_per_frame > 1) {
4289 codec_fr.den *= st->codec->ticks_per_frame;
4290 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4291 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4298 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4301 if (*spec <= '9' && *spec >= '0') /* opt:index */
4302 return strtol(spec, NULL, 0) == st->index;
4303 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4304 *spec == 't') { /* opt:[vasdt] */
4305 enum AVMediaType type;
4308 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4309 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4310 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4311 case 'd': type = AVMEDIA_TYPE_DATA; break;
4312 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4313 default: av_assert0(0);
4315 if (type != st->codec->codec_type)
4317 if (*spec++ == ':') { /* possibly followed by :index */
4318 int i, index = strtol(spec, NULL, 0);
4319 for (i = 0; i < s->nb_streams; i++)
4320 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4321 return i == st->index;
4325 } else if (*spec == 'p' && *(spec + 1) == ':') {
4329 prog_id = strtol(spec, &endptr, 0);
4330 for (i = 0; i < s->nb_programs; i++) {
4331 if (s->programs[i]->id != prog_id)
4334 if (*endptr++ == ':') {
4335 int stream_idx = strtol(endptr, NULL, 0);
4336 return stream_idx >= 0 &&
4337 stream_idx < s->programs[i]->nb_stream_indexes &&
4338 st->index == s->programs[i]->stream_index[stream_idx];
4341 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4342 if (st->index == s->programs[i]->stream_index[j])
4346 } else if (*spec == '#' ||
4347 (*spec == 'i' && *(spec + 1) == ':')) {
4350 spec += 1 + (*spec == 'i');
4351 stream_id = strtol(spec, &endptr, 0);
4353 return stream_id == st->id;
4354 } else if (!*spec) /* empty specifier, matches everything */
4357 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4358 return AVERROR(EINVAL);
4361 int ff_generate_avci_extradata(AVStream *st)
4363 static const uint8_t avci100_1080p_extradata[] = {
4365 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4366 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4367 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4368 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4369 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4370 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4371 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4372 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4373 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4375 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4378 static const uint8_t avci100_1080i_extradata[] = {
4380 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4381 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4382 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4383 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4384 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4385 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4386 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4387 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4388 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4389 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4390 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4392 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4395 static const uint8_t avci50_1080i_extradata[] = {
4397 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4398 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4399 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4400 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4401 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4402 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4403 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4404 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4405 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4406 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4407 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4409 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4412 static const uint8_t avci100_720p_extradata[] = {
4414 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4415 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4416 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4417 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4418 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4419 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4420 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4421 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4422 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4423 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4425 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4429 const uint8_t *data = NULL;
4432 if (st->codec->width == 1920) {
4433 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4434 data = avci100_1080p_extradata;
4435 size = sizeof(avci100_1080p_extradata);
4437 data = avci100_1080i_extradata;
4438 size = sizeof(avci100_1080i_extradata);
4440 } else if (st->codec->width == 1440) {
4441 data = avci50_1080i_extradata;
4442 size = sizeof(avci50_1080i_extradata);
4443 } else if (st->codec->width == 1280) {
4444 data = avci100_720p_extradata;
4445 size = sizeof(avci100_720p_extradata);
4451 av_freep(&st->codec->extradata);
4452 if (ff_alloc_extradata(st->codec, size))
4453 return AVERROR(ENOMEM);
4454 memcpy(st->codec->extradata, data, size);
4459 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4464 for (i = 0; i < st->nb_side_data; i++) {
4465 if (st->side_data[i].type == type) {
4467 *size = st->side_data[i].size;
4468 return st->side_data[i].data;