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 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
115 if (st->codec->codec)
116 return st->codec->codec;
118 switch (st->codec->codec_type) {
119 case AVMEDIA_TYPE_VIDEO:
120 if (s->video_codec) return s->video_codec;
122 case AVMEDIA_TYPE_AUDIO:
123 if (s->audio_codec) return s->audio_codec;
125 case AVMEDIA_TYPE_SUBTITLE:
126 if (s->subtitle_codec) return s->subtitle_codec;
130 return avcodec_find_decoder(codec_id);
133 int av_format_get_probe_score(const AVFormatContext *s)
135 return s->probe_score;
138 /* an arbitrarily chosen "sane" max packet size -- 50M */
139 #define SANE_CHUNK_SIZE (50000000)
141 int ffio_limit(AVIOContext *s, int size)
143 if (s->maxsize>= 0) {
144 int64_t remaining= s->maxsize - avio_tell(s);
145 if (remaining < size) {
146 int64_t newsize = avio_size(s);
147 if (!s->maxsize || s->maxsize<newsize)
148 s->maxsize = newsize - !newsize;
149 remaining= s->maxsize - avio_tell(s);
150 remaining= FFMAX(remaining, 0);
153 if (s->maxsize>= 0 && remaining+1 < size) {
154 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
161 /* Read the data in sane-sized chunks and append to pkt.
162 * Return the number of bytes read or an error. */
163 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
165 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
166 int orig_size = pkt->size;
170 int prev_size = pkt->size;
173 /* When the caller requests a lot of data, limit it to the amount
174 * left in file or SANE_CHUNK_SIZE when it is not known. */
176 if (read_size > SANE_CHUNK_SIZE/10) {
177 read_size = ffio_limit(s, read_size);
178 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
180 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
183 ret = av_grow_packet(pkt, read_size);
187 ret = avio_read(s, pkt->data + prev_size, read_size);
188 if (ret != read_size) {
189 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
196 pkt->flags |= AV_PKT_FLAG_CORRUPT;
201 return pkt->size > orig_size ? pkt->size - orig_size : ret;
204 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
209 pkt->pos = avio_tell(s);
211 return append_packet_chunked(s, pkt, size);
214 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
217 return av_get_packet(s, pkt, size);
218 return append_packet_chunked(s, pkt, size);
221 int av_filename_number_test(const char *filename)
225 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
228 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
231 AVProbeData lpd = *pd;
232 AVInputFormat *fmt1 = NULL, *fmt;
233 int score, nodat = 0, score_max = 0;
234 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
237 lpd.buf = zerobuffer;
239 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
240 int id3len = ff_id3v2_tag_len(lpd.buf);
241 if (lpd.buf_size > id3len + 16) {
243 lpd.buf_size -= id3len;
249 while ((fmt1 = av_iformat_next(fmt1))) {
250 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
253 if (fmt1->read_probe) {
254 score = fmt1->read_probe(&lpd);
255 if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
256 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
257 } else if (fmt1->extensions) {
258 if (av_match_ext(lpd.filename, fmt1->extensions))
259 score = AVPROBE_SCORE_EXTENSION;
261 if (score > score_max) {
264 } else if (score == score_max)
268 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
269 *score_ret = score_max;
274 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
277 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
278 if (score_ret > *score_max) {
279 *score_max = score_ret;
285 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
288 return av_probe_input_format2(pd, is_opened, &score);
291 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
294 static const struct {
297 enum AVMediaType type;
299 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
300 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
301 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
302 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
303 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
304 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
305 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
306 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
307 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
308 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
312 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
314 if (fmt && st->request_probe <= score) {
316 av_log(s, AV_LOG_DEBUG,
317 "Probe with size=%d, packets=%d detected %s with score=%d\n",
318 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
320 for (i = 0; fmt_id_type[i].name; i++) {
321 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
322 st->codec->codec_id = fmt_id_type[i].id;
323 st->codec->codec_type = fmt_id_type[i].type;
331 /************************************************************/
332 /* input media file */
334 int av_demuxer_open(AVFormatContext *ic) {
337 if (ic->iformat->read_header) {
338 err = ic->iformat->read_header(ic);
343 if (ic->pb && !ic->data_offset)
344 ic->data_offset = avio_tell(ic->pb);
350 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
351 const char *filename, void *logctx,
352 unsigned int offset, unsigned int max_probe_size)
354 AVProbeData pd = { filename ? filename : "" };
357 int ret = 0, probe_size, buf_offset = 0;
361 max_probe_size = PROBE_BUF_MAX;
362 else if (max_probe_size > PROBE_BUF_MAX)
363 max_probe_size = PROBE_BUF_MAX;
364 else if (max_probe_size < PROBE_BUF_MIN) {
365 av_log(logctx, AV_LOG_ERROR,
366 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
367 return AVERROR(EINVAL);
370 if (offset >= max_probe_size)
371 return AVERROR(EINVAL);
373 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
374 if (!av_strcasecmp(mime_type, "audio/aacp")) {
375 *fmt = av_find_input_format("aac");
377 av_freep(&mime_type);
380 for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
381 probe_size = FFMIN(probe_size << 1,
382 FFMAX(max_probe_size, probe_size + 1))) {
383 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
385 /* Read probe data. */
386 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
388 if ((ret = avio_read(pb, buf + buf_offset,
389 probe_size - buf_offset)) < 0) {
390 /* Fail if error was not end of file, otherwise, lower score. */
391 if (ret != AVERROR_EOF) {
396 ret = 0; /* error was end of file, nothing read */
399 if (buf_offset < offset)
401 pd.buf_size = buf_offset - offset;
402 pd.buf = &buf[offset];
404 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
406 /* Guess file format. */
407 *fmt = av_probe_input_format2(&pd, 1, &score);
409 /* This can only be true in the last iteration. */
410 if (score <= AVPROBE_SCORE_RETRY) {
411 av_log(logctx, AV_LOG_WARNING,
412 "Format %s detected only with low score of %d, "
413 "misdetection possible!\n", (*fmt)->name, score);
415 av_log(logctx, AV_LOG_DEBUG,
416 "Format %s probed with size=%d and score=%d\n",
417 (*fmt)->name, probe_size, score);
419 FILE *f = fopen("probestat.tmp", "ab");
420 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
428 return AVERROR_INVALIDDATA;
431 /* Rewind. Reuse probe buffer to avoid seeking. */
432 ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
434 return ret < 0 ? ret : score;
437 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
438 const char *filename, void *logctx,
439 unsigned int offset, unsigned int max_probe_size)
441 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
442 return ret < 0 ? ret : 0;
445 /* Open input file and probe the format if necessary. */
446 static int init_input(AVFormatContext *s, const char *filename,
447 AVDictionary **options)
450 AVProbeData pd = { filename, NULL, 0 };
451 int score = AVPROBE_SCORE_RETRY;
454 s->flags |= AVFMT_FLAG_CUSTOM_IO;
456 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
458 else if (s->iformat->flags & AVFMT_NOFILE)
459 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
460 "will be ignored with AVFMT_NOFILE format.\n");
464 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
465 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
468 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
469 &s->interrupt_callback, options)) < 0)
473 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
477 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
478 AVPacketList **plast_pktl)
480 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
485 (*plast_pktl)->next = pktl;
487 *packet_buffer = pktl;
489 /* Add the packet in the buffered packet list. */
495 int avformat_queue_attached_pictures(AVFormatContext *s)
498 for (i = 0; i < s->nb_streams; i++)
499 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
500 s->streams[i]->discard < AVDISCARD_ALL) {
501 AVPacket copy = s->streams[i]->attached_pic;
502 copy.buf = av_buffer_ref(copy.buf);
504 return AVERROR(ENOMEM);
506 add_to_pktbuf(&s->raw_packet_buffer, ©,
507 &s->raw_packet_buffer_end);
512 int avformat_open_input(AVFormatContext **ps, const char *filename,
513 AVInputFormat *fmt, AVDictionary **options)
515 AVFormatContext *s = *ps;
517 AVDictionary *tmp = NULL;
518 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
520 if (!s && !(s = avformat_alloc_context()))
521 return AVERROR(ENOMEM);
523 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
524 return AVERROR(EINVAL);
530 av_dict_copy(&tmp, *options, 0);
532 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
535 if ((ret = init_input(s, filename, &tmp)) < 0)
537 s->probe_score = ret;
538 avio_skip(s->pb, s->skip_initial_bytes);
540 /* Check filename in case an image number is expected. */
541 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
542 if (!av_filename_number_test(filename)) {
543 ret = AVERROR(EINVAL);
548 s->duration = s->start_time = AV_NOPTS_VALUE;
549 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
551 /* Allocate private data. */
552 if (s->iformat->priv_data_size > 0) {
553 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
554 ret = AVERROR(ENOMEM);
557 if (s->iformat->priv_class) {
558 *(const AVClass **) s->priv_data = s->iformat->priv_class;
559 av_opt_set_defaults(s->priv_data);
560 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
565 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
567 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
569 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
570 if ((ret = s->iformat->read_header(s)) < 0)
573 if (id3v2_extra_meta) {
574 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
575 !strcmp(s->iformat->name, "tta")) {
576 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
579 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
581 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
583 if ((ret = avformat_queue_attached_pictures(s)) < 0)
586 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
587 s->data_offset = avio_tell(s->pb);
589 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
592 av_dict_free(options);
599 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
601 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
603 avformat_free_context(s);
608 /*******************************************************/
610 static void force_codec_ids(AVFormatContext *s, AVStream *st)
612 switch (st->codec->codec_type) {
613 case AVMEDIA_TYPE_VIDEO:
614 if (s->video_codec_id)
615 st->codec->codec_id = s->video_codec_id;
617 case AVMEDIA_TYPE_AUDIO:
618 if (s->audio_codec_id)
619 st->codec->codec_id = s->audio_codec_id;
621 case AVMEDIA_TYPE_SUBTITLE:
622 if (s->subtitle_codec_id)
623 st->codec->codec_id = s->subtitle_codec_id;
628 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
630 if (st->request_probe>0) {
631 AVProbeData *pd = &st->probe_data;
633 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
637 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
639 av_log(s, AV_LOG_WARNING,
640 "Failed to reallocate probe buffer for stream %d\n",
645 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
646 pd->buf_size += pkt->size;
647 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
650 st->probe_packets = 0;
652 av_log(s, AV_LOG_WARNING,
653 "nothing to probe for stream %d\n", st->index);
657 end= s->raw_packet_buffer_remaining_size <= 0
658 || st->probe_packets<= 0;
660 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
661 int score = set_codec_from_probe_data(s, st, pd);
662 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
666 st->request_probe = -1;
667 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
668 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
670 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
672 force_codec_ids(s, st);
678 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
680 int64_t ref = pkt->dts;
681 int i, pts_wrap_behavior;
682 int64_t pts_wrap_reference;
683 AVProgram *first_program;
685 if (ref == AV_NOPTS_VALUE)
687 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
689 ref &= (1LL << st->pts_wrap_bits)-1;
691 // reference time stamp should be 60 s before first time stamp
692 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
693 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
694 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
695 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
696 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
698 first_program = av_find_program_from_stream(s, NULL, stream_index);
700 if (!first_program) {
701 int default_stream_index = av_find_default_stream_index(s);
702 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
703 for (i = 0; i < s->nb_streams; i++) {
704 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
705 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
709 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
710 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
714 AVProgram *program = first_program;
716 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
717 pts_wrap_reference = program->pts_wrap_reference;
718 pts_wrap_behavior = program->pts_wrap_behavior;
721 program = av_find_program_from_stream(s, program, stream_index);
724 // update every program with differing pts_wrap_reference
725 program = first_program;
727 if (program->pts_wrap_reference != pts_wrap_reference) {
728 for (i = 0; i<program->nb_stream_indexes; i++) {
729 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
730 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
733 program->pts_wrap_reference = pts_wrap_reference;
734 program->pts_wrap_behavior = pts_wrap_behavior;
736 program = av_find_program_from_stream(s, program, stream_index);
742 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
748 AVPacketList *pktl = s->raw_packet_buffer;
752 st = s->streams[pkt->stream_index];
753 if (s->raw_packet_buffer_remaining_size <= 0)
754 if ((err = probe_codec(s, st, NULL)) < 0)
756 if (st->request_probe <= 0) {
757 s->raw_packet_buffer = pktl->next;
758 s->raw_packet_buffer_remaining_size += pkt->size;
767 ret = s->iformat->read_packet(s, pkt);
769 if (!pktl || ret == AVERROR(EAGAIN))
771 for (i = 0; i < s->nb_streams; i++) {
773 if (st->probe_packets)
774 if ((err = probe_codec(s, st, NULL)) < 0)
776 av_assert0(st->request_probe <= 0);
781 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
782 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
783 av_log(s, AV_LOG_WARNING,
784 "Dropped corrupted packet (stream = %d)\n",
790 if (pkt->stream_index >= (unsigned)s->nb_streams) {
791 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
795 st = s->streams[pkt->stream_index];
797 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
798 // correct first time stamps to negative values
799 if (!is_relative(st->first_dts))
800 st->first_dts = wrap_timestamp(st, st->first_dts);
801 if (!is_relative(st->start_time))
802 st->start_time = wrap_timestamp(st, st->start_time);
803 if (!is_relative(st->cur_dts))
804 st->cur_dts = wrap_timestamp(st, st->cur_dts);
807 pkt->dts = wrap_timestamp(st, pkt->dts);
808 pkt->pts = wrap_timestamp(st, pkt->pts);
810 force_codec_ids(s, st);
812 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
813 if (s->use_wallclock_as_timestamps)
814 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
816 if (!pktl && st->request_probe <= 0)
819 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
820 s->raw_packet_buffer_remaining_size -= pkt->size;
822 if ((err = probe_codec(s, st, pkt)) < 0)
827 #if FF_API_READ_PACKET
828 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
830 return ff_read_packet(s, pkt);
835 /**********************************************************/
837 static int determinable_frame_size(AVCodecContext *avctx)
839 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
840 avctx->codec_id == AV_CODEC_ID_MP1 ||
841 avctx->codec_id == AV_CODEC_ID_MP2 ||
842 avctx->codec_id == AV_CODEC_ID_MP3/* ||
843 avctx->codec_id == AV_CODEC_ID_CELT*/)
849 * Get the number of samples of an audio frame. Return -1 on error.
851 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
855 /* give frame_size priority if demuxing */
856 if (!mux && enc->frame_size > 1)
857 return enc->frame_size;
859 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
862 /* Fall back on using frame_size if muxing. */
863 if (enc->frame_size > 1)
864 return enc->frame_size;
866 //For WMA we currently have no other means to calculate duration thus we
867 //do it here by assuming CBR, which is true for all known cases.
868 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
869 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
870 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
877 * Return the frame duration in seconds. Return 0 if not available.
879 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
880 AVCodecParserContext *pc, AVPacket *pkt)
886 switch (st->codec->codec_type) {
887 case AVMEDIA_TYPE_VIDEO:
888 if (st->r_frame_rate.num && !pc) {
889 *pnum = st->r_frame_rate.den;
890 *pden = st->r_frame_rate.num;
891 } else if (st->time_base.num * 1000LL > st->time_base.den) {
892 *pnum = st->time_base.num;
893 *pden = st->time_base.den;
894 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
895 *pnum = st->codec->time_base.num;
896 *pden = st->codec->time_base.den;
897 if (pc && pc->repeat_pict) {
898 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
899 *pden /= 1 + pc->repeat_pict;
901 *pnum *= 1 + pc->repeat_pict;
903 /* If this codec can be interlaced or progressive then we need
904 * a parser to compute duration of a packet. Thus if we have
905 * no parser in such case leave duration undefined. */
906 if (st->codec->ticks_per_frame > 1 && !pc)
910 case AVMEDIA_TYPE_AUDIO:
911 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
912 if (frame_size <= 0 || st->codec->sample_rate <= 0)
915 *pden = st->codec->sample_rate;
922 static int is_intra_only(AVCodecContext *enc) {
923 const AVCodecDescriptor *desc;
925 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
928 desc = av_codec_get_codec_descriptor(enc);
930 desc = avcodec_descriptor_get(enc->codec_id);
931 av_codec_set_codec_descriptor(enc, desc);
934 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
938 static int has_decode_delay_been_guessed(AVStream *st)
940 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
941 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
943 #if CONFIG_H264_DECODER
944 if (st->codec->has_b_frames &&
945 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
948 if (st->codec->has_b_frames<3)
949 return st->nb_decoded_frames >= 7;
950 else if (st->codec->has_b_frames<4)
951 return st->nb_decoded_frames >= 18;
953 return st->nb_decoded_frames >= 20;
956 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
960 if (pktl == s->packet_buffer_end)
961 return s->parse_queue;
965 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
966 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
967 st->codec->codec_id != AV_CODEC_ID_HEVC;
970 int delay = st->codec->has_b_frames;
973 if (dts == AV_NOPTS_VALUE) {
974 int64_t best_score = INT64_MAX;
975 for (i = 0; i<delay; i++) {
976 if (st->pts_reorder_error_count[i]) {
977 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
978 if (score < best_score) {
985 for (i = 0; i<delay; i++) {
986 if (pts_buffer[i] != AV_NOPTS_VALUE) {
987 int64_t diff = FFABS(pts_buffer[i] - dts)
988 + (uint64_t)st->pts_reorder_error[i];
989 diff = FFMAX(diff, st->pts_reorder_error[i]);
990 st->pts_reorder_error[i] = diff;
991 st->pts_reorder_error_count[i]++;
992 if (st->pts_reorder_error_count[i] > 250) {
993 st->pts_reorder_error[i] >>= 1;
994 st->pts_reorder_error_count[i] >>= 1;
1001 if (dts == AV_NOPTS_VALUE)
1002 dts = pts_buffer[0];
1007 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1008 int64_t dts, int64_t pts, AVPacket *pkt)
1010 AVStream *st = s->streams[stream_index];
1011 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1012 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1016 if (st->first_dts != AV_NOPTS_VALUE ||
1017 dts == AV_NOPTS_VALUE ||
1018 st->cur_dts == AV_NOPTS_VALUE ||
1022 delay = st->codec->has_b_frames;
1023 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1025 shift = st->first_dts - RELATIVE_TS_BASE;
1027 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1028 pts_buffer[i] = AV_NOPTS_VALUE;
1030 if (is_relative(pts))
1033 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1034 if (pktl->pkt.stream_index != stream_index)
1036 if (is_relative(pktl->pkt.pts))
1037 pktl->pkt.pts += shift;
1039 if (is_relative(pktl->pkt.dts))
1040 pktl->pkt.dts += shift;
1042 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1043 st->start_time = pktl->pkt.pts;
1045 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1046 pts_buffer[0] = pktl->pkt.pts;
1047 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1048 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1050 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
1054 if (st->start_time == AV_NOPTS_VALUE)
1055 st->start_time = pts;
1058 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1059 int stream_index, int duration)
1061 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1062 int64_t cur_dts = RELATIVE_TS_BASE;
1064 if (st->first_dts != AV_NOPTS_VALUE) {
1065 if (st->update_initial_durations_done)
1067 st->update_initial_durations_done = 1;
1068 cur_dts = st->first_dts;
1069 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1070 if (pktl->pkt.stream_index == stream_index) {
1071 if (pktl->pkt.pts != pktl->pkt.dts ||
1072 pktl->pkt.dts != AV_NOPTS_VALUE ||
1075 cur_dts -= duration;
1078 if (pktl && pktl->pkt.dts != st->first_dts) {
1079 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1080 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1084 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1087 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1088 st->first_dts = cur_dts;
1089 } else if (st->cur_dts != RELATIVE_TS_BASE)
1092 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1093 if (pktl->pkt.stream_index != stream_index)
1095 if (pktl->pkt.pts == pktl->pkt.dts &&
1096 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1097 !pktl->pkt.duration) {
1098 pktl->pkt.dts = cur_dts;
1099 if (!st->codec->has_b_frames)
1100 pktl->pkt.pts = cur_dts;
1101 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1102 pktl->pkt.duration = duration;
1105 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1108 st->cur_dts = cur_dts;
1111 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1112 AVCodecParserContext *pc, AVPacket *pkt)
1114 int num, den, presentation_delayed, delay, i;
1116 AVRational duration;
1117 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1118 st->codec->codec_id != AV_CODEC_ID_HEVC;
1120 if (s->flags & AVFMT_FLAG_NOFILLIN)
1123 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1124 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1125 if (st->last_dts_for_order_check <= pkt->dts) {
1128 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1129 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1131 st->last_dts_for_order_check);
1132 st->dts_misordered++;
1134 if (st->dts_ordered + st->dts_misordered > 250) {
1135 st->dts_ordered >>= 1;
1136 st->dts_misordered >>= 1;
1140 st->last_dts_for_order_check = pkt->dts;
1141 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1142 pkt->dts = AV_NOPTS_VALUE;
1145 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1146 pkt->dts = AV_NOPTS_VALUE;
1148 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1149 && !st->codec->has_b_frames)
1150 //FIXME Set low_delay = 0 when has_b_frames = 1
1151 st->codec->has_b_frames = 1;
1153 /* do we have a video B-frame ? */
1154 delay = st->codec->has_b_frames;
1155 presentation_delayed = 0;
1157 /* XXX: need has_b_frame, but cannot get it if the codec is
1158 * not initialized */
1160 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1161 presentation_delayed = 1;
1163 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1164 st->pts_wrap_bits < 63 &&
1165 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1166 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1167 pkt->dts -= 1LL << st->pts_wrap_bits;
1169 pkt->pts += 1LL << st->pts_wrap_bits;
1172 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1173 * We take the conservative approach and discard both.
1174 * Note: If this is misbehaving for an H.264 file, then possibly
1175 * presentation_delayed is not set correctly. */
1176 if (delay == 1 && pkt->dts == pkt->pts &&
1177 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1178 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1179 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1180 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1181 pkt->dts = AV_NOPTS_VALUE;
1184 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1185 if (pkt->duration == 0) {
1186 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1188 duration = (AVRational) {num, den};
1189 pkt->duration = av_rescale_rnd(1,
1190 num * (int64_t) st->time_base.den,
1191 den * (int64_t) st->time_base.num,
1196 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1197 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1199 /* Correct timestamps with byte offset if demuxers only have timestamps
1200 * on packet boundaries */
1201 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1202 /* this will estimate bitrate based on this frame's duration and size */
1203 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1204 if (pkt->pts != AV_NOPTS_VALUE)
1206 if (pkt->dts != AV_NOPTS_VALUE)
1210 /* This may be redundant, but it should not hurt. */
1211 if (pkt->dts != AV_NOPTS_VALUE &&
1212 pkt->pts != AV_NOPTS_VALUE &&
1213 pkt->pts > pkt->dts)
1214 presentation_delayed = 1;
1217 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1218 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1219 pkt->stream_index, pc, pkt->duration);
1220 /* Interpolate PTS and DTS if they are not present. We skip H264
1221 * currently because delay and has_b_frames are not reliably set. */
1222 if ((delay == 0 || (delay == 1 && pc)) &&
1224 if (presentation_delayed) {
1225 /* DTS = decompression timestamp */
1226 /* PTS = presentation timestamp */
1227 if (pkt->dts == AV_NOPTS_VALUE)
1228 pkt->dts = st->last_IP_pts;
1229 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1230 if (pkt->dts == AV_NOPTS_VALUE)
1231 pkt->dts = st->cur_dts;
1233 /* This is tricky: the dts must be incremented by the duration
1234 * of the frame we are displaying, i.e. the last I- or P-frame. */
1235 if (st->last_IP_duration == 0)
1236 st->last_IP_duration = pkt->duration;
1237 if (pkt->dts != AV_NOPTS_VALUE)
1238 st->cur_dts = pkt->dts + st->last_IP_duration;
1239 st->last_IP_duration = pkt->duration;
1240 st->last_IP_pts = pkt->pts;
1241 /* Cannot compute PTS if not present (we can compute it only
1242 * by knowing the future. */
1243 } else if (pkt->pts != AV_NOPTS_VALUE ||
1244 pkt->dts != AV_NOPTS_VALUE ||
1247 /* presentation is not delayed : PTS and DTS are the same */
1248 if (pkt->pts == AV_NOPTS_VALUE)
1249 pkt->pts = pkt->dts;
1250 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1252 if (pkt->pts == AV_NOPTS_VALUE)
1253 pkt->pts = st->cur_dts;
1254 pkt->dts = pkt->pts;
1255 if (pkt->pts != AV_NOPTS_VALUE)
1256 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1260 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1261 st->pts_buffer[0] = pkt->pts;
1262 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1263 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1265 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1267 // We skipped it above so we try here.
1269 // This should happen on the first packet
1270 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1271 if (pkt->dts > st->cur_dts)
1272 st->cur_dts = pkt->dts;
1274 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1275 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1278 if (is_intra_only(st->codec))
1279 pkt->flags |= AV_PKT_FLAG_KEY;
1281 pkt->convergence_duration = pc->convergence_duration;
1284 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1287 AVPacketList *pktl = *pkt_buf;
1288 *pkt_buf = pktl->next;
1289 av_free_packet(&pktl->pkt);
1292 *pkt_buf_end = NULL;
1296 * Parse a packet, add all split parts to parse_queue.
1298 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1300 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1302 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1303 AVStream *st = s->streams[stream_index];
1304 uint8_t *data = pkt ? pkt->data : NULL;
1305 int size = pkt ? pkt->size : 0;
1306 int ret = 0, got_output = 0;
1309 av_init_packet(&flush_pkt);
1312 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1313 // preserve 0-size sync packets
1314 compute_pkt_fields(s, st, st->parser, pkt);
1317 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1320 av_init_packet(&out_pkt);
1321 len = av_parser_parse2(st->parser, st->codec,
1322 &out_pkt.data, &out_pkt.size, data, size,
1323 pkt->pts, pkt->dts, pkt->pos);
1325 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1327 /* increment read pointer */
1331 got_output = !!out_pkt.size;
1336 if (pkt->side_data) {
1337 out_pkt.side_data = pkt->side_data;
1338 out_pkt.side_data_elems = pkt->side_data_elems;
1339 pkt->side_data = NULL;
1340 pkt->side_data_elems = 0;
1343 /* set the duration */
1344 out_pkt.duration = 0;
1345 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1346 if (st->codec->sample_rate > 0) {
1348 av_rescale_q_rnd(st->parser->duration,
1349 (AVRational) { 1, st->codec->sample_rate },
1353 } else if (st->codec->time_base.num != 0 &&
1354 st->codec->time_base.den != 0) {
1355 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1356 st->codec->time_base,
1361 out_pkt.stream_index = st->index;
1362 out_pkt.pts = st->parser->pts;
1363 out_pkt.dts = st->parser->dts;
1364 out_pkt.pos = st->parser->pos;
1366 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1367 out_pkt.pos = st->parser->frame_offset;
1369 if (st->parser->key_frame == 1 ||
1370 (st->parser->key_frame == -1 &&
1371 st->parser->pict_type == AV_PICTURE_TYPE_I))
1372 out_pkt.flags |= AV_PKT_FLAG_KEY;
1374 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1375 out_pkt.flags |= AV_PKT_FLAG_KEY;
1377 compute_pkt_fields(s, st, st->parser, &out_pkt);
1379 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1380 out_pkt.buf = pkt->buf;
1382 #if FF_API_DESTRUCT_PACKET
1383 FF_DISABLE_DEPRECATION_WARNINGS
1384 out_pkt.destruct = pkt->destruct;
1385 pkt->destruct = NULL;
1386 FF_ENABLE_DEPRECATION_WARNINGS
1389 if ((ret = av_dup_packet(&out_pkt)) < 0)
1392 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1393 av_free_packet(&out_pkt);
1394 ret = AVERROR(ENOMEM);
1399 /* end of the stream => close and free the parser */
1400 if (pkt == &flush_pkt) {
1401 av_parser_close(st->parser);
1406 av_free_packet(pkt);
1410 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1411 AVPacketList **pkt_buffer_end,
1415 av_assert0(*pkt_buffer);
1418 *pkt_buffer = pktl->next;
1420 *pkt_buffer_end = NULL;
1425 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1427 int ret = 0, i, got_packet = 0;
1429 av_init_packet(pkt);
1431 while (!got_packet && !s->parse_queue) {
1435 /* read next packet */
1436 ret = ff_read_packet(s, &cur_pkt);
1438 if (ret == AVERROR(EAGAIN))
1440 /* flush the parsers */
1441 for (i = 0; i < s->nb_streams; i++) {
1443 if (st->parser && st->need_parsing)
1444 parse_packet(s, NULL, st->index);
1446 /* all remaining packets are now in parse_queue =>
1447 * really terminate parsing */
1451 st = s->streams[cur_pkt.stream_index];
1453 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1454 cur_pkt.dts != AV_NOPTS_VALUE &&
1455 cur_pkt.pts < cur_pkt.dts) {
1456 av_log(s, AV_LOG_WARNING,
1457 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1458 cur_pkt.stream_index,
1459 av_ts2str(cur_pkt.pts),
1460 av_ts2str(cur_pkt.dts),
1463 if (s->debug & FF_FDEBUG_TS)
1464 av_log(s, AV_LOG_DEBUG,
1465 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1466 cur_pkt.stream_index,
1467 av_ts2str(cur_pkt.pts),
1468 av_ts2str(cur_pkt.dts),
1469 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1471 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1472 st->parser = av_parser_init(st->codec->codec_id);
1474 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1475 "%s, packets or times may be invalid.\n",
1476 avcodec_get_name(st->codec->codec_id));
1477 /* no parser available: just output the raw packets */
1478 st->need_parsing = AVSTREAM_PARSE_NONE;
1479 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1480 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1481 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1482 st->parser->flags |= PARSER_FLAG_ONCE;
1483 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1484 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1487 if (!st->need_parsing || !st->parser) {
1488 /* no parsing needed: we just output the packet as is */
1490 compute_pkt_fields(s, st, NULL, pkt);
1491 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1492 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1493 ff_reduce_index(s, st->index);
1494 av_add_index_entry(st, pkt->pos, pkt->dts,
1495 0, 0, AVINDEX_KEYFRAME);
1498 } else if (st->discard < AVDISCARD_ALL) {
1499 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1503 av_free_packet(&cur_pkt);
1505 if (pkt->flags & AV_PKT_FLAG_KEY)
1506 st->skip_to_keyframe = 0;
1507 if (st->skip_to_keyframe) {
1508 av_free_packet(&cur_pkt);
1516 if (!got_packet && s->parse_queue)
1517 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1520 AVStream *st = s->streams[pkt->stream_index];
1521 if (st->skip_samples) {
1522 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1524 AV_WL32(p, st->skip_samples);
1525 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1527 st->skip_samples = 0;
1531 if (ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1532 av_packet_merge_side_data(pkt);
1534 if (s->debug & FF_FDEBUG_TS)
1535 av_log(s, AV_LOG_DEBUG,
1536 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1537 "size=%d, duration=%d, flags=%d\n",
1539 av_ts2str(pkt->pts),
1540 av_ts2str(pkt->dts),
1541 pkt->size, pkt->duration, pkt->flags);
1546 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1548 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1554 ret = s->packet_buffer
1555 ? read_from_packet_buffer(&s->packet_buffer,
1556 &s->packet_buffer_end, pkt)
1557 : read_frame_internal(s, pkt);
1564 AVPacketList *pktl = s->packet_buffer;
1567 AVPacket *next_pkt = &pktl->pkt;
1569 if (next_pkt->dts != AV_NOPTS_VALUE) {
1570 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1571 // last dts seen for this stream. if any of packets following
1572 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1573 int64_t last_dts = next_pkt->dts;
1574 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1575 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1576 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1577 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1579 next_pkt->pts = pktl->pkt.dts;
1581 if (last_dts != AV_NOPTS_VALUE) {
1582 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1583 last_dts = pktl->pkt.dts;
1588 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1589 // Fixing the last reference frame had none pts issue (For MXF etc).
1590 // We only do this when
1592 // 2. we are not able to resolve a pts value for current packet.
1593 // 3. the packets for this stream at the end of the files had valid dts.
1594 next_pkt->pts = last_dts + next_pkt->duration;
1596 pktl = s->packet_buffer;
1599 /* read packet from packet buffer, if there is data */
1600 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1601 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1602 ret = read_from_packet_buffer(&s->packet_buffer,
1603 &s->packet_buffer_end, pkt);
1608 ret = read_frame_internal(s, pkt);
1610 if (pktl && ret != AVERROR(EAGAIN)) {
1617 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1618 &s->packet_buffer_end)) < 0)
1619 return AVERROR(ENOMEM);
1624 st = s->streams[pkt->stream_index];
1625 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1626 ff_reduce_index(s, st->index);
1627 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1630 if (is_relative(pkt->dts))
1631 pkt->dts -= RELATIVE_TS_BASE;
1632 if (is_relative(pkt->pts))
1633 pkt->pts -= RELATIVE_TS_BASE;
1638 /* XXX: suppress the packet queue */
1639 static void flush_packet_queue(AVFormatContext *s)
1641 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1642 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1643 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1645 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1648 /*******************************************************/
1651 int av_find_default_stream_index(AVFormatContext *s)
1653 int first_audio_index = -1;
1657 if (s->nb_streams <= 0)
1659 for (i = 0; i < s->nb_streams; i++) {
1661 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1662 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1665 if (first_audio_index < 0 &&
1666 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1667 first_audio_index = i;
1669 return first_audio_index >= 0 ? first_audio_index : 0;
1672 /** Flush the frame reader. */
1673 void ff_read_frame_flush(AVFormatContext *s)
1678 flush_packet_queue(s);
1680 /* Reset read state for each stream. */
1681 for (i = 0; i < s->nb_streams; i++) {
1685 av_parser_close(st->parser);
1688 st->last_IP_pts = AV_NOPTS_VALUE;
1689 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1690 if (st->first_dts == AV_NOPTS_VALUE)
1691 st->cur_dts = RELATIVE_TS_BASE;
1693 /* We set the current DTS to an unspecified origin. */
1694 st->cur_dts = AV_NOPTS_VALUE;
1696 st->probe_packets = MAX_PROBE_PACKETS;
1698 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1699 st->pts_buffer[j] = AV_NOPTS_VALUE;
1703 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1707 for (i = 0; i < s->nb_streams; i++) {
1708 AVStream *st = s->streams[i];
1711 av_rescale(timestamp,
1712 st->time_base.den * (int64_t) ref_st->time_base.num,
1713 st->time_base.num * (int64_t) ref_st->time_base.den);
1717 void ff_reduce_index(AVFormatContext *s, int stream_index)
1719 AVStream *st = s->streams[stream_index];
1720 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1722 if ((unsigned) st->nb_index_entries >= max_entries) {
1724 for (i = 0; 2 * i < st->nb_index_entries; i++)
1725 st->index_entries[i] = st->index_entries[2 * i];
1726 st->nb_index_entries = i;
1730 int ff_add_index_entry(AVIndexEntry **index_entries,
1731 int *nb_index_entries,
1732 unsigned int *index_entries_allocated_size,
1733 int64_t pos, int64_t timestamp,
1734 int size, int distance, int flags)
1736 AVIndexEntry *entries, *ie;
1739 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1742 if (timestamp == AV_NOPTS_VALUE)
1743 return AVERROR(EINVAL);
1745 if (size < 0 || size > 0x3FFFFFFF)
1746 return AVERROR(EINVAL);
1748 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1749 timestamp -= RELATIVE_TS_BASE;
1751 entries = av_fast_realloc(*index_entries,
1752 index_entries_allocated_size,
1753 (*nb_index_entries + 1) *
1754 sizeof(AVIndexEntry));
1758 *index_entries = entries;
1760 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1761 timestamp, AVSEEK_FLAG_ANY);
1764 index = (*nb_index_entries)++;
1765 ie = &entries[index];
1766 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1768 ie = &entries[index];
1769 if (ie->timestamp != timestamp) {
1770 if (ie->timestamp <= timestamp)
1772 memmove(entries + index + 1, entries + index,
1773 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1774 (*nb_index_entries)++;
1775 } else if (ie->pos == pos && distance < ie->min_distance)
1776 // do not reduce the distance
1777 distance = ie->min_distance;
1781 ie->timestamp = timestamp;
1782 ie->min_distance = distance;
1789 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1790 int size, int distance, int flags)
1792 timestamp = wrap_timestamp(st, timestamp);
1793 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1794 &st->index_entries_allocated_size, pos,
1795 timestamp, size, distance, flags);
1798 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1799 int64_t wanted_timestamp, int flags)
1807 // Optimize appending index entries at the end.
1808 if (b && entries[b - 1].timestamp < wanted_timestamp)
1813 timestamp = entries[m].timestamp;
1814 if (timestamp >= wanted_timestamp)
1816 if (timestamp <= wanted_timestamp)
1819 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1821 if (!(flags & AVSEEK_FLAG_ANY))
1822 while (m >= 0 && m < nb_entries &&
1823 !(entries[m].flags & AVINDEX_KEYFRAME))
1824 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1826 if (m == nb_entries)
1831 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1833 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1834 wanted_timestamp, flags);
1837 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1838 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1840 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1841 if (stream_index >= 0)
1842 ts = wrap_timestamp(s->streams[stream_index], ts);
1846 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1847 int64_t target_ts, int flags)
1849 AVInputFormat *avif = s->iformat;
1850 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1851 int64_t ts_min, ts_max, ts;
1856 if (stream_index < 0)
1859 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1862 ts_min = AV_NOPTS_VALUE;
1863 pos_limit = -1; // GCC falsely says it may be uninitialized.
1865 st = s->streams[stream_index];
1866 if (st->index_entries) {
1869 /* FIXME: Whole function must be checked for non-keyframe entries in
1870 * index case, especially read_timestamp(). */
1871 index = av_index_search_timestamp(st, target_ts,
1872 flags | AVSEEK_FLAG_BACKWARD);
1873 index = FFMAX(index, 0);
1874 e = &st->index_entries[index];
1876 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1878 ts_min = e->timestamp;
1879 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1880 pos_min, av_ts2str(ts_min));
1882 av_assert1(index == 0);
1885 index = av_index_search_timestamp(st, target_ts,
1886 flags & ~AVSEEK_FLAG_BACKWARD);
1887 av_assert0(index < st->nb_index_entries);
1889 e = &st->index_entries[index];
1890 av_assert1(e->timestamp >= target_ts);
1892 ts_max = e->timestamp;
1893 pos_limit = pos_max - e->min_distance;
1894 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1895 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1899 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1900 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1905 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1908 ff_read_frame_flush(s);
1909 ff_update_cur_dts(s, st, ts);
1914 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1915 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1917 int64_t step = 1024;
1918 int64_t limit, ts_max;
1919 int64_t filesize = avio_size(s->pb);
1920 int64_t pos_max = filesize - 1;
1923 pos_max = FFMAX(0, (pos_max) - step);
1924 ts_max = ff_read_timestamp(s, stream_index,
1925 &pos_max, limit, read_timestamp);
1927 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1928 if (ts_max == AV_NOPTS_VALUE)
1932 int64_t tmp_pos = pos_max + 1;
1933 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1934 &tmp_pos, INT64_MAX, read_timestamp);
1935 if (tmp_ts == AV_NOPTS_VALUE)
1937 av_assert0(tmp_pos > pos_max);
1940 if (tmp_pos >= filesize)
1952 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1953 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1954 int64_t ts_min, int64_t ts_max,
1955 int flags, int64_t *ts_ret,
1956 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1957 int64_t *, int64_t))
1964 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1966 if (ts_min == AV_NOPTS_VALUE) {
1967 pos_min = s->data_offset;
1968 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1969 if (ts_min == AV_NOPTS_VALUE)
1973 if (ts_min >= target_ts) {
1978 if (ts_max == AV_NOPTS_VALUE) {
1979 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1981 pos_limit = pos_max;
1984 if (ts_max <= target_ts) {
1989 if (ts_min > ts_max)
1991 else if (ts_min == ts_max)
1992 pos_limit = pos_min;
1995 while (pos_min < pos_limit) {
1997 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1998 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1999 assert(pos_limit <= pos_max);
2001 if (no_change == 0) {
2002 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2003 // interpolate position (better than dichotomy)
2004 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2006 pos_min - approximate_keyframe_distance;
2007 } else if (no_change == 1) {
2008 // bisection if interpolation did not change min / max pos last time
2009 pos = (pos_min + pos_limit) >> 1;
2011 /* linear search if bisection failed, can only happen if there
2012 * are very few or no keyframes between min/max */
2017 else if (pos > pos_limit)
2021 // May pass pos_limit instead of -1.
2022 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2027 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2028 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2029 pos_min, pos, pos_max,
2030 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2031 pos_limit, start_pos, no_change);
2032 if (ts == AV_NOPTS_VALUE) {
2033 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2036 assert(ts != AV_NOPTS_VALUE);
2037 if (target_ts <= ts) {
2038 pos_limit = start_pos - 1;
2042 if (target_ts >= ts) {
2048 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2049 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2052 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2054 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2055 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2056 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2062 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2063 int64_t pos, int flags)
2065 int64_t pos_min, pos_max;
2067 pos_min = s->data_offset;
2068 pos_max = avio_size(s->pb) - 1;
2072 else if (pos > pos_max)
2075 avio_seek(s->pb, pos, SEEK_SET);
2077 s->io_repositioned = 1;
2082 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2083 int64_t timestamp, int flags)
2090 st = s->streams[stream_index];
2092 index = av_index_search_timestamp(st, timestamp, flags);
2094 if (index < 0 && st->nb_index_entries &&
2095 timestamp < st->index_entries[0].timestamp)
2098 if (index < 0 || index == st->nb_index_entries - 1) {
2102 if (st->nb_index_entries) {
2103 av_assert0(st->index_entries);
2104 ie = &st->index_entries[st->nb_index_entries - 1];
2105 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2107 ff_update_cur_dts(s, st, ie->timestamp);
2109 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2115 read_status = av_read_frame(s, &pkt);
2116 } while (read_status == AVERROR(EAGAIN));
2117 if (read_status < 0)
2119 av_free_packet(&pkt);
2120 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2121 if (pkt.flags & AV_PKT_FLAG_KEY)
2123 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2124 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);
2129 index = av_index_search_timestamp(st, timestamp, flags);
2134 ff_read_frame_flush(s);
2135 if (s->iformat->read_seek)
2136 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2138 ie = &st->index_entries[index];
2139 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2141 ff_update_cur_dts(s, st, ie->timestamp);
2146 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2147 int64_t timestamp, int flags)
2152 if (flags & AVSEEK_FLAG_BYTE) {
2153 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2155 ff_read_frame_flush(s);
2156 return seek_frame_byte(s, stream_index, timestamp, flags);
2159 if (stream_index < 0) {
2160 stream_index = av_find_default_stream_index(s);
2161 if (stream_index < 0)
2164 st = s->streams[stream_index];
2165 /* timestamp for default must be expressed in AV_TIME_BASE units */
2166 timestamp = av_rescale(timestamp, st->time_base.den,
2167 AV_TIME_BASE * (int64_t) st->time_base.num);
2170 /* first, we try the format specific seek */
2171 if (s->iformat->read_seek) {
2172 ff_read_frame_flush(s);
2173 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2179 if (s->iformat->read_timestamp &&
2180 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2181 ff_read_frame_flush(s);
2182 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2183 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2184 ff_read_frame_flush(s);
2185 return seek_frame_generic(s, stream_index, timestamp, flags);
2190 int av_seek_frame(AVFormatContext *s, int stream_index,
2191 int64_t timestamp, int flags)
2195 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2196 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2197 if ((flags & AVSEEK_FLAG_BACKWARD))
2201 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2202 flags & ~AVSEEK_FLAG_BACKWARD);
2205 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2208 ret = avformat_queue_attached_pictures(s);
2213 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2214 int64_t ts, int64_t max_ts, int flags)
2216 if (min_ts > ts || max_ts < ts)
2218 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2219 return AVERROR(EINVAL);
2222 flags |= AVSEEK_FLAG_ANY;
2223 flags &= ~AVSEEK_FLAG_BACKWARD;
2225 if (s->iformat->read_seek2) {
2227 ff_read_frame_flush(s);
2229 if (stream_index == -1 && s->nb_streams == 1) {
2230 AVRational time_base = s->streams[0]->time_base;
2231 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2232 min_ts = av_rescale_rnd(min_ts, time_base.den,
2233 time_base.num * (int64_t)AV_TIME_BASE,
2234 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2235 max_ts = av_rescale_rnd(max_ts, time_base.den,
2236 time_base.num * (int64_t)AV_TIME_BASE,
2237 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2240 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2244 ret = avformat_queue_attached_pictures(s);
2248 if (s->iformat->read_timestamp) {
2249 // try to seek via read_timestamp()
2252 // Fall back on old API if new is not implemented but old is.
2253 // Note the old API has somewhat different semantics.
2254 if (s->iformat->read_seek || 1) {
2255 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2256 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2257 if (ret<0 && ts != min_ts && max_ts != ts) {
2258 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2260 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2265 // try some generic seek like seek_frame_generic() but with new ts semantics
2266 return -1; //unreachable
2269 /*******************************************************/
2272 * Return TRUE if the stream has accurate duration in any stream.
2274 * @return TRUE if the stream has accurate duration for at least one component.
2276 static int has_duration(AVFormatContext *ic)
2281 for (i = 0; i < ic->nb_streams; i++) {
2282 st = ic->streams[i];
2283 if (st->duration != AV_NOPTS_VALUE)
2286 if (ic->duration != AV_NOPTS_VALUE)
2292 * Estimate the stream timings from the one of each components.
2294 * Also computes the global bitrate if possible.
2296 static void update_stream_timings(AVFormatContext *ic)
2298 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2299 int64_t duration, duration1, filesize;
2304 start_time = INT64_MAX;
2305 start_time_text = INT64_MAX;
2306 end_time = INT64_MIN;
2307 duration = INT64_MIN;
2308 for (i = 0; i < ic->nb_streams; i++) {
2309 st = ic->streams[i];
2310 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2311 start_time1 = av_rescale_q(st->start_time, st->time_base,
2313 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2314 if (start_time1 < start_time_text)
2315 start_time_text = start_time1;
2317 start_time = FFMIN(start_time, start_time1);
2318 end_time1 = AV_NOPTS_VALUE;
2319 if (st->duration != AV_NOPTS_VALUE) {
2320 end_time1 = start_time1 +
2321 av_rescale_q(st->duration, st->time_base,
2323 end_time = FFMAX(end_time, end_time1);
2325 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2326 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2327 p->start_time = start_time1;
2328 if (p->end_time < end_time1)
2329 p->end_time = end_time1;
2332 if (st->duration != AV_NOPTS_VALUE) {
2333 duration1 = av_rescale_q(st->duration, st->time_base,
2335 duration = FFMAX(duration, duration1);
2338 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2339 start_time = start_time_text;
2340 else if (start_time > start_time_text)
2341 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2343 if (start_time != INT64_MAX) {
2344 ic->start_time = start_time;
2345 if (end_time != INT64_MIN) {
2346 if (ic->nb_programs) {
2347 for (i = 0; i < ic->nb_programs; i++) {
2348 p = ic->programs[i];
2349 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2350 duration = FFMAX(duration, p->end_time - p->start_time);
2353 duration = FFMAX(duration, end_time - start_time);
2356 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2357 ic->duration = duration;
2359 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2360 /* compute the bitrate */
2361 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2362 (double) ic->duration;
2363 if (bitrate >= 0 && bitrate <= INT_MAX)
2364 ic->bit_rate = bitrate;
2368 static void fill_all_stream_timings(AVFormatContext *ic)
2373 update_stream_timings(ic);
2374 for (i = 0; i < ic->nb_streams; i++) {
2375 st = ic->streams[i];
2376 if (st->start_time == AV_NOPTS_VALUE) {
2377 if (ic->start_time != AV_NOPTS_VALUE)
2378 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2380 if (ic->duration != AV_NOPTS_VALUE)
2381 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2387 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2389 int64_t filesize, duration;
2390 int i, show_warning = 0;
2393 /* if bit_rate is already set, we believe it */
2394 if (ic->bit_rate <= 0) {
2396 for (i = 0; i < ic->nb_streams; i++) {
2397 st = ic->streams[i];
2398 if (st->codec->bit_rate > 0) {
2399 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2403 bit_rate += st->codec->bit_rate;
2406 ic->bit_rate = bit_rate;
2409 /* if duration is already set, we believe it */
2410 if (ic->duration == AV_NOPTS_VALUE &&
2411 ic->bit_rate != 0) {
2412 filesize = ic->pb ? avio_size(ic->pb) : 0;
2414 for (i = 0; i < ic->nb_streams; i++) {
2415 st = ic->streams[i];
2416 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2417 && st->duration == AV_NOPTS_VALUE) {
2418 duration = av_rescale(8 * filesize, st->time_base.den,
2420 (int64_t) st->time_base.num);
2421 st->duration = duration;
2428 av_log(ic, AV_LOG_WARNING,
2429 "Estimating duration from bitrate, this may be inaccurate\n");
2432 #define DURATION_MAX_READ_SIZE 250000LL
2433 #define DURATION_MAX_RETRY 4
2435 /* only usable for MPEG-PS streams */
2436 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2438 AVPacket pkt1, *pkt = &pkt1;
2440 int read_size, i, ret;
2442 int64_t filesize, offset, duration;
2445 /* flush packet queue */
2446 flush_packet_queue(ic);
2448 for (i = 0; i < ic->nb_streams; i++) {
2449 st = ic->streams[i];
2450 if (st->start_time == AV_NOPTS_VALUE &&
2451 st->first_dts == AV_NOPTS_VALUE &&
2452 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2453 av_log(st->codec, AV_LOG_WARNING,
2454 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2457 av_parser_close(st->parser);
2462 /* estimate the end time (duration) */
2463 /* XXX: may need to support wrapping */
2464 filesize = ic->pb ? avio_size(ic->pb) : 0;
2465 end_time = AV_NOPTS_VALUE;
2467 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2471 avio_seek(ic->pb, offset, SEEK_SET);
2474 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2478 ret = ff_read_packet(ic, pkt);
2479 } while (ret == AVERROR(EAGAIN));
2482 read_size += pkt->size;
2483 st = ic->streams[pkt->stream_index];
2484 if (pkt->pts != AV_NOPTS_VALUE &&
2485 (st->start_time != AV_NOPTS_VALUE ||
2486 st->first_dts != AV_NOPTS_VALUE)) {
2487 duration = end_time = pkt->pts;
2488 if (st->start_time != AV_NOPTS_VALUE)
2489 duration -= st->start_time;
2491 duration -= st->first_dts;
2493 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2494 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2495 st->duration = duration;
2496 st->info->last_duration = duration;
2499 av_free_packet(pkt);
2501 } while (end_time == AV_NOPTS_VALUE &&
2502 filesize > (DURATION_MAX_READ_SIZE << retry) &&
2503 ++retry <= DURATION_MAX_RETRY);
2505 fill_all_stream_timings(ic);
2507 avio_seek(ic->pb, old_offset, SEEK_SET);
2508 for (i = 0; i < ic->nb_streams; i++) {
2511 st = ic->streams[i];
2512 st->cur_dts = st->first_dts;
2513 st->last_IP_pts = AV_NOPTS_VALUE;
2514 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2515 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2516 st->pts_buffer[j] = AV_NOPTS_VALUE;
2520 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2524 /* get the file size, if possible */
2525 if (ic->iformat->flags & AVFMT_NOFILE) {
2528 file_size = avio_size(ic->pb);
2529 file_size = FFMAX(0, file_size);
2532 if ((!strcmp(ic->iformat->name, "mpeg") ||
2533 !strcmp(ic->iformat->name, "mpegts")) &&
2534 file_size && ic->pb->seekable) {
2535 /* get accurate estimate from the PTSes */
2536 estimate_timings_from_pts(ic, old_offset);
2537 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2538 } else if (has_duration(ic)) {
2539 /* at least one component has timings - we use them for all
2541 fill_all_stream_timings(ic);
2542 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2544 /* less precise: use bitrate info */
2545 estimate_timings_from_bit_rate(ic);
2546 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2548 update_stream_timings(ic);
2552 AVStream av_unused *st;
2553 for (i = 0; i < ic->nb_streams; i++) {
2554 st = ic->streams[i];
2555 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2556 (double) st->start_time / AV_TIME_BASE,
2557 (double) st->duration / AV_TIME_BASE);
2560 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2561 (double) ic->start_time / AV_TIME_BASE,
2562 (double) ic->duration / AV_TIME_BASE,
2563 ic->bit_rate / 1000);
2567 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2569 AVCodecContext *avctx = st->codec;
2571 #define FAIL(errmsg) do { \
2573 *errmsg_ptr = errmsg; \
2577 switch (avctx->codec_type) {
2578 case AVMEDIA_TYPE_AUDIO:
2579 if (!avctx->frame_size && determinable_frame_size(avctx))
2580 FAIL("unspecified frame size");
2581 if (st->info->found_decoder >= 0 &&
2582 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2583 FAIL("unspecified sample format");
2584 if (!avctx->sample_rate)
2585 FAIL("unspecified sample rate");
2586 if (!avctx->channels)
2587 FAIL("unspecified number of channels");
2588 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2589 FAIL("no decodable DTS frames");
2591 case AVMEDIA_TYPE_VIDEO:
2593 FAIL("unspecified size");
2594 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2595 FAIL("unspecified pixel format");
2596 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2597 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2598 FAIL("no frame in rv30/40 and no sar");
2600 case AVMEDIA_TYPE_SUBTITLE:
2601 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2602 FAIL("unspecified size");
2604 case AVMEDIA_TYPE_DATA:
2605 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2608 if (avctx->codec_id == AV_CODEC_ID_NONE)
2609 FAIL("unknown codec");
2613 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2614 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2615 AVDictionary **options)
2617 const AVCodec *codec;
2618 int got_picture = 1, ret = 0;
2619 AVFrame *frame = av_frame_alloc();
2620 AVSubtitle subtitle;
2621 AVPacket pkt = *avpkt;
2624 return AVERROR(ENOMEM);
2626 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2627 AVDictionary *thread_opt = NULL;
2629 codec = find_decoder(s, st, st->codec->codec_id);
2632 st->info->found_decoder = -1;
2637 /* Force thread count to 1 since the H.264 decoder will not extract
2638 * SPS and PPS to extradata during multi-threaded decoding. */
2639 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2640 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2642 av_dict_free(&thread_opt);
2644 st->info->found_decoder = -1;
2647 st->info->found_decoder = 1;
2648 } else if (!st->info->found_decoder)
2649 st->info->found_decoder = 1;
2651 if (st->info->found_decoder < 0) {
2656 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2658 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2659 (!st->codec_info_nb_frames &&
2660 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2662 switch (st->codec->codec_type) {
2663 case AVMEDIA_TYPE_VIDEO:
2664 ret = avcodec_decode_video2(st->codec, frame,
2665 &got_picture, &pkt);
2667 case AVMEDIA_TYPE_AUDIO:
2668 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2670 case AVMEDIA_TYPE_SUBTITLE:
2671 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2672 &got_picture, &pkt);
2680 st->nb_decoded_frames++;
2687 if (!pkt.data && !got_picture)
2691 av_frame_free(&frame);
2695 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2697 while (tags->id != AV_CODEC_ID_NONE) {
2705 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2708 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2709 if (tag == tags[i].tag)
2711 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2712 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2714 return AV_CODEC_ID_NONE;
2717 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2722 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2724 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2726 return AV_CODEC_ID_NONE;
2731 if (sflags & (1 << (bps - 1))) {
2734 return AV_CODEC_ID_PCM_S8;
2736 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2738 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2740 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2742 return AV_CODEC_ID_NONE;
2747 return AV_CODEC_ID_PCM_U8;
2749 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2751 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2753 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2755 return AV_CODEC_ID_NONE;
2761 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2764 if (!av_codec_get_tag2(tags, id, &tag))
2769 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2773 for (i = 0; tags && tags[i]; i++) {
2774 const AVCodecTag *codec_tags = tags[i];
2775 while (codec_tags->id != AV_CODEC_ID_NONE) {
2776 if (codec_tags->id == id) {
2777 *tag = codec_tags->tag;
2786 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2789 for (i = 0; tags && tags[i]; i++) {
2790 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2791 if (id != AV_CODEC_ID_NONE)
2794 return AV_CODEC_ID_NONE;
2797 static void compute_chapters_end(AVFormatContext *s)
2800 int64_t max_time = s->duration +
2801 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2803 for (i = 0; i < s->nb_chapters; i++)
2804 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2805 AVChapter *ch = s->chapters[i];
2806 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2810 for (j = 0; j < s->nb_chapters; j++) {
2811 AVChapter *ch1 = s->chapters[j];
2812 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2814 if (j != i && next_start > ch->start && next_start < end)
2817 ch->end = (end == INT64_MAX) ? ch->start : end;
2821 static int get_std_framerate(int i)
2824 return (i + 1) * 1001;
2826 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2829 /* Is the time base unreliable?
2830 * This is a heuristic to balance between quick acceptance of the values in
2831 * the headers vs. some extra checks.
2832 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2833 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2834 * And there are "variable" fps files this needs to detect as well. */
2835 static int tb_unreliable(AVCodecContext *c)
2837 if (c->time_base.den >= 101L * c->time_base.num ||
2838 c->time_base.den < 5L * c->time_base.num ||
2839 // c->codec_tag == AV_RL32("DIVX") ||
2840 // c->codec_tag == AV_RL32("XVID") ||
2841 c->codec_tag == AV_RL32("mp4v") ||
2842 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2843 c->codec_id == AV_CODEC_ID_H264)
2848 #if FF_API_FORMAT_PARAMETERS
2849 int av_find_stream_info(AVFormatContext *ic)
2851 return avformat_find_stream_info(ic, NULL);
2855 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2859 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2860 avctx->extradata_size = 0;
2861 return AVERROR(EINVAL);
2863 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2864 if (avctx->extradata) {
2865 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2866 avctx->extradata_size = size;
2869 avctx->extradata_size = 0;
2870 ret = AVERROR(ENOMEM);
2875 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2877 int ret = ff_alloc_extradata(avctx, size);
2880 ret = avio_read(pb, avctx->extradata, size);
2882 av_freep(&avctx->extradata);
2883 avctx->extradata_size = 0;
2884 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2885 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2891 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2894 int64_t last = st->info->last_dts;
2896 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2897 && ts - (uint64_t)last < INT64_MAX) {
2898 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2899 int64_t duration = ts - last;
2901 if (!st->info->duration_error)
2902 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2903 if (!st->info->duration_error)
2904 return AVERROR(ENOMEM);
2906 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2907 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2908 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2909 if (st->info->duration_error[0][1][i] < 1e10) {
2910 int framerate = get_std_framerate(i);
2911 double sdts = dts*framerate/(1001*12);
2912 for (j= 0; j<2; j++) {
2913 int64_t ticks = llrint(sdts+j*0.5);
2914 double error= sdts - ticks + j*0.5;
2915 st->info->duration_error[j][0][i] += error;
2916 st->info->duration_error[j][1][i] += error*error;
2920 st->info->duration_count++;
2921 st->info->rfps_duration_sum += duration;
2923 if (st->info->duration_count % 10 == 0) {
2924 int n = st->info->duration_count;
2925 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2926 if (st->info->duration_error[0][1][i] < 1e10) {
2927 double a0 = st->info->duration_error[0][0][i] / n;
2928 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2929 double a1 = st->info->duration_error[1][0][i] / n;
2930 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2931 if (error0 > 0.04 && error1 > 0.04) {
2932 st->info->duration_error[0][1][i] = 2e10;
2933 st->info->duration_error[1][1][i] = 2e10;
2939 // ignore the first 4 values, they might have some random jitter
2940 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2941 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2943 if (ts != AV_NOPTS_VALUE)
2944 st->info->last_dts = ts;
2949 void ff_rfps_calculate(AVFormatContext *ic)
2953 for (i = 0; i < ic->nb_streams; i++) {
2954 AVStream *st = ic->streams[i];
2956 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2958 // the check for tb_unreliable() is not completely correct, since this is not about handling
2959 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2960 // ipmovie.c produces.
2961 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)
2962 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);
2963 if (st->info->duration_count>1 && !st->r_frame_rate.num
2964 && tb_unreliable(st->codec)) {
2966 double best_error= 0.01;
2968 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2971 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2973 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2976 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2979 for (k= 0; k<2; k++) {
2980 int n = st->info->duration_count;
2981 double a= st->info->duration_error[k][0][j] / n;
2982 double error= st->info->duration_error[k][1][j]/n - a*a;
2984 if (error < best_error && best_error> 0.000000001) {
2986 num = get_std_framerate(j);
2989 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2992 // do not increase frame rate by more than 1 % in order to match a standard rate.
2993 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2994 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2997 av_freep(&st->info->duration_error);
2998 st->info->last_dts = AV_NOPTS_VALUE;
2999 st->info->duration_count = 0;
3000 st->info->rfps_duration_sum = 0;
3004 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3006 int i, count, ret = 0, j;
3009 AVPacket pkt1, *pkt;
3010 int64_t old_offset = avio_tell(ic->pb);
3011 // new streams might appear, no options for those
3012 int orig_nb_streams = ic->nb_streams;
3013 int flush_codecs = ic->probesize > 0;
3016 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3017 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3019 for (i = 0; i < ic->nb_streams; i++) {
3020 const AVCodec *codec;
3021 AVDictionary *thread_opt = NULL;
3022 st = ic->streams[i];
3024 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3025 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3026 /* if (!st->time_base.num)
3028 if (!st->codec->time_base.num)
3029 st->codec->time_base = st->time_base;
3031 // only for the split stuff
3032 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3033 st->parser = av_parser_init(st->codec->codec_id);
3035 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3036 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3037 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3038 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3040 } else if (st->need_parsing) {
3041 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3042 "%s, packets or times may be invalid.\n",
3043 avcodec_get_name(st->codec->codec_id));
3046 codec = find_decoder(ic, st, st->codec->codec_id);
3048 /* Force thread count to 1 since the H.264 decoder will not extract
3049 * SPS and PPS to extradata during multi-threaded decoding. */
3050 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3052 /* Ensure that subtitle_header is properly set. */
3053 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3054 && codec && !st->codec->codec) {
3055 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3056 av_log(ic, AV_LOG_WARNING,
3057 "Failed to open codec in av_find_stream_info\n");
3060 // Try to just open decoders, in case this is enough to get parameters.
3061 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3062 if (codec && !st->codec->codec)
3063 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3064 av_log(ic, AV_LOG_WARNING,
3065 "Failed to open codec in av_find_stream_info\n");
3068 av_dict_free(&thread_opt);
3071 for (i = 0; i < ic->nb_streams; i++) {
3072 #if FF_API_R_FRAME_RATE
3073 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3075 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3076 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3082 if (ff_check_interrupt(&ic->interrupt_callback)) {
3084 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3088 /* check if one codec still needs to be handled */
3089 for (i = 0; i < ic->nb_streams; i++) {
3090 int fps_analyze_framecount = 20;
3092 st = ic->streams[i];
3093 if (!has_codec_parameters(st, NULL))
3095 /* If the timebase is coarse (like the usual millisecond precision
3096 * of mkv), we need to analyze more frames to reliably arrive at
3097 * the correct fps. */
3098 if (av_q2d(st->time_base) > 0.0005)
3099 fps_analyze_framecount *= 2;
3100 if (ic->fps_probe_size >= 0)
3101 fps_analyze_framecount = ic->fps_probe_size;
3102 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3103 fps_analyze_framecount = 0;
3104 /* variable fps and no guess at the real fps */
3105 if (tb_unreliable(st->codec) &&
3106 !(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3107 st->info->duration_count < fps_analyze_framecount &&
3108 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3110 if (st->parser && st->parser->parser->split &&
3111 !st->codec->extradata)
3113 if (st->first_dts == AV_NOPTS_VALUE &&
3114 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3115 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3118 if (i == ic->nb_streams) {
3119 /* NOTE: If the format has no header, then we need to read some
3120 * packets to get most of the streams, so we cannot stop here. */
3121 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3122 /* If we found the info for all the codecs, we can stop. */
3124 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3129 /* We did not get all the codec info, but we read too much data. */
3130 if (read_size >= ic->probesize) {
3132 av_log(ic, AV_LOG_DEBUG,
3133 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3134 for (i = 0; i < ic->nb_streams; i++)
3135 if (!ic->streams[i]->r_frame_rate.num &&
3136 ic->streams[i]->info->duration_count <= 1 &&
3137 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3138 strcmp(ic->iformat->name, "image2"))
3139 av_log(ic, AV_LOG_WARNING,
3140 "Stream #%d: not enough frames to estimate rate; "
3141 "consider increasing probesize\n", i);
3145 /* NOTE: A new stream can be added there if no header in file
3146 * (AVFMTCTX_NOHEADER). */
3147 ret = read_frame_internal(ic, &pkt1);
3148 if (ret == AVERROR(EAGAIN))
3156 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3157 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3159 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3160 &ic->packet_buffer_end);
3162 ret = AVERROR(ENOMEM);
3163 goto find_stream_info_err;
3165 if ((ret = av_dup_packet(pkt)) < 0)
3166 goto find_stream_info_err;
3169 st = ic->streams[pkt->stream_index];
3170 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3171 read_size += pkt->size;
3173 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3174 /* check for non-increasing dts */
3175 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3176 st->info->fps_last_dts >= pkt->dts) {
3177 av_log(ic, AV_LOG_DEBUG,
3178 "Non-increasing DTS in stream %d: packet %d with DTS "
3179 "%"PRId64", packet %d with DTS %"PRId64"\n",
3180 st->index, st->info->fps_last_dts_idx,
3181 st->info->fps_last_dts, st->codec_info_nb_frames,
3183 st->info->fps_first_dts =
3184 st->info->fps_last_dts = AV_NOPTS_VALUE;
3186 /* Check for a discontinuity in dts. If the difference in dts
3187 * is more than 1000 times the average packet duration in the
3188 * sequence, we treat it as a discontinuity. */
3189 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3190 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3191 (pkt->dts - st->info->fps_last_dts) / 1000 >
3192 (st->info->fps_last_dts - st->info->fps_first_dts) /
3193 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3194 av_log(ic, AV_LOG_WARNING,
3195 "DTS discontinuity in stream %d: packet %d with DTS "
3196 "%"PRId64", packet %d with DTS %"PRId64"\n",
3197 st->index, st->info->fps_last_dts_idx,
3198 st->info->fps_last_dts, st->codec_info_nb_frames,
3200 st->info->fps_first_dts =
3201 st->info->fps_last_dts = AV_NOPTS_VALUE;
3204 /* update stored dts values */
3205 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3206 st->info->fps_first_dts = pkt->dts;
3207 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3209 st->info->fps_last_dts = pkt->dts;
3210 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3212 if (st->codec_info_nb_frames>1) {
3214 if (st->time_base.den > 0)
3215 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3216 if (st->avg_frame_rate.num > 0)
3217 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3220 && st->codec_info_nb_frames>30
3221 && st->info->fps_first_dts != AV_NOPTS_VALUE
3222 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3223 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3225 if (t >= ic->max_analyze_duration) {
3226 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n",
3227 ic->max_analyze_duration,
3231 if (pkt->duration) {
3232 st->info->codec_info_duration += pkt->duration;
3233 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3236 #if FF_API_R_FRAME_RATE
3237 ff_rfps_add_frame(ic, st, pkt->dts);
3239 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3240 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3241 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3242 if (ff_alloc_extradata(st->codec, i))
3243 return AVERROR(ENOMEM);
3244 memcpy(st->codec->extradata, pkt->data,
3245 st->codec->extradata_size);
3249 /* If still no information, we try to open the codec and to
3250 * decompress the frame. We try to avoid that in most cases as
3251 * it takes longer and uses more memory. For MPEG-4, we need to
3252 * decompress for QuickTime.
3254 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3255 * least one frame of codec data, this makes sure the codec initializes
3256 * the channel configuration and does not only trust the values from
3258 try_decode_frame(ic, st, pkt,
3259 (options && i < orig_nb_streams) ? &options[i] : NULL);
3261 st->codec_info_nb_frames++;
3266 AVPacket empty_pkt = { 0 };
3268 av_init_packet(&empty_pkt);
3270 for (i = 0; i < ic->nb_streams; i++) {
3272 st = ic->streams[i];
3274 /* flush the decoders */
3275 if (st->info->found_decoder == 1) {
3277 err = try_decode_frame(ic, st, &empty_pkt,
3278 (options && i < orig_nb_streams)
3279 ? &options[i] : NULL);
3280 } while (err > 0 && !has_codec_parameters(st, NULL));
3283 av_log(ic, AV_LOG_INFO,
3284 "decoding for stream %d failed\n", st->index);
3290 // close codecs which were opened in try_decode_frame()
3291 for (i = 0; i < ic->nb_streams; i++) {
3292 st = ic->streams[i];
3293 avcodec_close(st->codec);
3296 ff_rfps_calculate(ic);
3298 for (i = 0; i < ic->nb_streams; i++) {
3299 st = ic->streams[i];
3300 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3301 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3302 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3303 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3304 st->codec->codec_tag= tag;
3307 /* estimate average framerate if not set by demuxer */
3308 if (st->info->codec_info_duration_fields &&
3309 !st->avg_frame_rate.num &&
3310 st->info->codec_info_duration) {
3312 double best_error = 0.01;
3314 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3315 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3316 st->info->codec_info_duration < 0)
3318 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3319 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3320 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3322 /* Round guessed framerate to a "standard" framerate if it's
3323 * within 1% of the original estimate. */
3324 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3325 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3326 double error = fabs(av_q2d(st->avg_frame_rate) /
3327 av_q2d(std_fps) - 1);
3329 if (error < best_error) {
3331 best_fps = std_fps.num;
3335 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3336 best_fps, 12 * 1001, INT_MAX);
3339 if (!st->r_frame_rate.num) {
3340 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3341 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3342 st->r_frame_rate.num = st->codec->time_base.den;
3343 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3345 st->r_frame_rate.num = st->time_base.den;
3346 st->r_frame_rate.den = st->time_base.num;
3349 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3350 if (!st->codec->bits_per_coded_sample)
3351 st->codec->bits_per_coded_sample =
3352 av_get_bits_per_sample(st->codec->codec_id);
3353 // set stream disposition based on audio service type
3354 switch (st->codec->audio_service_type) {
3355 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3356 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3358 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3359 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3361 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3362 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3364 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3365 st->disposition = AV_DISPOSITION_COMMENT;
3367 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3368 st->disposition = AV_DISPOSITION_KARAOKE;
3375 estimate_timings(ic, old_offset);
3377 if (ret >= 0 && ic->nb_streams)
3378 /* We could not have all the codec parameters before EOF. */
3380 for (i = 0; i < ic->nb_streams; i++) {
3382 st = ic->streams[i];
3383 if (!has_codec_parameters(st, &errmsg)) {
3385 avcodec_string(buf, sizeof(buf), st->codec, 0);
3386 av_log(ic, AV_LOG_WARNING,
3387 "Could not find codec parameters for stream %d (%s): %s\n"
3388 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3395 compute_chapters_end(ic);
3397 find_stream_info_err:
3398 for (i = 0; i < ic->nb_streams; i++) {
3399 st = ic->streams[i];
3400 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3401 ic->streams[i]->codec->thread_count = 0;
3403 av_freep(&st->info->duration_error);
3404 av_freep(&ic->streams[i]->info);
3407 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3408 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3412 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3416 for (i = 0; i < ic->nb_programs; i++) {
3417 if (ic->programs[i] == last) {
3421 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3422 if (ic->programs[i]->stream_index[j] == s)
3423 return ic->programs[i];
3429 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3430 int wanted_stream_nb, int related_stream,
3431 AVCodec **decoder_ret, int flags)
3433 int i, nb_streams = ic->nb_streams;
3434 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3435 unsigned *program = NULL;
3436 AVCodec *decoder = NULL, *best_decoder = NULL;
3438 if (related_stream >= 0 && wanted_stream_nb < 0) {
3439 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3441 program = p->stream_index;
3442 nb_streams = p->nb_stream_indexes;
3445 for (i = 0; i < nb_streams; i++) {
3446 int real_stream_index = program ? program[i] : i;
3447 AVStream *st = ic->streams[real_stream_index];
3448 AVCodecContext *avctx = st->codec;
3449 if (avctx->codec_type != type)
3451 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3453 if (wanted_stream_nb != real_stream_index &&
3454 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3455 AV_DISPOSITION_VISUAL_IMPAIRED))
3457 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3460 decoder = find_decoder(ic, st, st->codec->codec_id);
3463 ret = AVERROR_DECODER_NOT_FOUND;
3467 count = st->codec_info_nb_frames;
3468 bitrate = avctx->bit_rate;
3469 multiframe = FFMIN(5, count);
3470 if ((best_multiframe > multiframe) ||
3471 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3472 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3475 best_bitrate = bitrate;
3476 best_multiframe = multiframe;
3477 ret = real_stream_index;
3478 best_decoder = decoder;
3479 if (program && i == nb_streams - 1 && ret < 0) {
3481 nb_streams = ic->nb_streams;
3482 /* no related stream found, try again with everything */
3487 *decoder_ret = best_decoder;
3491 /*******************************************************/
3493 int av_read_play(AVFormatContext *s)
3495 if (s->iformat->read_play)
3496 return s->iformat->read_play(s);
3498 return avio_pause(s->pb, 0);
3499 return AVERROR(ENOSYS);
3502 int av_read_pause(AVFormatContext *s)
3504 if (s->iformat->read_pause)
3505 return s->iformat->read_pause(s);
3507 return avio_pause(s->pb, 1);
3508 return AVERROR(ENOSYS);
3511 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3513 av_assert0(s->nb_streams>0);
3514 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3516 for (j = 0; j < st->nb_side_data; j++)
3517 av_freep(&st->side_data[j].data);
3518 av_freep(&st->side_data);
3519 st->nb_side_data = 0;
3522 av_parser_close(st->parser);
3524 if (st->attached_pic.data)
3525 av_free_packet(&st->attached_pic);
3526 av_dict_free(&st->metadata);
3527 av_freep(&st->probe_data.buf);
3528 av_freep(&st->index_entries);
3529 av_freep(&st->codec->extradata);
3530 av_freep(&st->codec->subtitle_header);
3531 av_freep(&st->codec);
3532 av_freep(&st->priv_data);
3534 av_freep(&st->info->duration_error);
3535 av_freep(&st->info);
3536 av_freep(&s->streams[ --s->nb_streams ]);
3539 void avformat_free_context(AVFormatContext *s)
3547 if (s->iformat && s->iformat->priv_class && s->priv_data)
3548 av_opt_free(s->priv_data);
3549 if (s->oformat && s->oformat->priv_class && s->priv_data)
3550 av_opt_free(s->priv_data);
3552 for (i = s->nb_streams - 1; i >= 0; i--) {
3553 ff_free_stream(s, s->streams[i]);
3555 for (i = s->nb_programs - 1; i >= 0; i--) {
3556 av_dict_free(&s->programs[i]->metadata);
3557 av_freep(&s->programs[i]->stream_index);
3558 av_freep(&s->programs[i]);
3560 av_freep(&s->programs);
3561 av_freep(&s->priv_data);
3562 while (s->nb_chapters--) {
3563 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3564 av_freep(&s->chapters[s->nb_chapters]);
3566 av_freep(&s->chapters);
3567 av_dict_free(&s->metadata);
3568 av_freep(&s->streams);
3569 av_freep(&s->internal);
3573 #if FF_API_CLOSE_INPUT_FILE
3574 void av_close_input_file(AVFormatContext *s)
3576 avformat_close_input(&s);
3580 void avformat_close_input(AVFormatContext **ps)
3591 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3592 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3595 flush_packet_queue(s);
3598 if (s->iformat->read_close)
3599 s->iformat->read_close(s);
3601 avformat_free_context(s);
3608 #if FF_API_NEW_STREAM
3609 AVStream *av_new_stream(AVFormatContext *s, int id)
3611 AVStream *st = avformat_new_stream(s, NULL);
3618 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3624 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3626 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3629 s->streams = streams;
3631 st = av_mallocz(sizeof(AVStream));
3634 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3638 st->info->last_dts = AV_NOPTS_VALUE;
3640 st->codec = avcodec_alloc_context3(c);
3642 /* no default bitrate if decoding */
3643 st->codec->bit_rate = 0;
3644 st->index = s->nb_streams;
3645 st->start_time = AV_NOPTS_VALUE;
3646 st->duration = AV_NOPTS_VALUE;
3647 /* we set the current DTS to 0 so that formats without any timestamps
3648 * but durations get some timestamps, formats with some unknown
3649 * timestamps have their first few packets buffered and the
3650 * timestamps corrected before they are returned to the user */
3651 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3652 st->first_dts = AV_NOPTS_VALUE;
3653 st->probe_packets = MAX_PROBE_PACKETS;
3654 st->pts_wrap_reference = AV_NOPTS_VALUE;
3655 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3657 /* default pts setting is MPEG-like */
3658 avpriv_set_pts_info(st, 33, 1, 90000);
3659 st->last_IP_pts = AV_NOPTS_VALUE;
3660 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3661 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3662 st->pts_buffer[i] = AV_NOPTS_VALUE;
3664 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3666 #if FF_API_R_FRAME_RATE
3667 st->info->last_dts = AV_NOPTS_VALUE;
3669 st->info->fps_first_dts = AV_NOPTS_VALUE;
3670 st->info->fps_last_dts = AV_NOPTS_VALUE;
3672 s->streams[s->nb_streams++] = st;
3676 AVProgram *av_new_program(AVFormatContext *ac, int id)
3678 AVProgram *program = NULL;
3681 av_dlog(ac, "new_program: id=0x%04x\n", id);
3683 for (i = 0; i < ac->nb_programs; i++)
3684 if (ac->programs[i]->id == id)
3685 program = ac->programs[i];
3688 program = av_mallocz(sizeof(AVProgram));
3691 dynarray_add(&ac->programs, &ac->nb_programs, program);
3692 program->discard = AVDISCARD_NONE;
3695 program->pts_wrap_reference = AV_NOPTS_VALUE;
3696 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3698 program->start_time =
3699 program->end_time = AV_NOPTS_VALUE;
3704 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3705 int64_t start, int64_t end, const char *title)
3707 AVChapter *chapter = NULL;
3710 for (i = 0; i < s->nb_chapters; i++)
3711 if (s->chapters[i]->id == id)
3712 chapter = s->chapters[i];
3715 chapter = av_mallocz(sizeof(AVChapter));
3718 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3720 av_dict_set(&chapter->metadata, "title", title, 0);
3722 chapter->time_base = time_base;
3723 chapter->start = start;
3729 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3732 AVProgram *program = NULL;
3735 if (idx >= ac->nb_streams) {
3736 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3740 for (i = 0; i < ac->nb_programs; i++) {
3741 if (ac->programs[i]->id != progid)
3743 program = ac->programs[i];
3744 for (j = 0; j < program->nb_stream_indexes; j++)
3745 if (program->stream_index[j] == idx)
3748 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3751 program->stream_index = tmp;
3752 program->stream_index[program->nb_stream_indexes++] = idx;
3757 static void print_fps(double d, const char *postfix)
3759 uint64_t v = lrintf(d * 100);
3761 av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3762 else if (v % (100 * 1000))
3763 av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3765 av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3768 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3770 if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3771 AVDictionaryEntry *tag = NULL;
3773 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3774 while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3775 if (strcmp("language", tag->key)) {
3776 const char *p = tag->value;
3777 av_log(ctx, AV_LOG_INFO,
3778 "%s %-16s: ", indent, tag->key);
3781 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3782 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3783 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3785 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3786 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3789 av_log(ctx, AV_LOG_INFO, "\n");
3794 /* "user interface" functions */
3795 static void dump_stream_format(AVFormatContext *ic, int i,
3796 int index, int is_output)
3799 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3800 AVStream *st = ic->streams[i];
3801 int g = av_gcd(st->time_base.num, st->time_base.den);
3802 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3803 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3804 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3805 /* the pid is an important information, so we display it */
3806 /* XXX: add a generic system */
3807 if (flags & AVFMT_SHOW_IDS)
3808 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3810 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3811 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3812 st->time_base.num / g, st->time_base.den / g);
3813 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3814 if (st->sample_aspect_ratio.num && // default
3815 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3816 AVRational display_aspect_ratio;
3817 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3818 st->codec->width * st->sample_aspect_ratio.num,
3819 st->codec->height * st->sample_aspect_ratio.den,
3821 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3822 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3823 display_aspect_ratio.num, display_aspect_ratio.den);
3825 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3826 if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3827 print_fps(av_q2d(st->avg_frame_rate), "fps");
3828 #if FF_API_R_FRAME_RATE
3829 if (st->r_frame_rate.den && st->r_frame_rate.num)
3830 print_fps(av_q2d(st->r_frame_rate), "tbr");
3832 if (st->time_base.den && st->time_base.num)
3833 print_fps(1 / av_q2d(st->time_base), "tbn");
3834 if (st->codec->time_base.den && st->codec->time_base.num)
3835 print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3837 if (st->disposition & AV_DISPOSITION_DEFAULT)
3838 av_log(NULL, AV_LOG_INFO, " (default)");
3839 if (st->disposition & AV_DISPOSITION_DUB)
3840 av_log(NULL, AV_LOG_INFO, " (dub)");
3841 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3842 av_log(NULL, AV_LOG_INFO, " (original)");
3843 if (st->disposition & AV_DISPOSITION_COMMENT)
3844 av_log(NULL, AV_LOG_INFO, " (comment)");
3845 if (st->disposition & AV_DISPOSITION_LYRICS)
3846 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3847 if (st->disposition & AV_DISPOSITION_KARAOKE)
3848 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3849 if (st->disposition & AV_DISPOSITION_FORCED)
3850 av_log(NULL, AV_LOG_INFO, " (forced)");
3851 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3852 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3853 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3854 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3855 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3856 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3857 av_log(NULL, AV_LOG_INFO, "\n");
3858 dump_metadata(NULL, st->metadata, " ");
3861 void av_dump_format(AVFormatContext *ic, int index,
3862 const char *url, int is_output)
3865 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3866 if (ic->nb_streams && !printed)
3869 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3870 is_output ? "Output" : "Input",
3872 is_output ? ic->oformat->name : ic->iformat->name,
3873 is_output ? "to" : "from", url);
3874 dump_metadata(NULL, ic->metadata, " ");
3876 av_log(NULL, AV_LOG_INFO, " Duration: ");
3877 if (ic->duration != AV_NOPTS_VALUE) {
3878 int hours, mins, secs, us;
3879 int64_t duration = ic->duration + 5000;
3880 secs = duration / AV_TIME_BASE;
3881 us = duration % AV_TIME_BASE;
3886 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3887 (100 * us) / AV_TIME_BASE);
3889 av_log(NULL, AV_LOG_INFO, "N/A");
3891 if (ic->start_time != AV_NOPTS_VALUE) {
3893 av_log(NULL, AV_LOG_INFO, ", start: ");
3894 secs = ic->start_time / AV_TIME_BASE;
3895 us = abs(ic->start_time % AV_TIME_BASE);
3896 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3897 secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3899 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3901 av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3903 av_log(NULL, AV_LOG_INFO, "N/A");
3904 av_log(NULL, AV_LOG_INFO, "\n");
3906 for (i = 0; i < ic->nb_chapters; i++) {
3907 AVChapter *ch = ic->chapters[i];
3908 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3909 av_log(NULL, AV_LOG_INFO,
3910 "start %f, ", ch->start * av_q2d(ch->time_base));
3911 av_log(NULL, AV_LOG_INFO,
3912 "end %f\n", ch->end * av_q2d(ch->time_base));
3914 dump_metadata(NULL, ch->metadata, " ");
3916 if (ic->nb_programs) {
3917 int j, k, total = 0;
3918 for (j = 0; j < ic->nb_programs; j++) {
3919 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3921 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3922 name ? name->value : "");
3923 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3924 for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3925 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3927 printed[ic->programs[j]->stream_index[k]] = 1;
3929 total += ic->programs[j]->nb_stream_indexes;
3931 if (total < ic->nb_streams)
3932 av_log(NULL, AV_LOG_INFO, " No Program\n");
3934 for (i = 0; i < ic->nb_streams; i++)
3936 dump_stream_format(ic, i, index, is_output);
3941 uint64_t ff_ntp_time(void)
3943 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3946 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3949 char *q, buf1[20], c;
3950 int nd, len, percentd_found;
3962 while (av_isdigit(*p))
3963 nd = nd * 10 + *p++ - '0';
3965 } while (av_isdigit(c));
3974 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3976 if ((q - buf + len) > buf_size - 1)
3978 memcpy(q, buf1, len);
3986 if ((q - buf) < buf_size - 1)
3990 if (!percentd_found)
3999 #define HEXDUMP_PRINT(...) \
4002 av_log(avcl, level, __VA_ARGS__); \
4004 fprintf(f, __VA_ARGS__); \
4007 static void hex_dump_internal(void *avcl, FILE *f, int level,
4008 const uint8_t *buf, int size)
4012 for (i = 0; i < size; i += 16) {
4016 HEXDUMP_PRINT("%08x ", i);
4017 for (j = 0; j < 16; j++) {
4019 HEXDUMP_PRINT(" %02x", buf[i + j]);
4024 for (j = 0; j < len; j++) {
4026 if (c < ' ' || c > '~')
4028 HEXDUMP_PRINT("%c", c);
4030 HEXDUMP_PRINT("\n");
4034 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
4036 hex_dump_internal(NULL, f, 0, buf, size);
4039 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
4041 hex_dump_internal(avcl, NULL, level, buf, size);
4044 static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt,
4045 int dump_payload, AVRational time_base)
4047 HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
4048 HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
4049 HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
4050 /* DTS is _always_ valid after av_read_frame() */
4051 HEXDUMP_PRINT(" dts=");
4052 if (pkt->dts == AV_NOPTS_VALUE)
4053 HEXDUMP_PRINT("N/A");
4055 HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
4056 /* PTS may not be known if B-frames are present. */
4057 HEXDUMP_PRINT(" pts=");
4058 if (pkt->pts == AV_NOPTS_VALUE)
4059 HEXDUMP_PRINT("N/A");
4061 HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
4062 HEXDUMP_PRINT("\n");
4063 HEXDUMP_PRINT(" size=%d\n", pkt->size);
4065 av_hex_dump(f, pkt->data, pkt->size);
4068 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
4070 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
4073 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
4076 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
4079 void av_url_split(char *proto, int proto_size,
4080 char *authorization, int authorization_size,
4081 char *hostname, int hostname_size,
4082 int *port_ptr, char *path, int path_size, const char *url)
4084 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4090 if (authorization_size > 0)
4091 authorization[0] = 0;
4092 if (hostname_size > 0)
4097 /* parse protocol */
4098 if ((p = strchr(url, ':'))) {
4099 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4106 /* no protocol means plain filename */
4107 av_strlcpy(path, url, path_size);
4111 /* separate path from hostname */
4112 ls = strchr(p, '/');
4113 ls2 = strchr(p, '?');
4117 ls = FFMIN(ls, ls2);
4119 av_strlcpy(path, ls, path_size);
4121 ls = &p[strlen(p)]; // XXX
4123 /* the rest is hostname, use that to parse auth/port */
4125 /* authorization (user[:pass]@hostname) */
4127 while ((at = strchr(p, '@')) && at < ls) {
4128 av_strlcpy(authorization, at2,
4129 FFMIN(authorization_size, at + 1 - at2));
4130 p = at + 1; /* skip '@' */
4133 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4135 av_strlcpy(hostname, p + 1,
4136 FFMIN(hostname_size, brk - p));
4137 if (brk[1] == ':' && port_ptr)
4138 *port_ptr = atoi(brk + 2);
4139 } else if ((col = strchr(p, ':')) && col < ls) {
4140 av_strlcpy(hostname, p,
4141 FFMIN(col + 1 - p, hostname_size));
4143 *port_ptr = atoi(col + 1);
4145 av_strlcpy(hostname, p,
4146 FFMIN(ls + 1 - p, hostname_size));
4150 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4153 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4156 'C', 'D', 'E', 'F' };
4157 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4160 'c', 'd', 'e', 'f' };
4161 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4163 for (i = 0; i < s; i++) {
4164 buff[i * 2] = hex_table[src[i] >> 4];
4165 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4171 int ff_hex_to_data(uint8_t *data, const char *p)
4178 p += strspn(p, SPACE_CHARS);
4181 c = av_toupper((unsigned char) *p++);
4182 if (c >= '0' && c <= '9')
4184 else if (c >= 'A' && c <= 'F')
4199 #if FF_API_SET_PTS_INFO
4200 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4201 unsigned int pts_num, unsigned int pts_den)
4203 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4207 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4208 unsigned int pts_num, unsigned int pts_den)
4211 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4212 if (new_tb.num != pts_num)
4213 av_log(NULL, AV_LOG_DEBUG,
4214 "st:%d removing common factor %d from timebase\n",
4215 s->index, pts_num / new_tb.num);
4217 av_log(NULL, AV_LOG_WARNING,
4218 "st:%d has too large timebase, reducing\n", s->index);
4220 if (new_tb.num <= 0 || new_tb.den <= 0) {
4221 av_log(NULL, AV_LOG_ERROR,
4222 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4223 new_tb.num, new_tb.den,
4227 s->time_base = new_tb;
4228 av_codec_set_pkt_timebase(s->codec, new_tb);
4229 s->pts_wrap_bits = pts_wrap_bits;
4232 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4235 const char *ptr = str;
4237 /* Parse key=value pairs. */
4240 char *dest = NULL, *dest_end;
4241 int key_len, dest_len = 0;
4243 /* Skip whitespace and potential commas. */
4244 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4251 if (!(ptr = strchr(key, '=')))
4254 key_len = ptr - key;
4256 callback_get_buf(context, key, key_len, &dest, &dest_len);
4257 dest_end = dest + dest_len - 1;
4261 while (*ptr && *ptr != '\"') {
4265 if (dest && dest < dest_end)
4269 if (dest && dest < dest_end)
4277 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4278 if (dest && dest < dest_end)
4286 int ff_find_stream_index(AVFormatContext *s, int id)
4289 for (i = 0; i < s->nb_streams; i++)
4290 if (s->streams[i]->id == id)
4295 int64_t ff_iso8601_to_unix_time(const char *datestr)
4297 struct tm time1 = { 0 }, time2 = { 0 };
4299 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4300 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4302 return av_timegm(&time2);
4304 return av_timegm(&time1);
4307 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4311 if (ofmt->query_codec)
4312 return ofmt->query_codec(codec_id, std_compliance);
4313 else if (ofmt->codec_tag)
4314 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4315 else if (codec_id == ofmt->video_codec ||
4316 codec_id == ofmt->audio_codec ||
4317 codec_id == ofmt->subtitle_codec)
4320 return AVERROR_PATCHWELCOME;
4323 int avformat_network_init(void)
4327 ff_network_inited_globally = 1;
4328 if ((ret = ff_network_init()) < 0)
4335 int avformat_network_deinit(void)
4344 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4345 uint64_t channel_layout, int32_t sample_rate,
4346 int32_t width, int32_t height)
4352 return AVERROR(EINVAL);
4355 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4357 if (channel_layout) {
4359 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4363 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4365 if (width || height) {
4367 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4369 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4371 return AVERROR(ENOMEM);
4372 bytestream_put_le32(&data, flags);
4374 bytestream_put_le32(&data, channels);
4376 bytestream_put_le64(&data, channel_layout);
4378 bytestream_put_le32(&data, sample_rate);
4379 if (width || height) {
4380 bytestream_put_le32(&data, width);
4381 bytestream_put_le32(&data, height);
4386 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4388 AVRational undef = {0, 1};
4389 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4390 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4391 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4393 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4394 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4395 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4396 stream_sample_aspect_ratio = undef;
4398 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4399 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4400 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4401 frame_sample_aspect_ratio = undef;
4403 if (stream_sample_aspect_ratio.num)
4404 return stream_sample_aspect_ratio;
4406 return frame_sample_aspect_ratio;
4409 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4411 AVRational fr = st->r_frame_rate;
4412 AVRational codec_fr = av_inv_q(st->codec->time_base);
4413 AVRational avg_fr = st->avg_frame_rate;
4415 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4416 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4421 if (st->codec->ticks_per_frame > 1) {
4422 codec_fr.den *= st->codec->ticks_per_frame;
4423 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4424 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4431 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4434 if (*spec <= '9' && *spec >= '0') /* opt:index */
4435 return strtol(spec, NULL, 0) == st->index;
4436 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4437 *spec == 't') { /* opt:[vasdt] */
4438 enum AVMediaType type;
4441 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4442 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4443 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4444 case 'd': type = AVMEDIA_TYPE_DATA; break;
4445 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4446 default: av_assert0(0);
4448 if (type != st->codec->codec_type)
4450 if (*spec++ == ':') { /* possibly followed by :index */
4451 int i, index = strtol(spec, NULL, 0);
4452 for (i = 0; i < s->nb_streams; i++)
4453 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4454 return i == st->index;
4458 } else if (*spec == 'p' && *(spec + 1) == ':') {
4462 prog_id = strtol(spec, &endptr, 0);
4463 for (i = 0; i < s->nb_programs; i++) {
4464 if (s->programs[i]->id != prog_id)
4467 if (*endptr++ == ':') {
4468 int stream_idx = strtol(endptr, NULL, 0);
4469 return stream_idx >= 0 &&
4470 stream_idx < s->programs[i]->nb_stream_indexes &&
4471 st->index == s->programs[i]->stream_index[stream_idx];
4474 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4475 if (st->index == s->programs[i]->stream_index[j])
4479 } else if (*spec == '#' ||
4480 (*spec == 'i' && *(spec + 1) == ':')) {
4483 spec += 1 + (*spec == 'i');
4484 stream_id = strtol(spec, &endptr, 0);
4486 return stream_id == st->id;
4487 } else if (!*spec) /* empty specifier, matches everything */
4490 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4491 return AVERROR(EINVAL);
4494 int ff_generate_avci_extradata(AVStream *st)
4496 static const uint8_t avci100_1080p_extradata[] = {
4498 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4499 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4500 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4501 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4502 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4503 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4504 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4505 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4506 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4508 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4511 static const uint8_t avci100_1080i_extradata[] = {
4513 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4514 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4515 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4516 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4517 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4518 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4519 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4520 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4521 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4522 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4523 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4525 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4528 static const uint8_t avci50_1080i_extradata[] = {
4530 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4531 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4532 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4533 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4534 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4535 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4536 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4537 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4538 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4539 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4540 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4542 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4545 static const uint8_t avci100_720p_extradata[] = {
4547 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4548 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4549 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4550 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4551 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4552 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4553 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4554 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4555 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4556 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4558 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4562 const uint8_t *data = NULL;
4565 if (st->codec->width == 1920) {
4566 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4567 data = avci100_1080p_extradata;
4568 size = sizeof(avci100_1080p_extradata);
4570 data = avci100_1080i_extradata;
4571 size = sizeof(avci100_1080i_extradata);
4573 } else if (st->codec->width == 1440) {
4574 data = avci50_1080i_extradata;
4575 size = sizeof(avci50_1080i_extradata);
4576 } else if (st->codec->width == 1280) {
4577 data = avci100_720p_extradata;
4578 size = sizeof(avci100_720p_extradata);
4584 av_freep(&st->codec->extradata);
4585 if (ff_alloc_extradata(st->codec, size))
4586 return AVERROR(ENOMEM);
4587 memcpy(st->codec->extradata, data, size);