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 is not set in estimate_timings_from_pts\n");
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) {
3512 av_assert0(s->nb_streams>0);
3513 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3516 av_parser_close(st->parser);
3518 if (st->attached_pic.data)
3519 av_free_packet(&st->attached_pic);
3520 av_dict_free(&st->metadata);
3521 av_freep(&st->probe_data.buf);
3522 av_freep(&st->index_entries);
3523 av_freep(&st->codec->extradata);
3524 av_freep(&st->codec->subtitle_header);
3525 av_freep(&st->codec);
3526 av_freep(&st->priv_data);
3528 av_freep(&st->info->duration_error);
3529 av_freep(&st->info);
3530 av_freep(&s->streams[ --s->nb_streams ]);
3533 void avformat_free_context(AVFormatContext *s)
3541 if (s->iformat && s->iformat->priv_class && s->priv_data)
3542 av_opt_free(s->priv_data);
3544 for (i = s->nb_streams - 1; i >= 0; i--) {
3545 ff_free_stream(s, s->streams[i]);
3547 for (i = s->nb_programs - 1; i >= 0; i--) {
3548 av_dict_free(&s->programs[i]->metadata);
3549 av_freep(&s->programs[i]->stream_index);
3550 av_freep(&s->programs[i]);
3552 av_freep(&s->programs);
3553 av_freep(&s->priv_data);
3554 while (s->nb_chapters--) {
3555 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3556 av_freep(&s->chapters[s->nb_chapters]);
3558 av_freep(&s->chapters);
3559 av_dict_free(&s->metadata);
3560 av_freep(&s->streams);
3561 av_freep(&s->internal);
3565 #if FF_API_CLOSE_INPUT_FILE
3566 void av_close_input_file(AVFormatContext *s)
3568 avformat_close_input(&s);
3572 void avformat_close_input(AVFormatContext **ps)
3583 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3584 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3587 flush_packet_queue(s);
3590 if (s->iformat->read_close)
3591 s->iformat->read_close(s);
3593 avformat_free_context(s);
3600 #if FF_API_NEW_STREAM
3601 AVStream *av_new_stream(AVFormatContext *s, int id)
3603 AVStream *st = avformat_new_stream(s, NULL);
3610 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3616 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3618 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3621 s->streams = streams;
3623 st = av_mallocz(sizeof(AVStream));
3626 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3630 st->info->last_dts = AV_NOPTS_VALUE;
3632 st->codec = avcodec_alloc_context3(c);
3634 /* no default bitrate if decoding */
3635 st->codec->bit_rate = 0;
3636 st->index = s->nb_streams;
3637 st->start_time = AV_NOPTS_VALUE;
3638 st->duration = AV_NOPTS_VALUE;
3639 /* we set the current DTS to 0 so that formats without any timestamps
3640 * but durations get some timestamps, formats with some unknown
3641 * timestamps have their first few packets buffered and the
3642 * timestamps corrected before they are returned to the user */
3643 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3644 st->first_dts = AV_NOPTS_VALUE;
3645 st->probe_packets = MAX_PROBE_PACKETS;
3646 st->pts_wrap_reference = AV_NOPTS_VALUE;
3647 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3649 /* default pts setting is MPEG-like */
3650 avpriv_set_pts_info(st, 33, 1, 90000);
3651 st->last_IP_pts = AV_NOPTS_VALUE;
3652 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3653 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3654 st->pts_buffer[i] = AV_NOPTS_VALUE;
3656 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3658 #if FF_API_R_FRAME_RATE
3659 st->info->last_dts = AV_NOPTS_VALUE;
3661 st->info->fps_first_dts = AV_NOPTS_VALUE;
3662 st->info->fps_last_dts = AV_NOPTS_VALUE;
3664 s->streams[s->nb_streams++] = st;
3668 AVProgram *av_new_program(AVFormatContext *ac, int id)
3670 AVProgram *program = NULL;
3673 av_dlog(ac, "new_program: id=0x%04x\n", id);
3675 for (i = 0; i < ac->nb_programs; i++)
3676 if (ac->programs[i]->id == id)
3677 program = ac->programs[i];
3680 program = av_mallocz(sizeof(AVProgram));
3683 dynarray_add(&ac->programs, &ac->nb_programs, program);
3684 program->discard = AVDISCARD_NONE;
3687 program->pts_wrap_reference = AV_NOPTS_VALUE;
3688 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3690 program->start_time =
3691 program->end_time = AV_NOPTS_VALUE;
3696 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3697 int64_t start, int64_t end, const char *title)
3699 AVChapter *chapter = NULL;
3702 for (i = 0; i < s->nb_chapters; i++)
3703 if (s->chapters[i]->id == id)
3704 chapter = s->chapters[i];
3707 chapter = av_mallocz(sizeof(AVChapter));
3710 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3712 av_dict_set(&chapter->metadata, "title", title, 0);
3714 chapter->time_base = time_base;
3715 chapter->start = start;
3721 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3724 AVProgram *program = NULL;
3727 if (idx >= ac->nb_streams) {
3728 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3732 for (i = 0; i < ac->nb_programs; i++) {
3733 if (ac->programs[i]->id != progid)
3735 program = ac->programs[i];
3736 for (j = 0; j < program->nb_stream_indexes; j++)
3737 if (program->stream_index[j] == idx)
3740 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3743 program->stream_index = tmp;
3744 program->stream_index[program->nb_stream_indexes++] = idx;
3749 static void print_fps(double d, const char *postfix)
3751 uint64_t v = lrintf(d * 100);
3753 av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3754 else if (v % (100 * 1000))
3755 av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3757 av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3760 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3762 if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3763 AVDictionaryEntry *tag = NULL;
3765 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3766 while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3767 if (strcmp("language", tag->key)) {
3768 const char *p = tag->value;
3769 av_log(ctx, AV_LOG_INFO,
3770 "%s %-16s: ", indent, tag->key);
3773 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3774 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3775 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3777 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3778 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3781 av_log(ctx, AV_LOG_INFO, "\n");
3786 /* "user interface" functions */
3787 static void dump_stream_format(AVFormatContext *ic, int i,
3788 int index, int is_output)
3791 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3792 AVStream *st = ic->streams[i];
3793 int g = av_gcd(st->time_base.num, st->time_base.den);
3794 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3795 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3796 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3797 /* the pid is an important information, so we display it */
3798 /* XXX: add a generic system */
3799 if (flags & AVFMT_SHOW_IDS)
3800 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3802 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3803 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3804 st->time_base.num / g, st->time_base.den / g);
3805 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3806 if (st->sample_aspect_ratio.num && // default
3807 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3808 AVRational display_aspect_ratio;
3809 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3810 st->codec->width * st->sample_aspect_ratio.num,
3811 st->codec->height * st->sample_aspect_ratio.den,
3813 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3814 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3815 display_aspect_ratio.num, display_aspect_ratio.den);
3817 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3818 if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3819 print_fps(av_q2d(st->avg_frame_rate), "fps");
3820 #if FF_API_R_FRAME_RATE
3821 if (st->r_frame_rate.den && st->r_frame_rate.num)
3822 print_fps(av_q2d(st->r_frame_rate), "tbr");
3824 if (st->time_base.den && st->time_base.num)
3825 print_fps(1 / av_q2d(st->time_base), "tbn");
3826 if (st->codec->time_base.den && st->codec->time_base.num)
3827 print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3829 if (st->disposition & AV_DISPOSITION_DEFAULT)
3830 av_log(NULL, AV_LOG_INFO, " (default)");
3831 if (st->disposition & AV_DISPOSITION_DUB)
3832 av_log(NULL, AV_LOG_INFO, " (dub)");
3833 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3834 av_log(NULL, AV_LOG_INFO, " (original)");
3835 if (st->disposition & AV_DISPOSITION_COMMENT)
3836 av_log(NULL, AV_LOG_INFO, " (comment)");
3837 if (st->disposition & AV_DISPOSITION_LYRICS)
3838 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3839 if (st->disposition & AV_DISPOSITION_KARAOKE)
3840 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3841 if (st->disposition & AV_DISPOSITION_FORCED)
3842 av_log(NULL, AV_LOG_INFO, " (forced)");
3843 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3844 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3845 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3846 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3847 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3848 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3849 av_log(NULL, AV_LOG_INFO, "\n");
3850 dump_metadata(NULL, st->metadata, " ");
3853 void av_dump_format(AVFormatContext *ic, int index,
3854 const char *url, int is_output)
3857 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3858 if (ic->nb_streams && !printed)
3861 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3862 is_output ? "Output" : "Input",
3864 is_output ? ic->oformat->name : ic->iformat->name,
3865 is_output ? "to" : "from", url);
3866 dump_metadata(NULL, ic->metadata, " ");
3868 av_log(NULL, AV_LOG_INFO, " Duration: ");
3869 if (ic->duration != AV_NOPTS_VALUE) {
3870 int hours, mins, secs, us;
3871 int64_t duration = ic->duration + 5000;
3872 secs = duration / AV_TIME_BASE;
3873 us = duration % AV_TIME_BASE;
3878 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3879 (100 * us) / AV_TIME_BASE);
3881 av_log(NULL, AV_LOG_INFO, "N/A");
3883 if (ic->start_time != AV_NOPTS_VALUE) {
3885 av_log(NULL, AV_LOG_INFO, ", start: ");
3886 secs = ic->start_time / AV_TIME_BASE;
3887 us = abs(ic->start_time % AV_TIME_BASE);
3888 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3889 secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3891 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3893 av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3895 av_log(NULL, AV_LOG_INFO, "N/A");
3896 av_log(NULL, AV_LOG_INFO, "\n");
3898 for (i = 0; i < ic->nb_chapters; i++) {
3899 AVChapter *ch = ic->chapters[i];
3900 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3901 av_log(NULL, AV_LOG_INFO,
3902 "start %f, ", ch->start * av_q2d(ch->time_base));
3903 av_log(NULL, AV_LOG_INFO,
3904 "end %f\n", ch->end * av_q2d(ch->time_base));
3906 dump_metadata(NULL, ch->metadata, " ");
3908 if (ic->nb_programs) {
3909 int j, k, total = 0;
3910 for (j = 0; j < ic->nb_programs; j++) {
3911 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3913 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3914 name ? name->value : "");
3915 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3916 for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3917 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3919 printed[ic->programs[j]->stream_index[k]] = 1;
3921 total += ic->programs[j]->nb_stream_indexes;
3923 if (total < ic->nb_streams)
3924 av_log(NULL, AV_LOG_INFO, " No Program\n");
3926 for (i = 0; i < ic->nb_streams; i++)
3928 dump_stream_format(ic, i, index, is_output);
3933 uint64_t ff_ntp_time(void)
3935 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3938 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3941 char *q, buf1[20], c;
3942 int nd, len, percentd_found;
3954 while (av_isdigit(*p))
3955 nd = nd * 10 + *p++ - '0';
3957 } while (av_isdigit(c));
3966 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3968 if ((q - buf + len) > buf_size - 1)
3970 memcpy(q, buf1, len);
3978 if ((q - buf) < buf_size - 1)
3982 if (!percentd_found)
3991 #define HEXDUMP_PRINT(...) \
3994 av_log(avcl, level, __VA_ARGS__); \
3996 fprintf(f, __VA_ARGS__); \
3999 static void hex_dump_internal(void *avcl, FILE *f, int level,
4000 const uint8_t *buf, int size)
4004 for (i = 0; i < size; i += 16) {
4008 HEXDUMP_PRINT("%08x ", i);
4009 for (j = 0; j < 16; j++) {
4011 HEXDUMP_PRINT(" %02x", buf[i + j]);
4016 for (j = 0; j < len; j++) {
4018 if (c < ' ' || c > '~')
4020 HEXDUMP_PRINT("%c", c);
4022 HEXDUMP_PRINT("\n");
4026 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
4028 hex_dump_internal(NULL, f, 0, buf, size);
4031 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
4033 hex_dump_internal(avcl, NULL, level, buf, size);
4036 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
4037 int dump_payload, AVRational time_base)
4039 HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
4040 HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
4041 HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
4042 /* DTS is _always_ valid after av_read_frame() */
4043 HEXDUMP_PRINT(" dts=");
4044 if (pkt->dts == AV_NOPTS_VALUE)
4045 HEXDUMP_PRINT("N/A");
4047 HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
4048 /* PTS may not be known if B-frames are present. */
4049 HEXDUMP_PRINT(" pts=");
4050 if (pkt->pts == AV_NOPTS_VALUE)
4051 HEXDUMP_PRINT("N/A");
4053 HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
4054 HEXDUMP_PRINT("\n");
4055 HEXDUMP_PRINT(" size=%d\n", pkt->size);
4057 av_hex_dump(f, pkt->data, pkt->size);
4060 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
4062 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
4065 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
4068 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
4071 void av_url_split(char *proto, int proto_size,
4072 char *authorization, int authorization_size,
4073 char *hostname, int hostname_size,
4074 int *port_ptr, char *path, int path_size, const char *url)
4076 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4082 if (authorization_size > 0)
4083 authorization[0] = 0;
4084 if (hostname_size > 0)
4089 /* parse protocol */
4090 if ((p = strchr(url, ':'))) {
4091 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4098 /* no protocol means plain filename */
4099 av_strlcpy(path, url, path_size);
4103 /* separate path from hostname */
4104 ls = strchr(p, '/');
4105 ls2 = strchr(p, '?');
4109 ls = FFMIN(ls, ls2);
4111 av_strlcpy(path, ls, path_size);
4113 ls = &p[strlen(p)]; // XXX
4115 /* the rest is hostname, use that to parse auth/port */
4117 /* authorization (user[:pass]@hostname) */
4119 while ((at = strchr(p, '@')) && at < ls) {
4120 av_strlcpy(authorization, at2,
4121 FFMIN(authorization_size, at + 1 - at2));
4122 p = at + 1; /* skip '@' */
4125 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4127 av_strlcpy(hostname, p + 1,
4128 FFMIN(hostname_size, brk - p));
4129 if (brk[1] == ':' && port_ptr)
4130 *port_ptr = atoi(brk + 2);
4131 } else if ((col = strchr(p, ':')) && col < ls) {
4132 av_strlcpy(hostname, p,
4133 FFMIN(col + 1 - p, hostname_size));
4135 *port_ptr = atoi(col + 1);
4137 av_strlcpy(hostname, p,
4138 FFMIN(ls + 1 - p, hostname_size));
4142 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4145 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4148 'C', 'D', 'E', 'F' };
4149 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4152 'c', 'd', 'e', 'f' };
4153 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4155 for (i = 0; i < s; i++) {
4156 buff[i * 2] = hex_table[src[i] >> 4];
4157 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4163 int ff_hex_to_data(uint8_t *data, const char *p)
4170 p += strspn(p, SPACE_CHARS);
4173 c = av_toupper((unsigned char) *p++);
4174 if (c >= '0' && c <= '9')
4176 else if (c >= 'A' && c <= 'F')
4191 #if FF_API_SET_PTS_INFO
4192 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4193 unsigned int pts_num, unsigned int pts_den)
4195 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4199 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4200 unsigned int pts_num, unsigned int pts_den)
4203 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4204 if (new_tb.num != pts_num)
4205 av_log(NULL, AV_LOG_DEBUG,
4206 "st:%d removing common factor %d from timebase\n",
4207 s->index, pts_num / new_tb.num);
4209 av_log(NULL, AV_LOG_WARNING,
4210 "st:%d has too large timebase, reducing\n", s->index);
4212 if (new_tb.num <= 0 || new_tb.den <= 0) {
4213 av_log(NULL, AV_LOG_ERROR,
4214 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4215 new_tb.num, new_tb.den,
4219 s->time_base = new_tb;
4220 av_codec_set_pkt_timebase(s->codec, new_tb);
4221 s->pts_wrap_bits = pts_wrap_bits;
4224 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4227 const char *ptr = str;
4229 /* Parse key=value pairs. */
4232 char *dest = NULL, *dest_end;
4233 int key_len, dest_len = 0;
4235 /* Skip whitespace and potential commas. */
4236 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4243 if (!(ptr = strchr(key, '=')))
4246 key_len = ptr - key;
4248 callback_get_buf(context, key, key_len, &dest, &dest_len);
4249 dest_end = dest + dest_len - 1;
4253 while (*ptr && *ptr != '\"') {
4257 if (dest && dest < dest_end)
4261 if (dest && dest < dest_end)
4269 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4270 if (dest && dest < dest_end)
4278 int ff_find_stream_index(AVFormatContext *s, int id)
4281 for (i = 0; i < s->nb_streams; i++)
4282 if (s->streams[i]->id == id)
4287 int64_t ff_iso8601_to_unix_time(const char *datestr)
4289 struct tm time1 = { 0 }, time2 = { 0 };
4291 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4292 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4294 return av_timegm(&time2);
4296 return av_timegm(&time1);
4299 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4303 if (ofmt->query_codec)
4304 return ofmt->query_codec(codec_id, std_compliance);
4305 else if (ofmt->codec_tag)
4306 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4307 else if (codec_id == ofmt->video_codec ||
4308 codec_id == ofmt->audio_codec ||
4309 codec_id == ofmt->subtitle_codec)
4312 return AVERROR_PATCHWELCOME;
4315 int avformat_network_init(void)
4319 ff_network_inited_globally = 1;
4320 if ((ret = ff_network_init()) < 0)
4327 int avformat_network_deinit(void)
4336 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4337 uint64_t channel_layout, int32_t sample_rate,
4338 int32_t width, int32_t height)
4344 return AVERROR(EINVAL);
4347 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4349 if (channel_layout) {
4351 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4355 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4357 if (width || height) {
4359 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4361 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4363 return AVERROR(ENOMEM);
4364 bytestream_put_le32(&data, flags);
4366 bytestream_put_le32(&data, channels);
4368 bytestream_put_le64(&data, channel_layout);
4370 bytestream_put_le32(&data, sample_rate);
4371 if (width || height) {
4372 bytestream_put_le32(&data, width);
4373 bytestream_put_le32(&data, height);
4378 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4380 AVRational undef = {0, 1};
4381 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4382 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4383 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4385 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4386 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4387 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4388 stream_sample_aspect_ratio = undef;
4390 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4391 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4392 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4393 frame_sample_aspect_ratio = undef;
4395 if (stream_sample_aspect_ratio.num)
4396 return stream_sample_aspect_ratio;
4398 return frame_sample_aspect_ratio;
4401 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4403 AVRational fr = st->r_frame_rate;
4404 AVRational codec_fr = av_inv_q(st->codec->time_base);
4405 AVRational avg_fr = st->avg_frame_rate;
4407 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4408 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4413 if (st->codec->ticks_per_frame > 1) {
4414 codec_fr.den *= st->codec->ticks_per_frame;
4415 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4416 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4423 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4426 if (*spec <= '9' && *spec >= '0') /* opt:index */
4427 return strtol(spec, NULL, 0) == st->index;
4428 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4429 *spec == 't') { /* opt:[vasdt] */
4430 enum AVMediaType type;
4433 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4434 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4435 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4436 case 'd': type = AVMEDIA_TYPE_DATA; break;
4437 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4438 default: av_assert0(0);
4440 if (type != st->codec->codec_type)
4442 if (*spec++ == ':') { /* possibly followed by :index */
4443 int i, index = strtol(spec, NULL, 0);
4444 for (i = 0; i < s->nb_streams; i++)
4445 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4446 return i == st->index;
4450 } else if (*spec == 'p' && *(spec + 1) == ':') {
4454 prog_id = strtol(spec, &endptr, 0);
4455 for (i = 0; i < s->nb_programs; i++) {
4456 if (s->programs[i]->id != prog_id)
4459 if (*endptr++ == ':') {
4460 int stream_idx = strtol(endptr, NULL, 0);
4461 return stream_idx >= 0 &&
4462 stream_idx < s->programs[i]->nb_stream_indexes &&
4463 st->index == s->programs[i]->stream_index[stream_idx];
4466 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4467 if (st->index == s->programs[i]->stream_index[j])
4471 } else if (*spec == '#' ||
4472 (*spec == 'i' && *(spec + 1) == ':')) {
4475 spec += 1 + (*spec == 'i');
4476 stream_id = strtol(spec, &endptr, 0);
4478 return stream_id == st->id;
4479 } else if (!*spec) /* empty specifier, matches everything */
4482 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4483 return AVERROR(EINVAL);
4486 int ff_generate_avci_extradata(AVStream *st)
4488 static const uint8_t avci100_1080p_extradata[] = {
4490 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4491 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4492 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4493 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4494 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4495 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4496 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4497 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4498 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4500 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4503 static const uint8_t avci100_1080i_extradata[] = {
4505 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4506 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4507 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4508 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4509 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4510 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4511 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4512 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4513 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4514 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4515 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4517 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4520 static const uint8_t avci50_1080i_extradata[] = {
4522 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4523 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4524 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4525 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4526 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4527 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4528 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4529 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4530 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4531 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4532 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4534 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4537 static const uint8_t avci100_720p_extradata[] = {
4539 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4540 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4541 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4542 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4543 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4544 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4545 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4546 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4547 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4548 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4550 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4554 const uint8_t *data = NULL;
4557 if (st->codec->width == 1920) {
4558 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4559 data = avci100_1080p_extradata;
4560 size = sizeof(avci100_1080p_extradata);
4562 data = avci100_1080i_extradata;
4563 size = sizeof(avci100_1080i_extradata);
4565 } else if (st->codec->width == 1440) {
4566 data = avci50_1080i_extradata;
4567 size = sizeof(avci50_1080i_extradata);
4568 } else if (st->codec->width == 1280) {
4569 data = avci100_720p_extradata;
4570 size = sizeof(avci100_720p_extradata);
4576 av_freep(&st->codec->extradata);
4577 if (ff_alloc_extradata(st->codec, size))
4578 return AVERROR(ENOMEM);
4579 memcpy(st->codec->extradata, data, size);