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 void av_format_inject_global_side_data(AVFormatContext *s)
116 s->internal->inject_global_side_data = 1;
117 for (i = 0; i < s->nb_streams; i++) {
118 AVStream *st = s->streams[i];
119 st->inject_global_side_data = 1;
123 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
125 if (st->codec->codec)
126 return st->codec->codec;
128 switch (st->codec->codec_type) {
129 case AVMEDIA_TYPE_VIDEO:
130 if (s->video_codec) return s->video_codec;
132 case AVMEDIA_TYPE_AUDIO:
133 if (s->audio_codec) return s->audio_codec;
135 case AVMEDIA_TYPE_SUBTITLE:
136 if (s->subtitle_codec) return s->subtitle_codec;
140 return avcodec_find_decoder(codec_id);
143 int av_format_get_probe_score(const AVFormatContext *s)
145 return s->probe_score;
148 /* an arbitrarily chosen "sane" max packet size -- 50M */
149 #define SANE_CHUNK_SIZE (50000000)
151 int ffio_limit(AVIOContext *s, int size)
153 if (s->maxsize>= 0) {
154 int64_t remaining= s->maxsize - avio_tell(s);
155 if (remaining < size) {
156 int64_t newsize = avio_size(s);
157 if (!s->maxsize || s->maxsize<newsize)
158 s->maxsize = newsize - !newsize;
159 remaining= s->maxsize - avio_tell(s);
160 remaining= FFMAX(remaining, 0);
163 if (s->maxsize>= 0 && remaining+1 < size) {
164 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
171 /* Read the data in sane-sized chunks and append to pkt.
172 * Return the number of bytes read or an error. */
173 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
175 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
176 int orig_size = pkt->size;
180 int prev_size = pkt->size;
183 /* When the caller requests a lot of data, limit it to the amount
184 * left in file or SANE_CHUNK_SIZE when it is not known. */
186 if (read_size > SANE_CHUNK_SIZE/10) {
187 read_size = ffio_limit(s, read_size);
188 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
190 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
193 ret = av_grow_packet(pkt, read_size);
197 ret = avio_read(s, pkt->data + prev_size, read_size);
198 if (ret != read_size) {
199 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
206 pkt->flags |= AV_PKT_FLAG_CORRUPT;
211 return pkt->size > orig_size ? pkt->size - orig_size : ret;
214 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
219 pkt->pos = avio_tell(s);
221 return append_packet_chunked(s, pkt, size);
224 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
227 return av_get_packet(s, pkt, size);
228 return append_packet_chunked(s, pkt, size);
231 int av_filename_number_test(const char *filename)
235 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
238 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
241 AVProbeData lpd = *pd;
242 AVInputFormat *fmt1 = NULL, *fmt;
243 int score, nodat = 0, score_max = 0;
244 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
247 lpd.buf = zerobuffer;
249 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
250 int id3len = ff_id3v2_tag_len(lpd.buf);
251 if (lpd.buf_size > id3len + 16) {
253 lpd.buf_size -= id3len;
259 while ((fmt1 = av_iformat_next(fmt1))) {
260 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
263 if (fmt1->read_probe) {
264 score = fmt1->read_probe(&lpd);
265 if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
266 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
267 } else if (fmt1->extensions) {
268 if (av_match_ext(lpd.filename, fmt1->extensions))
269 score = AVPROBE_SCORE_EXTENSION;
271 if (score > score_max) {
274 } else if (score == score_max)
278 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
279 *score_ret = score_max;
284 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
287 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
288 if (score_ret > *score_max) {
289 *score_max = score_ret;
295 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
298 return av_probe_input_format2(pd, is_opened, &score);
301 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
304 static const struct {
307 enum AVMediaType type;
309 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
310 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
311 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
312 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
313 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
314 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
315 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
316 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
317 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
318 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
322 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
324 if (fmt && st->request_probe <= score) {
326 av_log(s, AV_LOG_DEBUG,
327 "Probe with size=%d, packets=%d detected %s with score=%d\n",
328 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
330 for (i = 0; fmt_id_type[i].name; i++) {
331 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
332 st->codec->codec_id = fmt_id_type[i].id;
333 st->codec->codec_type = fmt_id_type[i].type;
341 /************************************************************/
342 /* input media file */
344 int av_demuxer_open(AVFormatContext *ic) {
347 if (ic->iformat->read_header) {
348 err = ic->iformat->read_header(ic);
353 if (ic->pb && !ic->data_offset)
354 ic->data_offset = avio_tell(ic->pb);
360 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
361 const char *filename, void *logctx,
362 unsigned int offset, unsigned int max_probe_size)
364 AVProbeData pd = { filename ? filename : "" };
367 int ret = 0, probe_size, buf_offset = 0;
371 max_probe_size = PROBE_BUF_MAX;
372 else if (max_probe_size > PROBE_BUF_MAX)
373 max_probe_size = PROBE_BUF_MAX;
374 else if (max_probe_size < PROBE_BUF_MIN) {
375 av_log(logctx, AV_LOG_ERROR,
376 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
377 return AVERROR(EINVAL);
380 if (offset >= max_probe_size)
381 return AVERROR(EINVAL);
383 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
384 if (!av_strcasecmp(mime_type, "audio/aacp")) {
385 *fmt = av_find_input_format("aac");
387 av_freep(&mime_type);
390 for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
391 probe_size = FFMIN(probe_size << 1,
392 FFMAX(max_probe_size, probe_size + 1))) {
393 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
395 /* Read probe data. */
396 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
398 if ((ret = avio_read(pb, buf + buf_offset,
399 probe_size - buf_offset)) < 0) {
400 /* Fail if error was not end of file, otherwise, lower score. */
401 if (ret != AVERROR_EOF) {
406 ret = 0; /* error was end of file, nothing read */
409 if (buf_offset < offset)
411 pd.buf_size = buf_offset - offset;
412 pd.buf = &buf[offset];
414 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
416 /* Guess file format. */
417 *fmt = av_probe_input_format2(&pd, 1, &score);
419 /* This can only be true in the last iteration. */
420 if (score <= AVPROBE_SCORE_RETRY) {
421 av_log(logctx, AV_LOG_WARNING,
422 "Format %s detected only with low score of %d, "
423 "misdetection possible!\n", (*fmt)->name, score);
425 av_log(logctx, AV_LOG_DEBUG,
426 "Format %s probed with size=%d and score=%d\n",
427 (*fmt)->name, probe_size, score);
429 FILE *f = fopen("probestat.tmp", "ab");
430 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
438 return AVERROR_INVALIDDATA;
441 /* Rewind. Reuse probe buffer to avoid seeking. */
442 ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
444 return ret < 0 ? ret : score;
447 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
448 const char *filename, void *logctx,
449 unsigned int offset, unsigned int max_probe_size)
451 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
452 return ret < 0 ? ret : 0;
455 /* Open input file and probe the format if necessary. */
456 static int init_input(AVFormatContext *s, const char *filename,
457 AVDictionary **options)
460 AVProbeData pd = { filename, NULL, 0 };
461 int score = AVPROBE_SCORE_RETRY;
464 s->flags |= AVFMT_FLAG_CUSTOM_IO;
466 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
468 else if (s->iformat->flags & AVFMT_NOFILE)
469 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
470 "will be ignored with AVFMT_NOFILE format.\n");
474 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
475 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
478 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
479 &s->interrupt_callback, options)) < 0)
483 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
487 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
488 AVPacketList **plast_pktl)
490 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
495 (*plast_pktl)->next = pktl;
497 *packet_buffer = pktl;
499 /* Add the packet in the buffered packet list. */
505 int avformat_queue_attached_pictures(AVFormatContext *s)
508 for (i = 0; i < s->nb_streams; i++)
509 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
510 s->streams[i]->discard < AVDISCARD_ALL) {
511 AVPacket copy = s->streams[i]->attached_pic;
512 copy.buf = av_buffer_ref(copy.buf);
514 return AVERROR(ENOMEM);
516 add_to_pktbuf(&s->raw_packet_buffer, ©,
517 &s->raw_packet_buffer_end);
522 int avformat_open_input(AVFormatContext **ps, const char *filename,
523 AVInputFormat *fmt, AVDictionary **options)
525 AVFormatContext *s = *ps;
527 AVDictionary *tmp = NULL;
528 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
530 if (!s && !(s = avformat_alloc_context()))
531 return AVERROR(ENOMEM);
533 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
534 return AVERROR(EINVAL);
540 av_dict_copy(&tmp, *options, 0);
542 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
545 if ((ret = init_input(s, filename, &tmp)) < 0)
547 s->probe_score = ret;
548 avio_skip(s->pb, s->skip_initial_bytes);
550 /* Check filename in case an image number is expected. */
551 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
552 if (!av_filename_number_test(filename)) {
553 ret = AVERROR(EINVAL);
558 s->duration = s->start_time = AV_NOPTS_VALUE;
559 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
561 /* Allocate private data. */
562 if (s->iformat->priv_data_size > 0) {
563 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
564 ret = AVERROR(ENOMEM);
567 if (s->iformat->priv_class) {
568 *(const AVClass **) s->priv_data = s->iformat->priv_class;
569 av_opt_set_defaults(s->priv_data);
570 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
575 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
577 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
579 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
580 if ((ret = s->iformat->read_header(s)) < 0)
583 if (id3v2_extra_meta) {
584 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
585 !strcmp(s->iformat->name, "tta")) {
586 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
589 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
591 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
593 if ((ret = avformat_queue_attached_pictures(s)) < 0)
596 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
597 s->data_offset = avio_tell(s->pb);
599 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
602 av_dict_free(options);
609 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
611 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
613 avformat_free_context(s);
618 /*******************************************************/
620 static void force_codec_ids(AVFormatContext *s, AVStream *st)
622 switch (st->codec->codec_type) {
623 case AVMEDIA_TYPE_VIDEO:
624 if (s->video_codec_id)
625 st->codec->codec_id = s->video_codec_id;
627 case AVMEDIA_TYPE_AUDIO:
628 if (s->audio_codec_id)
629 st->codec->codec_id = s->audio_codec_id;
631 case AVMEDIA_TYPE_SUBTITLE:
632 if (s->subtitle_codec_id)
633 st->codec->codec_id = s->subtitle_codec_id;
638 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
640 if (st->request_probe>0) {
641 AVProbeData *pd = &st->probe_data;
643 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
647 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
649 av_log(s, AV_LOG_WARNING,
650 "Failed to reallocate probe buffer for stream %d\n",
655 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
656 pd->buf_size += pkt->size;
657 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
660 st->probe_packets = 0;
662 av_log(s, AV_LOG_WARNING,
663 "nothing to probe for stream %d\n", st->index);
667 end= s->raw_packet_buffer_remaining_size <= 0
668 || st->probe_packets<= 0;
670 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
671 int score = set_codec_from_probe_data(s, st, pd);
672 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
676 st->request_probe = -1;
677 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
678 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
680 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
682 force_codec_ids(s, st);
688 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
690 int64_t ref = pkt->dts;
691 int i, pts_wrap_behavior;
692 int64_t pts_wrap_reference;
693 AVProgram *first_program;
695 if (ref == AV_NOPTS_VALUE)
697 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
699 ref &= (1LL << st->pts_wrap_bits)-1;
701 // reference time stamp should be 60 s before first time stamp
702 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
703 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
704 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
705 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
706 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
708 first_program = av_find_program_from_stream(s, NULL, stream_index);
710 if (!first_program) {
711 int default_stream_index = av_find_default_stream_index(s);
712 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
713 for (i = 0; i < s->nb_streams; i++) {
714 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
715 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
719 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
720 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
724 AVProgram *program = first_program;
726 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
727 pts_wrap_reference = program->pts_wrap_reference;
728 pts_wrap_behavior = program->pts_wrap_behavior;
731 program = av_find_program_from_stream(s, program, stream_index);
734 // update every program with differing pts_wrap_reference
735 program = first_program;
737 if (program->pts_wrap_reference != pts_wrap_reference) {
738 for (i = 0; i<program->nb_stream_indexes; i++) {
739 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
740 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
743 program->pts_wrap_reference = pts_wrap_reference;
744 program->pts_wrap_behavior = pts_wrap_behavior;
746 program = av_find_program_from_stream(s, program, stream_index);
752 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
758 AVPacketList *pktl = s->raw_packet_buffer;
762 st = s->streams[pkt->stream_index];
763 if (s->raw_packet_buffer_remaining_size <= 0)
764 if ((err = probe_codec(s, st, NULL)) < 0)
766 if (st->request_probe <= 0) {
767 s->raw_packet_buffer = pktl->next;
768 s->raw_packet_buffer_remaining_size += pkt->size;
777 ret = s->iformat->read_packet(s, pkt);
779 if (!pktl || ret == AVERROR(EAGAIN))
781 for (i = 0; i < s->nb_streams; i++) {
783 if (st->probe_packets)
784 if ((err = probe_codec(s, st, NULL)) < 0)
786 av_assert0(st->request_probe <= 0);
791 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
792 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
793 av_log(s, AV_LOG_WARNING,
794 "Dropped corrupted packet (stream = %d)\n",
800 if (pkt->stream_index >= (unsigned)s->nb_streams) {
801 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
805 st = s->streams[pkt->stream_index];
807 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
808 // correct first time stamps to negative values
809 if (!is_relative(st->first_dts))
810 st->first_dts = wrap_timestamp(st, st->first_dts);
811 if (!is_relative(st->start_time))
812 st->start_time = wrap_timestamp(st, st->start_time);
813 if (!is_relative(st->cur_dts))
814 st->cur_dts = wrap_timestamp(st, st->cur_dts);
817 pkt->dts = wrap_timestamp(st, pkt->dts);
818 pkt->pts = wrap_timestamp(st, pkt->pts);
820 force_codec_ids(s, st);
822 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
823 if (s->use_wallclock_as_timestamps)
824 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
826 if (!pktl && st->request_probe <= 0)
829 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
830 s->raw_packet_buffer_remaining_size -= pkt->size;
832 if ((err = probe_codec(s, st, pkt)) < 0)
837 #if FF_API_READ_PACKET
838 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
840 return ff_read_packet(s, pkt);
845 /**********************************************************/
847 static int determinable_frame_size(AVCodecContext *avctx)
849 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
850 avctx->codec_id == AV_CODEC_ID_MP1 ||
851 avctx->codec_id == AV_CODEC_ID_MP2 ||
852 avctx->codec_id == AV_CODEC_ID_MP3/* ||
853 avctx->codec_id == AV_CODEC_ID_CELT*/)
859 * Get the number of samples of an audio frame. Return -1 on error.
861 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
865 /* give frame_size priority if demuxing */
866 if (!mux && enc->frame_size > 1)
867 return enc->frame_size;
869 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
872 /* Fall back on using frame_size if muxing. */
873 if (enc->frame_size > 1)
874 return enc->frame_size;
876 //For WMA we currently have no other means to calculate duration thus we
877 //do it here by assuming CBR, which is true for all known cases.
878 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
879 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
880 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
887 * Return the frame duration in seconds. Return 0 if not available.
889 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
890 AVCodecParserContext *pc, AVPacket *pkt)
896 switch (st->codec->codec_type) {
897 case AVMEDIA_TYPE_VIDEO:
898 if (st->r_frame_rate.num && !pc) {
899 *pnum = st->r_frame_rate.den;
900 *pden = st->r_frame_rate.num;
901 } else if (st->time_base.num * 1000LL > st->time_base.den) {
902 *pnum = st->time_base.num;
903 *pden = st->time_base.den;
904 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
905 *pnum = st->codec->time_base.num;
906 *pden = st->codec->time_base.den;
907 if (pc && pc->repeat_pict) {
908 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
909 *pden /= 1 + pc->repeat_pict;
911 *pnum *= 1 + pc->repeat_pict;
913 /* If this codec can be interlaced or progressive then we need
914 * a parser to compute duration of a packet. Thus if we have
915 * no parser in such case leave duration undefined. */
916 if (st->codec->ticks_per_frame > 1 && !pc)
920 case AVMEDIA_TYPE_AUDIO:
921 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
922 if (frame_size <= 0 || st->codec->sample_rate <= 0)
925 *pden = st->codec->sample_rate;
932 static int is_intra_only(AVCodecContext *enc) {
933 const AVCodecDescriptor *desc;
935 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
938 desc = av_codec_get_codec_descriptor(enc);
940 desc = avcodec_descriptor_get(enc->codec_id);
941 av_codec_set_codec_descriptor(enc, desc);
944 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
948 static int has_decode_delay_been_guessed(AVStream *st)
950 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
951 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
953 #if CONFIG_H264_DECODER
954 if (st->codec->has_b_frames &&
955 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
958 if (st->codec->has_b_frames<3)
959 return st->nb_decoded_frames >= 7;
960 else if (st->codec->has_b_frames<4)
961 return st->nb_decoded_frames >= 18;
963 return st->nb_decoded_frames >= 20;
966 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
970 if (pktl == s->packet_buffer_end)
971 return s->parse_queue;
975 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
976 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
977 st->codec->codec_id != AV_CODEC_ID_HEVC;
980 int delay = st->codec->has_b_frames;
983 if (dts == AV_NOPTS_VALUE) {
984 int64_t best_score = INT64_MAX;
985 for (i = 0; i<delay; i++) {
986 if (st->pts_reorder_error_count[i]) {
987 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
988 if (score < best_score) {
995 for (i = 0; i<delay; i++) {
996 if (pts_buffer[i] != AV_NOPTS_VALUE) {
997 int64_t diff = FFABS(pts_buffer[i] - dts)
998 + (uint64_t)st->pts_reorder_error[i];
999 diff = FFMAX(diff, st->pts_reorder_error[i]);
1000 st->pts_reorder_error[i] = diff;
1001 st->pts_reorder_error_count[i]++;
1002 if (st->pts_reorder_error_count[i] > 250) {
1003 st->pts_reorder_error[i] >>= 1;
1004 st->pts_reorder_error_count[i] >>= 1;
1011 if (dts == AV_NOPTS_VALUE)
1012 dts = pts_buffer[0];
1017 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1018 int64_t dts, int64_t pts, AVPacket *pkt)
1020 AVStream *st = s->streams[stream_index];
1021 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1022 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1026 if (st->first_dts != AV_NOPTS_VALUE ||
1027 dts == AV_NOPTS_VALUE ||
1028 st->cur_dts == AV_NOPTS_VALUE ||
1032 delay = st->codec->has_b_frames;
1033 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1035 shift = st->first_dts - RELATIVE_TS_BASE;
1037 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1038 pts_buffer[i] = AV_NOPTS_VALUE;
1040 if (is_relative(pts))
1043 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1044 if (pktl->pkt.stream_index != stream_index)
1046 if (is_relative(pktl->pkt.pts))
1047 pktl->pkt.pts += shift;
1049 if (is_relative(pktl->pkt.dts))
1050 pktl->pkt.dts += shift;
1052 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1053 st->start_time = pktl->pkt.pts;
1055 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1056 pts_buffer[0] = pktl->pkt.pts;
1057 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1058 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1060 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
1064 if (st->start_time == AV_NOPTS_VALUE)
1065 st->start_time = pts;
1068 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1069 int stream_index, int duration)
1071 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1072 int64_t cur_dts = RELATIVE_TS_BASE;
1074 if (st->first_dts != AV_NOPTS_VALUE) {
1075 if (st->update_initial_durations_done)
1077 st->update_initial_durations_done = 1;
1078 cur_dts = st->first_dts;
1079 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1080 if (pktl->pkt.stream_index == stream_index) {
1081 if (pktl->pkt.pts != pktl->pkt.dts ||
1082 pktl->pkt.dts != AV_NOPTS_VALUE ||
1085 cur_dts -= duration;
1088 if (pktl && pktl->pkt.dts != st->first_dts) {
1089 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1090 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1094 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1097 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1098 st->first_dts = cur_dts;
1099 } else if (st->cur_dts != RELATIVE_TS_BASE)
1102 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1103 if (pktl->pkt.stream_index != stream_index)
1105 if (pktl->pkt.pts == pktl->pkt.dts &&
1106 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1107 !pktl->pkt.duration) {
1108 pktl->pkt.dts = cur_dts;
1109 if (!st->codec->has_b_frames)
1110 pktl->pkt.pts = cur_dts;
1111 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1112 pktl->pkt.duration = duration;
1115 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1118 st->cur_dts = cur_dts;
1121 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1122 AVCodecParserContext *pc, AVPacket *pkt)
1124 int num, den, presentation_delayed, delay, i;
1126 AVRational duration;
1127 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1128 st->codec->codec_id != AV_CODEC_ID_HEVC;
1130 if (s->flags & AVFMT_FLAG_NOFILLIN)
1133 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1134 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1135 if (st->last_dts_for_order_check <= pkt->dts) {
1138 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1139 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1141 st->last_dts_for_order_check);
1142 st->dts_misordered++;
1144 if (st->dts_ordered + st->dts_misordered > 250) {
1145 st->dts_ordered >>= 1;
1146 st->dts_misordered >>= 1;
1150 st->last_dts_for_order_check = pkt->dts;
1151 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1152 pkt->dts = AV_NOPTS_VALUE;
1155 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1156 pkt->dts = AV_NOPTS_VALUE;
1158 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1159 && !st->codec->has_b_frames)
1160 //FIXME Set low_delay = 0 when has_b_frames = 1
1161 st->codec->has_b_frames = 1;
1163 /* do we have a video B-frame ? */
1164 delay = st->codec->has_b_frames;
1165 presentation_delayed = 0;
1167 /* XXX: need has_b_frame, but cannot get it if the codec is
1168 * not initialized */
1170 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1171 presentation_delayed = 1;
1173 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1174 st->pts_wrap_bits < 63 &&
1175 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1176 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1177 pkt->dts -= 1LL << st->pts_wrap_bits;
1179 pkt->pts += 1LL << st->pts_wrap_bits;
1182 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1183 * We take the conservative approach and discard both.
1184 * Note: If this is misbehaving for an H.264 file, then possibly
1185 * presentation_delayed is not set correctly. */
1186 if (delay == 1 && pkt->dts == pkt->pts &&
1187 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1188 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1189 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1190 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1191 pkt->dts = AV_NOPTS_VALUE;
1194 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1195 if (pkt->duration == 0) {
1196 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1198 duration = (AVRational) {num, den};
1199 pkt->duration = av_rescale_rnd(1,
1200 num * (int64_t) st->time_base.den,
1201 den * (int64_t) st->time_base.num,
1206 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1207 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1209 /* Correct timestamps with byte offset if demuxers only have timestamps
1210 * on packet boundaries */
1211 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1212 /* this will estimate bitrate based on this frame's duration and size */
1213 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1214 if (pkt->pts != AV_NOPTS_VALUE)
1216 if (pkt->dts != AV_NOPTS_VALUE)
1220 /* This may be redundant, but it should not hurt. */
1221 if (pkt->dts != AV_NOPTS_VALUE &&
1222 pkt->pts != AV_NOPTS_VALUE &&
1223 pkt->pts > pkt->dts)
1224 presentation_delayed = 1;
1227 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1228 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1229 pkt->stream_index, pc, pkt->duration);
1230 /* Interpolate PTS and DTS if they are not present. We skip H264
1231 * currently because delay and has_b_frames are not reliably set. */
1232 if ((delay == 0 || (delay == 1 && pc)) &&
1234 if (presentation_delayed) {
1235 /* DTS = decompression timestamp */
1236 /* PTS = presentation timestamp */
1237 if (pkt->dts == AV_NOPTS_VALUE)
1238 pkt->dts = st->last_IP_pts;
1239 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1240 if (pkt->dts == AV_NOPTS_VALUE)
1241 pkt->dts = st->cur_dts;
1243 /* This is tricky: the dts must be incremented by the duration
1244 * of the frame we are displaying, i.e. the last I- or P-frame. */
1245 if (st->last_IP_duration == 0)
1246 st->last_IP_duration = pkt->duration;
1247 if (pkt->dts != AV_NOPTS_VALUE)
1248 st->cur_dts = pkt->dts + st->last_IP_duration;
1249 st->last_IP_duration = pkt->duration;
1250 st->last_IP_pts = pkt->pts;
1251 /* Cannot compute PTS if not present (we can compute it only
1252 * by knowing the future. */
1253 } else if (pkt->pts != AV_NOPTS_VALUE ||
1254 pkt->dts != AV_NOPTS_VALUE ||
1257 /* presentation is not delayed : PTS and DTS are the same */
1258 if (pkt->pts == AV_NOPTS_VALUE)
1259 pkt->pts = pkt->dts;
1260 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1262 if (pkt->pts == AV_NOPTS_VALUE)
1263 pkt->pts = st->cur_dts;
1264 pkt->dts = pkt->pts;
1265 if (pkt->pts != AV_NOPTS_VALUE)
1266 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1270 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1271 st->pts_buffer[0] = pkt->pts;
1272 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1273 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1275 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1277 // We skipped it above so we try here.
1279 // This should happen on the first packet
1280 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1281 if (pkt->dts > st->cur_dts)
1282 st->cur_dts = pkt->dts;
1284 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1285 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1288 if (is_intra_only(st->codec))
1289 pkt->flags |= AV_PKT_FLAG_KEY;
1291 pkt->convergence_duration = pc->convergence_duration;
1294 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1297 AVPacketList *pktl = *pkt_buf;
1298 *pkt_buf = pktl->next;
1299 av_free_packet(&pktl->pkt);
1302 *pkt_buf_end = NULL;
1306 * Parse a packet, add all split parts to parse_queue.
1308 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1310 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1312 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1313 AVStream *st = s->streams[stream_index];
1314 uint8_t *data = pkt ? pkt->data : NULL;
1315 int size = pkt ? pkt->size : 0;
1316 int ret = 0, got_output = 0;
1319 av_init_packet(&flush_pkt);
1322 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1323 // preserve 0-size sync packets
1324 compute_pkt_fields(s, st, st->parser, pkt);
1327 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1330 av_init_packet(&out_pkt);
1331 len = av_parser_parse2(st->parser, st->codec,
1332 &out_pkt.data, &out_pkt.size, data, size,
1333 pkt->pts, pkt->dts, pkt->pos);
1335 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1337 /* increment read pointer */
1341 got_output = !!out_pkt.size;
1346 if (pkt->side_data) {
1347 out_pkt.side_data = pkt->side_data;
1348 out_pkt.side_data_elems = pkt->side_data_elems;
1349 pkt->side_data = NULL;
1350 pkt->side_data_elems = 0;
1353 /* set the duration */
1354 out_pkt.duration = 0;
1355 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1356 if (st->codec->sample_rate > 0) {
1358 av_rescale_q_rnd(st->parser->duration,
1359 (AVRational) { 1, st->codec->sample_rate },
1363 } else if (st->codec->time_base.num != 0 &&
1364 st->codec->time_base.den != 0) {
1365 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1366 st->codec->time_base,
1371 out_pkt.stream_index = st->index;
1372 out_pkt.pts = st->parser->pts;
1373 out_pkt.dts = st->parser->dts;
1374 out_pkt.pos = st->parser->pos;
1376 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1377 out_pkt.pos = st->parser->frame_offset;
1379 if (st->parser->key_frame == 1 ||
1380 (st->parser->key_frame == -1 &&
1381 st->parser->pict_type == AV_PICTURE_TYPE_I))
1382 out_pkt.flags |= AV_PKT_FLAG_KEY;
1384 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1385 out_pkt.flags |= AV_PKT_FLAG_KEY;
1387 compute_pkt_fields(s, st, st->parser, &out_pkt);
1389 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1390 out_pkt.buf = pkt->buf;
1392 #if FF_API_DESTRUCT_PACKET
1393 FF_DISABLE_DEPRECATION_WARNINGS
1394 out_pkt.destruct = pkt->destruct;
1395 pkt->destruct = NULL;
1396 FF_ENABLE_DEPRECATION_WARNINGS
1399 if ((ret = av_dup_packet(&out_pkt)) < 0)
1402 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1403 av_free_packet(&out_pkt);
1404 ret = AVERROR(ENOMEM);
1409 /* end of the stream => close and free the parser */
1410 if (pkt == &flush_pkt) {
1411 av_parser_close(st->parser);
1416 av_free_packet(pkt);
1420 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1421 AVPacketList **pkt_buffer_end,
1425 av_assert0(*pkt_buffer);
1428 *pkt_buffer = pktl->next;
1430 *pkt_buffer_end = NULL;
1435 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1437 int ret = 0, i, got_packet = 0;
1439 av_init_packet(pkt);
1441 while (!got_packet && !s->parse_queue) {
1445 /* read next packet */
1446 ret = ff_read_packet(s, &cur_pkt);
1448 if (ret == AVERROR(EAGAIN))
1450 /* flush the parsers */
1451 for (i = 0; i < s->nb_streams; i++) {
1453 if (st->parser && st->need_parsing)
1454 parse_packet(s, NULL, st->index);
1456 /* all remaining packets are now in parse_queue =>
1457 * really terminate parsing */
1461 st = s->streams[cur_pkt.stream_index];
1463 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1464 cur_pkt.dts != AV_NOPTS_VALUE &&
1465 cur_pkt.pts < cur_pkt.dts) {
1466 av_log(s, AV_LOG_WARNING,
1467 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1468 cur_pkt.stream_index,
1469 av_ts2str(cur_pkt.pts),
1470 av_ts2str(cur_pkt.dts),
1473 if (s->debug & FF_FDEBUG_TS)
1474 av_log(s, AV_LOG_DEBUG,
1475 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1476 cur_pkt.stream_index,
1477 av_ts2str(cur_pkt.pts),
1478 av_ts2str(cur_pkt.dts),
1479 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1481 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1482 st->parser = av_parser_init(st->codec->codec_id);
1484 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1485 "%s, packets or times may be invalid.\n",
1486 avcodec_get_name(st->codec->codec_id));
1487 /* no parser available: just output the raw packets */
1488 st->need_parsing = AVSTREAM_PARSE_NONE;
1489 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1490 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1491 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1492 st->parser->flags |= PARSER_FLAG_ONCE;
1493 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1494 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1497 if (!st->need_parsing || !st->parser) {
1498 /* no parsing needed: we just output the packet as is */
1500 compute_pkt_fields(s, st, NULL, pkt);
1501 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1502 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1503 ff_reduce_index(s, st->index);
1504 av_add_index_entry(st, pkt->pos, pkt->dts,
1505 0, 0, AVINDEX_KEYFRAME);
1508 } else if (st->discard < AVDISCARD_ALL) {
1509 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1513 av_free_packet(&cur_pkt);
1515 if (pkt->flags & AV_PKT_FLAG_KEY)
1516 st->skip_to_keyframe = 0;
1517 if (st->skip_to_keyframe) {
1518 av_free_packet(&cur_pkt);
1526 if (!got_packet && s->parse_queue)
1527 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1530 AVStream *st = s->streams[pkt->stream_index];
1531 if (st->skip_samples) {
1532 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1534 AV_WL32(p, st->skip_samples);
1535 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1537 st->skip_samples = 0;
1540 if (st->inject_global_side_data) {
1541 for (i = 0; i < st->nb_side_data; i++) {
1542 AVPacketSideData *src_sd = &st->side_data[i];
1545 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1548 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1550 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1554 memcpy(dst_data, src_sd->data, src_sd->size);
1556 st->inject_global_side_data = 0;
1559 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1560 av_packet_merge_side_data(pkt);
1563 if (s->debug & FF_FDEBUG_TS)
1564 av_log(s, AV_LOG_DEBUG,
1565 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1566 "size=%d, duration=%d, flags=%d\n",
1568 av_ts2str(pkt->pts),
1569 av_ts2str(pkt->dts),
1570 pkt->size, pkt->duration, pkt->flags);
1575 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1577 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1583 ret = s->packet_buffer
1584 ? read_from_packet_buffer(&s->packet_buffer,
1585 &s->packet_buffer_end, pkt)
1586 : read_frame_internal(s, pkt);
1593 AVPacketList *pktl = s->packet_buffer;
1596 AVPacket *next_pkt = &pktl->pkt;
1598 if (next_pkt->dts != AV_NOPTS_VALUE) {
1599 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1600 // last dts seen for this stream. if any of packets following
1601 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1602 int64_t last_dts = next_pkt->dts;
1603 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1604 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1605 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1606 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1608 next_pkt->pts = pktl->pkt.dts;
1610 if (last_dts != AV_NOPTS_VALUE) {
1611 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1612 last_dts = pktl->pkt.dts;
1617 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1618 // Fixing the last reference frame had none pts issue (For MXF etc).
1619 // We only do this when
1621 // 2. we are not able to resolve a pts value for current packet.
1622 // 3. the packets for this stream at the end of the files had valid dts.
1623 next_pkt->pts = last_dts + next_pkt->duration;
1625 pktl = s->packet_buffer;
1628 /* read packet from packet buffer, if there is data */
1629 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1630 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1631 ret = read_from_packet_buffer(&s->packet_buffer,
1632 &s->packet_buffer_end, pkt);
1637 ret = read_frame_internal(s, pkt);
1639 if (pktl && ret != AVERROR(EAGAIN)) {
1646 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1647 &s->packet_buffer_end)) < 0)
1648 return AVERROR(ENOMEM);
1653 st = s->streams[pkt->stream_index];
1654 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1655 ff_reduce_index(s, st->index);
1656 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1659 if (is_relative(pkt->dts))
1660 pkt->dts -= RELATIVE_TS_BASE;
1661 if (is_relative(pkt->pts))
1662 pkt->pts -= RELATIVE_TS_BASE;
1667 /* XXX: suppress the packet queue */
1668 static void flush_packet_queue(AVFormatContext *s)
1670 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1671 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1672 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1674 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1677 /*******************************************************/
1680 int av_find_default_stream_index(AVFormatContext *s)
1682 int first_audio_index = -1;
1686 if (s->nb_streams <= 0)
1688 for (i = 0; i < s->nb_streams; i++) {
1690 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1691 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1694 if (first_audio_index < 0 &&
1695 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1696 first_audio_index = i;
1698 return first_audio_index >= 0 ? first_audio_index : 0;
1701 /** Flush the frame reader. */
1702 void ff_read_frame_flush(AVFormatContext *s)
1707 flush_packet_queue(s);
1709 /* Reset read state for each stream. */
1710 for (i = 0; i < s->nb_streams; i++) {
1714 av_parser_close(st->parser);
1717 st->last_IP_pts = AV_NOPTS_VALUE;
1718 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1719 if (st->first_dts == AV_NOPTS_VALUE)
1720 st->cur_dts = RELATIVE_TS_BASE;
1722 /* We set the current DTS to an unspecified origin. */
1723 st->cur_dts = AV_NOPTS_VALUE;
1725 st->probe_packets = MAX_PROBE_PACKETS;
1727 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1728 st->pts_buffer[j] = AV_NOPTS_VALUE;
1730 if (s->internal->inject_global_side_data)
1731 st->inject_global_side_data = 1;
1735 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1739 for (i = 0; i < s->nb_streams; i++) {
1740 AVStream *st = s->streams[i];
1743 av_rescale(timestamp,
1744 st->time_base.den * (int64_t) ref_st->time_base.num,
1745 st->time_base.num * (int64_t) ref_st->time_base.den);
1749 void ff_reduce_index(AVFormatContext *s, int stream_index)
1751 AVStream *st = s->streams[stream_index];
1752 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1754 if ((unsigned) st->nb_index_entries >= max_entries) {
1756 for (i = 0; 2 * i < st->nb_index_entries; i++)
1757 st->index_entries[i] = st->index_entries[2 * i];
1758 st->nb_index_entries = i;
1762 int ff_add_index_entry(AVIndexEntry **index_entries,
1763 int *nb_index_entries,
1764 unsigned int *index_entries_allocated_size,
1765 int64_t pos, int64_t timestamp,
1766 int size, int distance, int flags)
1768 AVIndexEntry *entries, *ie;
1771 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1774 if (timestamp == AV_NOPTS_VALUE)
1775 return AVERROR(EINVAL);
1777 if (size < 0 || size > 0x3FFFFFFF)
1778 return AVERROR(EINVAL);
1780 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1781 timestamp -= RELATIVE_TS_BASE;
1783 entries = av_fast_realloc(*index_entries,
1784 index_entries_allocated_size,
1785 (*nb_index_entries + 1) *
1786 sizeof(AVIndexEntry));
1790 *index_entries = entries;
1792 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1793 timestamp, AVSEEK_FLAG_ANY);
1796 index = (*nb_index_entries)++;
1797 ie = &entries[index];
1798 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1800 ie = &entries[index];
1801 if (ie->timestamp != timestamp) {
1802 if (ie->timestamp <= timestamp)
1804 memmove(entries + index + 1, entries + index,
1805 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1806 (*nb_index_entries)++;
1807 } else if (ie->pos == pos && distance < ie->min_distance)
1808 // do not reduce the distance
1809 distance = ie->min_distance;
1813 ie->timestamp = timestamp;
1814 ie->min_distance = distance;
1821 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1822 int size, int distance, int flags)
1824 timestamp = wrap_timestamp(st, timestamp);
1825 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1826 &st->index_entries_allocated_size, pos,
1827 timestamp, size, distance, flags);
1830 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1831 int64_t wanted_timestamp, int flags)
1839 // Optimize appending index entries at the end.
1840 if (b && entries[b - 1].timestamp < wanted_timestamp)
1845 timestamp = entries[m].timestamp;
1846 if (timestamp >= wanted_timestamp)
1848 if (timestamp <= wanted_timestamp)
1851 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1853 if (!(flags & AVSEEK_FLAG_ANY))
1854 while (m >= 0 && m < nb_entries &&
1855 !(entries[m].flags & AVINDEX_KEYFRAME))
1856 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1858 if (m == nb_entries)
1863 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1865 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1866 wanted_timestamp, flags);
1869 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1870 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1872 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1873 if (stream_index >= 0)
1874 ts = wrap_timestamp(s->streams[stream_index], ts);
1878 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1879 int64_t target_ts, int flags)
1881 AVInputFormat *avif = s->iformat;
1882 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1883 int64_t ts_min, ts_max, ts;
1888 if (stream_index < 0)
1891 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1894 ts_min = AV_NOPTS_VALUE;
1895 pos_limit = -1; // GCC falsely says it may be uninitialized.
1897 st = s->streams[stream_index];
1898 if (st->index_entries) {
1901 /* FIXME: Whole function must be checked for non-keyframe entries in
1902 * index case, especially read_timestamp(). */
1903 index = av_index_search_timestamp(st, target_ts,
1904 flags | AVSEEK_FLAG_BACKWARD);
1905 index = FFMAX(index, 0);
1906 e = &st->index_entries[index];
1908 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1910 ts_min = e->timestamp;
1911 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1912 pos_min, av_ts2str(ts_min));
1914 av_assert1(index == 0);
1917 index = av_index_search_timestamp(st, target_ts,
1918 flags & ~AVSEEK_FLAG_BACKWARD);
1919 av_assert0(index < st->nb_index_entries);
1921 e = &st->index_entries[index];
1922 av_assert1(e->timestamp >= target_ts);
1924 ts_max = e->timestamp;
1925 pos_limit = pos_max - e->min_distance;
1926 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1927 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1931 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1932 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1937 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1940 ff_read_frame_flush(s);
1941 ff_update_cur_dts(s, st, ts);
1946 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1947 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1949 int64_t step = 1024;
1950 int64_t limit, ts_max;
1951 int64_t filesize = avio_size(s->pb);
1952 int64_t pos_max = filesize - 1;
1955 pos_max = FFMAX(0, (pos_max) - step);
1956 ts_max = ff_read_timestamp(s, stream_index,
1957 &pos_max, limit, read_timestamp);
1959 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1960 if (ts_max == AV_NOPTS_VALUE)
1964 int64_t tmp_pos = pos_max + 1;
1965 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1966 &tmp_pos, INT64_MAX, read_timestamp);
1967 if (tmp_ts == AV_NOPTS_VALUE)
1969 av_assert0(tmp_pos > pos_max);
1972 if (tmp_pos >= filesize)
1984 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1985 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1986 int64_t ts_min, int64_t ts_max,
1987 int flags, int64_t *ts_ret,
1988 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1989 int64_t *, int64_t))
1996 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1998 if (ts_min == AV_NOPTS_VALUE) {
1999 pos_min = s->data_offset;
2000 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2001 if (ts_min == AV_NOPTS_VALUE)
2005 if (ts_min >= target_ts) {
2010 if (ts_max == AV_NOPTS_VALUE) {
2011 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2013 pos_limit = pos_max;
2016 if (ts_max <= target_ts) {
2021 if (ts_min > ts_max)
2023 else if (ts_min == ts_max)
2024 pos_limit = pos_min;
2027 while (pos_min < pos_limit) {
2029 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2030 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2031 assert(pos_limit <= pos_max);
2033 if (no_change == 0) {
2034 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2035 // interpolate position (better than dichotomy)
2036 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2038 pos_min - approximate_keyframe_distance;
2039 } else if (no_change == 1) {
2040 // bisection if interpolation did not change min / max pos last time
2041 pos = (pos_min + pos_limit) >> 1;
2043 /* linear search if bisection failed, can only happen if there
2044 * are very few or no keyframes between min/max */
2049 else if (pos > pos_limit)
2053 // May pass pos_limit instead of -1.
2054 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2059 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2060 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2061 pos_min, pos, pos_max,
2062 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2063 pos_limit, start_pos, no_change);
2064 if (ts == AV_NOPTS_VALUE) {
2065 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2068 assert(ts != AV_NOPTS_VALUE);
2069 if (target_ts <= ts) {
2070 pos_limit = start_pos - 1;
2074 if (target_ts >= ts) {
2080 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2081 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2084 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2086 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2087 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2088 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2094 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2095 int64_t pos, int flags)
2097 int64_t pos_min, pos_max;
2099 pos_min = s->data_offset;
2100 pos_max = avio_size(s->pb) - 1;
2104 else if (pos > pos_max)
2107 avio_seek(s->pb, pos, SEEK_SET);
2109 s->io_repositioned = 1;
2114 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2115 int64_t timestamp, int flags)
2122 st = s->streams[stream_index];
2124 index = av_index_search_timestamp(st, timestamp, flags);
2126 if (index < 0 && st->nb_index_entries &&
2127 timestamp < st->index_entries[0].timestamp)
2130 if (index < 0 || index == st->nb_index_entries - 1) {
2134 if (st->nb_index_entries) {
2135 av_assert0(st->index_entries);
2136 ie = &st->index_entries[st->nb_index_entries - 1];
2137 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2139 ff_update_cur_dts(s, st, ie->timestamp);
2141 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2147 read_status = av_read_frame(s, &pkt);
2148 } while (read_status == AVERROR(EAGAIN));
2149 if (read_status < 0)
2151 av_free_packet(&pkt);
2152 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2153 if (pkt.flags & AV_PKT_FLAG_KEY)
2155 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2156 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);
2161 index = av_index_search_timestamp(st, timestamp, flags);
2166 ff_read_frame_flush(s);
2167 if (s->iformat->read_seek)
2168 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2170 ie = &st->index_entries[index];
2171 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2173 ff_update_cur_dts(s, st, ie->timestamp);
2178 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2179 int64_t timestamp, int flags)
2184 if (flags & AVSEEK_FLAG_BYTE) {
2185 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2187 ff_read_frame_flush(s);
2188 return seek_frame_byte(s, stream_index, timestamp, flags);
2191 if (stream_index < 0) {
2192 stream_index = av_find_default_stream_index(s);
2193 if (stream_index < 0)
2196 st = s->streams[stream_index];
2197 /* timestamp for default must be expressed in AV_TIME_BASE units */
2198 timestamp = av_rescale(timestamp, st->time_base.den,
2199 AV_TIME_BASE * (int64_t) st->time_base.num);
2202 /* first, we try the format specific seek */
2203 if (s->iformat->read_seek) {
2204 ff_read_frame_flush(s);
2205 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2211 if (s->iformat->read_timestamp &&
2212 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2213 ff_read_frame_flush(s);
2214 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2215 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2216 ff_read_frame_flush(s);
2217 return seek_frame_generic(s, stream_index, timestamp, flags);
2222 int av_seek_frame(AVFormatContext *s, int stream_index,
2223 int64_t timestamp, int flags)
2227 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2228 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2229 if ((flags & AVSEEK_FLAG_BACKWARD))
2233 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2234 flags & ~AVSEEK_FLAG_BACKWARD);
2237 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2240 ret = avformat_queue_attached_pictures(s);
2245 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2246 int64_t ts, int64_t max_ts, int flags)
2248 if (min_ts > ts || max_ts < ts)
2250 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2251 return AVERROR(EINVAL);
2254 flags |= AVSEEK_FLAG_ANY;
2255 flags &= ~AVSEEK_FLAG_BACKWARD;
2257 if (s->iformat->read_seek2) {
2259 ff_read_frame_flush(s);
2261 if (stream_index == -1 && s->nb_streams == 1) {
2262 AVRational time_base = s->streams[0]->time_base;
2263 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2264 min_ts = av_rescale_rnd(min_ts, time_base.den,
2265 time_base.num * (int64_t)AV_TIME_BASE,
2266 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2267 max_ts = av_rescale_rnd(max_ts, time_base.den,
2268 time_base.num * (int64_t)AV_TIME_BASE,
2269 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2272 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2276 ret = avformat_queue_attached_pictures(s);
2280 if (s->iformat->read_timestamp) {
2281 // try to seek via read_timestamp()
2284 // Fall back on old API if new is not implemented but old is.
2285 // Note the old API has somewhat different semantics.
2286 if (s->iformat->read_seek || 1) {
2287 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2288 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2289 if (ret<0 && ts != min_ts && max_ts != ts) {
2290 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2292 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2297 // try some generic seek like seek_frame_generic() but with new ts semantics
2298 return -1; //unreachable
2301 /*******************************************************/
2304 * Return TRUE if the stream has accurate duration in any stream.
2306 * @return TRUE if the stream has accurate duration for at least one component.
2308 static int has_duration(AVFormatContext *ic)
2313 for (i = 0; i < ic->nb_streams; i++) {
2314 st = ic->streams[i];
2315 if (st->duration != AV_NOPTS_VALUE)
2318 if (ic->duration != AV_NOPTS_VALUE)
2324 * Estimate the stream timings from the one of each components.
2326 * Also computes the global bitrate if possible.
2328 static void update_stream_timings(AVFormatContext *ic)
2330 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2331 int64_t duration, duration1, filesize;
2336 start_time = INT64_MAX;
2337 start_time_text = INT64_MAX;
2338 end_time = INT64_MIN;
2339 duration = INT64_MIN;
2340 for (i = 0; i < ic->nb_streams; i++) {
2341 st = ic->streams[i];
2342 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2343 start_time1 = av_rescale_q(st->start_time, st->time_base,
2345 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2346 if (start_time1 < start_time_text)
2347 start_time_text = start_time1;
2349 start_time = FFMIN(start_time, start_time1);
2350 end_time1 = AV_NOPTS_VALUE;
2351 if (st->duration != AV_NOPTS_VALUE) {
2352 end_time1 = start_time1 +
2353 av_rescale_q(st->duration, st->time_base,
2355 end_time = FFMAX(end_time, end_time1);
2357 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2358 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2359 p->start_time = start_time1;
2360 if (p->end_time < end_time1)
2361 p->end_time = end_time1;
2364 if (st->duration != AV_NOPTS_VALUE) {
2365 duration1 = av_rescale_q(st->duration, st->time_base,
2367 duration = FFMAX(duration, duration1);
2370 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2371 start_time = start_time_text;
2372 else if (start_time > start_time_text)
2373 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2375 if (start_time != INT64_MAX) {
2376 ic->start_time = start_time;
2377 if (end_time != INT64_MIN) {
2378 if (ic->nb_programs) {
2379 for (i = 0; i < ic->nb_programs; i++) {
2380 p = ic->programs[i];
2381 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2382 duration = FFMAX(duration, p->end_time - p->start_time);
2385 duration = FFMAX(duration, end_time - start_time);
2388 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2389 ic->duration = duration;
2391 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2392 /* compute the bitrate */
2393 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2394 (double) ic->duration;
2395 if (bitrate >= 0 && bitrate <= INT_MAX)
2396 ic->bit_rate = bitrate;
2400 static void fill_all_stream_timings(AVFormatContext *ic)
2405 update_stream_timings(ic);
2406 for (i = 0; i < ic->nb_streams; i++) {
2407 st = ic->streams[i];
2408 if (st->start_time == AV_NOPTS_VALUE) {
2409 if (ic->start_time != AV_NOPTS_VALUE)
2410 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2412 if (ic->duration != AV_NOPTS_VALUE)
2413 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2419 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2421 int64_t filesize, duration;
2422 int i, show_warning = 0;
2425 /* if bit_rate is already set, we believe it */
2426 if (ic->bit_rate <= 0) {
2428 for (i = 0; i < ic->nb_streams; i++) {
2429 st = ic->streams[i];
2430 if (st->codec->bit_rate > 0) {
2431 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2435 bit_rate += st->codec->bit_rate;
2438 ic->bit_rate = bit_rate;
2441 /* if duration is already set, we believe it */
2442 if (ic->duration == AV_NOPTS_VALUE &&
2443 ic->bit_rate != 0) {
2444 filesize = ic->pb ? avio_size(ic->pb) : 0;
2446 for (i = 0; i < ic->nb_streams; i++) {
2447 st = ic->streams[i];
2448 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2449 && st->duration == AV_NOPTS_VALUE) {
2450 duration = av_rescale(8 * filesize, st->time_base.den,
2452 (int64_t) st->time_base.num);
2453 st->duration = duration;
2460 av_log(ic, AV_LOG_WARNING,
2461 "Estimating duration from bitrate, this may be inaccurate\n");
2464 #define DURATION_MAX_READ_SIZE 250000LL
2465 #define DURATION_MAX_RETRY 4
2467 /* only usable for MPEG-PS streams */
2468 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2470 AVPacket pkt1, *pkt = &pkt1;
2472 int read_size, i, ret;
2474 int64_t filesize, offset, duration;
2477 /* flush packet queue */
2478 flush_packet_queue(ic);
2480 for (i = 0; i < ic->nb_streams; i++) {
2481 st = ic->streams[i];
2482 if (st->start_time == AV_NOPTS_VALUE &&
2483 st->first_dts == AV_NOPTS_VALUE &&
2484 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2485 av_log(st->codec, AV_LOG_WARNING,
2486 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2489 av_parser_close(st->parser);
2494 /* estimate the end time (duration) */
2495 /* XXX: may need to support wrapping */
2496 filesize = ic->pb ? avio_size(ic->pb) : 0;
2497 end_time = AV_NOPTS_VALUE;
2499 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2503 avio_seek(ic->pb, offset, SEEK_SET);
2506 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2510 ret = ff_read_packet(ic, pkt);
2511 } while (ret == AVERROR(EAGAIN));
2514 read_size += pkt->size;
2515 st = ic->streams[pkt->stream_index];
2516 if (pkt->pts != AV_NOPTS_VALUE &&
2517 (st->start_time != AV_NOPTS_VALUE ||
2518 st->first_dts != AV_NOPTS_VALUE)) {
2519 duration = end_time = pkt->pts;
2520 if (st->start_time != AV_NOPTS_VALUE)
2521 duration -= st->start_time;
2523 duration -= st->first_dts;
2525 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2526 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2527 st->duration = duration;
2528 st->info->last_duration = duration;
2531 av_free_packet(pkt);
2533 } while (end_time == AV_NOPTS_VALUE &&
2534 filesize > (DURATION_MAX_READ_SIZE << retry) &&
2535 ++retry <= DURATION_MAX_RETRY);
2537 fill_all_stream_timings(ic);
2539 avio_seek(ic->pb, old_offset, SEEK_SET);
2540 for (i = 0; i < ic->nb_streams; i++) {
2543 st = ic->streams[i];
2544 st->cur_dts = st->first_dts;
2545 st->last_IP_pts = AV_NOPTS_VALUE;
2546 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2547 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2548 st->pts_buffer[j] = AV_NOPTS_VALUE;
2552 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2556 /* get the file size, if possible */
2557 if (ic->iformat->flags & AVFMT_NOFILE) {
2560 file_size = avio_size(ic->pb);
2561 file_size = FFMAX(0, file_size);
2564 if ((!strcmp(ic->iformat->name, "mpeg") ||
2565 !strcmp(ic->iformat->name, "mpegts")) &&
2566 file_size && ic->pb->seekable) {
2567 /* get accurate estimate from the PTSes */
2568 estimate_timings_from_pts(ic, old_offset);
2569 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2570 } else if (has_duration(ic)) {
2571 /* at least one component has timings - we use them for all
2573 fill_all_stream_timings(ic);
2574 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2576 /* less precise: use bitrate info */
2577 estimate_timings_from_bit_rate(ic);
2578 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2580 update_stream_timings(ic);
2584 AVStream av_unused *st;
2585 for (i = 0; i < ic->nb_streams; i++) {
2586 st = ic->streams[i];
2587 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2588 (double) st->start_time / AV_TIME_BASE,
2589 (double) st->duration / AV_TIME_BASE);
2592 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2593 (double) ic->start_time / AV_TIME_BASE,
2594 (double) ic->duration / AV_TIME_BASE,
2595 ic->bit_rate / 1000);
2599 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2601 AVCodecContext *avctx = st->codec;
2603 #define FAIL(errmsg) do { \
2605 *errmsg_ptr = errmsg; \
2609 switch (avctx->codec_type) {
2610 case AVMEDIA_TYPE_AUDIO:
2611 if (!avctx->frame_size && determinable_frame_size(avctx))
2612 FAIL("unspecified frame size");
2613 if (st->info->found_decoder >= 0 &&
2614 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2615 FAIL("unspecified sample format");
2616 if (!avctx->sample_rate)
2617 FAIL("unspecified sample rate");
2618 if (!avctx->channels)
2619 FAIL("unspecified number of channels");
2620 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2621 FAIL("no decodable DTS frames");
2623 case AVMEDIA_TYPE_VIDEO:
2625 FAIL("unspecified size");
2626 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2627 FAIL("unspecified pixel format");
2628 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2629 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2630 FAIL("no frame in rv30/40 and no sar");
2632 case AVMEDIA_TYPE_SUBTITLE:
2633 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2634 FAIL("unspecified size");
2636 case AVMEDIA_TYPE_DATA:
2637 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2640 if (avctx->codec_id == AV_CODEC_ID_NONE)
2641 FAIL("unknown codec");
2645 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2646 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2647 AVDictionary **options)
2649 const AVCodec *codec;
2650 int got_picture = 1, ret = 0;
2651 AVFrame *frame = av_frame_alloc();
2652 AVSubtitle subtitle;
2653 AVPacket pkt = *avpkt;
2656 return AVERROR(ENOMEM);
2658 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2659 AVDictionary *thread_opt = NULL;
2661 codec = find_decoder(s, st, st->codec->codec_id);
2664 st->info->found_decoder = -1;
2669 /* Force thread count to 1 since the H.264 decoder will not extract
2670 * SPS and PPS to extradata during multi-threaded decoding. */
2671 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2672 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2674 av_dict_free(&thread_opt);
2676 st->info->found_decoder = -1;
2679 st->info->found_decoder = 1;
2680 } else if (!st->info->found_decoder)
2681 st->info->found_decoder = 1;
2683 if (st->info->found_decoder < 0) {
2688 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2690 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2691 (!st->codec_info_nb_frames &&
2692 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2694 switch (st->codec->codec_type) {
2695 case AVMEDIA_TYPE_VIDEO:
2696 ret = avcodec_decode_video2(st->codec, frame,
2697 &got_picture, &pkt);
2699 case AVMEDIA_TYPE_AUDIO:
2700 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2702 case AVMEDIA_TYPE_SUBTITLE:
2703 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2704 &got_picture, &pkt);
2712 st->nb_decoded_frames++;
2719 if (!pkt.data && !got_picture)
2723 av_frame_free(&frame);
2727 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2729 while (tags->id != AV_CODEC_ID_NONE) {
2737 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2740 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2741 if (tag == tags[i].tag)
2743 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2744 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2746 return AV_CODEC_ID_NONE;
2749 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2754 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2756 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2758 return AV_CODEC_ID_NONE;
2763 if (sflags & (1 << (bps - 1))) {
2766 return AV_CODEC_ID_PCM_S8;
2768 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2770 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2772 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2774 return AV_CODEC_ID_NONE;
2779 return AV_CODEC_ID_PCM_U8;
2781 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2783 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2785 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2787 return AV_CODEC_ID_NONE;
2793 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2796 if (!av_codec_get_tag2(tags, id, &tag))
2801 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2805 for (i = 0; tags && tags[i]; i++) {
2806 const AVCodecTag *codec_tags = tags[i];
2807 while (codec_tags->id != AV_CODEC_ID_NONE) {
2808 if (codec_tags->id == id) {
2809 *tag = codec_tags->tag;
2818 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2821 for (i = 0; tags && tags[i]; i++) {
2822 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2823 if (id != AV_CODEC_ID_NONE)
2826 return AV_CODEC_ID_NONE;
2829 static void compute_chapters_end(AVFormatContext *s)
2832 int64_t max_time = s->duration +
2833 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2835 for (i = 0; i < s->nb_chapters; i++)
2836 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2837 AVChapter *ch = s->chapters[i];
2838 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2842 for (j = 0; j < s->nb_chapters; j++) {
2843 AVChapter *ch1 = s->chapters[j];
2844 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2846 if (j != i && next_start > ch->start && next_start < end)
2849 ch->end = (end == INT64_MAX) ? ch->start : end;
2853 static int get_std_framerate(int i)
2856 return (i + 1) * 1001;
2858 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2861 /* Is the time base unreliable?
2862 * This is a heuristic to balance between quick acceptance of the values in
2863 * the headers vs. some extra checks.
2864 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2865 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2866 * And there are "variable" fps files this needs to detect as well. */
2867 static int tb_unreliable(AVCodecContext *c)
2869 if (c->time_base.den >= 101L * c->time_base.num ||
2870 c->time_base.den < 5L * c->time_base.num ||
2871 // c->codec_tag == AV_RL32("DIVX") ||
2872 // c->codec_tag == AV_RL32("XVID") ||
2873 c->codec_tag == AV_RL32("mp4v") ||
2874 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2875 c->codec_id == AV_CODEC_ID_H264)
2880 #if FF_API_FORMAT_PARAMETERS
2881 int av_find_stream_info(AVFormatContext *ic)
2883 return avformat_find_stream_info(ic, NULL);
2887 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2891 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2892 avctx->extradata_size = 0;
2893 return AVERROR(EINVAL);
2895 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2896 if (avctx->extradata) {
2897 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2898 avctx->extradata_size = size;
2901 avctx->extradata_size = 0;
2902 ret = AVERROR(ENOMEM);
2907 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2909 int ret = ff_alloc_extradata(avctx, size);
2912 ret = avio_read(pb, avctx->extradata, size);
2914 av_freep(&avctx->extradata);
2915 avctx->extradata_size = 0;
2916 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2917 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2923 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2926 int64_t last = st->info->last_dts;
2928 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2929 && ts - (uint64_t)last < INT64_MAX) {
2930 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2931 int64_t duration = ts - last;
2933 if (!st->info->duration_error)
2934 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2935 if (!st->info->duration_error)
2936 return AVERROR(ENOMEM);
2938 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2939 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2940 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2941 if (st->info->duration_error[0][1][i] < 1e10) {
2942 int framerate = get_std_framerate(i);
2943 double sdts = dts*framerate/(1001*12);
2944 for (j= 0; j<2; j++) {
2945 int64_t ticks = llrint(sdts+j*0.5);
2946 double error= sdts - ticks + j*0.5;
2947 st->info->duration_error[j][0][i] += error;
2948 st->info->duration_error[j][1][i] += error*error;
2952 st->info->duration_count++;
2953 st->info->rfps_duration_sum += duration;
2955 if (st->info->duration_count % 10 == 0) {
2956 int n = st->info->duration_count;
2957 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2958 if (st->info->duration_error[0][1][i] < 1e10) {
2959 double a0 = st->info->duration_error[0][0][i] / n;
2960 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2961 double a1 = st->info->duration_error[1][0][i] / n;
2962 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2963 if (error0 > 0.04 && error1 > 0.04) {
2964 st->info->duration_error[0][1][i] = 2e10;
2965 st->info->duration_error[1][1][i] = 2e10;
2971 // ignore the first 4 values, they might have some random jitter
2972 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2973 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2975 if (ts != AV_NOPTS_VALUE)
2976 st->info->last_dts = ts;
2981 void ff_rfps_calculate(AVFormatContext *ic)
2985 for (i = 0; i < ic->nb_streams; i++) {
2986 AVStream *st = ic->streams[i];
2988 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2990 // the check for tb_unreliable() is not completely correct, since this is not about handling
2991 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2992 // ipmovie.c produces.
2993 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)
2994 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);
2995 if (st->info->duration_count>1 && !st->r_frame_rate.num
2996 && tb_unreliable(st->codec)) {
2998 double best_error= 0.01;
3000 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3003 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3005 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3008 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3011 for (k= 0; k<2; k++) {
3012 int n = st->info->duration_count;
3013 double a= st->info->duration_error[k][0][j] / n;
3014 double error= st->info->duration_error[k][1][j]/n - a*a;
3016 if (error < best_error && best_error> 0.000000001) {
3018 num = get_std_framerate(j);
3021 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3024 // do not increase frame rate by more than 1 % in order to match a standard rate.
3025 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3026 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3029 av_freep(&st->info->duration_error);
3030 st->info->last_dts = AV_NOPTS_VALUE;
3031 st->info->duration_count = 0;
3032 st->info->rfps_duration_sum = 0;
3036 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3038 int i, count, ret = 0, j;
3041 AVPacket pkt1, *pkt;
3042 int64_t old_offset = avio_tell(ic->pb);
3043 // new streams might appear, no options for those
3044 int orig_nb_streams = ic->nb_streams;
3045 int flush_codecs = ic->probesize > 0;
3048 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3049 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3051 for (i = 0; i < ic->nb_streams; i++) {
3052 const AVCodec *codec;
3053 AVDictionary *thread_opt = NULL;
3054 st = ic->streams[i];
3056 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3057 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3058 /* if (!st->time_base.num)
3060 if (!st->codec->time_base.num)
3061 st->codec->time_base = st->time_base;
3063 // only for the split stuff
3064 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3065 st->parser = av_parser_init(st->codec->codec_id);
3067 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3068 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3069 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3070 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3072 } else if (st->need_parsing) {
3073 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3074 "%s, packets or times may be invalid.\n",
3075 avcodec_get_name(st->codec->codec_id));
3078 codec = find_decoder(ic, st, st->codec->codec_id);
3080 /* Force thread count to 1 since the H.264 decoder will not extract
3081 * SPS and PPS to extradata during multi-threaded decoding. */
3082 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3084 /* Ensure that subtitle_header is properly set. */
3085 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3086 && codec && !st->codec->codec) {
3087 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3088 av_log(ic, AV_LOG_WARNING,
3089 "Failed to open codec in av_find_stream_info\n");
3092 // Try to just open decoders, in case this is enough to get parameters.
3093 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3094 if (codec && !st->codec->codec)
3095 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3096 av_log(ic, AV_LOG_WARNING,
3097 "Failed to open codec in av_find_stream_info\n");
3100 av_dict_free(&thread_opt);
3103 for (i = 0; i < ic->nb_streams; i++) {
3104 #if FF_API_R_FRAME_RATE
3105 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3107 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3108 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3114 if (ff_check_interrupt(&ic->interrupt_callback)) {
3116 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3120 /* check if one codec still needs to be handled */
3121 for (i = 0; i < ic->nb_streams; i++) {
3122 int fps_analyze_framecount = 20;
3124 st = ic->streams[i];
3125 if (!has_codec_parameters(st, NULL))
3127 /* If the timebase is coarse (like the usual millisecond precision
3128 * of mkv), we need to analyze more frames to reliably arrive at
3129 * the correct fps. */
3130 if (av_q2d(st->time_base) > 0.0005)
3131 fps_analyze_framecount *= 2;
3132 if (ic->fps_probe_size >= 0)
3133 fps_analyze_framecount = ic->fps_probe_size;
3134 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3135 fps_analyze_framecount = 0;
3136 /* variable fps and no guess at the real fps */
3137 if (tb_unreliable(st->codec) &&
3138 !(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3139 st->info->duration_count < fps_analyze_framecount &&
3140 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3142 if (st->parser && st->parser->parser->split &&
3143 !st->codec->extradata)
3145 if (st->first_dts == AV_NOPTS_VALUE &&
3146 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3147 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3150 if (i == ic->nb_streams) {
3151 /* NOTE: If the format has no header, then we need to read some
3152 * packets to get most of the streams, so we cannot stop here. */
3153 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3154 /* If we found the info for all the codecs, we can stop. */
3156 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3161 /* We did not get all the codec info, but we read too much data. */
3162 if (read_size >= ic->probesize) {
3164 av_log(ic, AV_LOG_DEBUG,
3165 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3166 for (i = 0; i < ic->nb_streams; i++)
3167 if (!ic->streams[i]->r_frame_rate.num &&
3168 ic->streams[i]->info->duration_count <= 1 &&
3169 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3170 strcmp(ic->iformat->name, "image2"))
3171 av_log(ic, AV_LOG_WARNING,
3172 "Stream #%d: not enough frames to estimate rate; "
3173 "consider increasing probesize\n", i);
3177 /* NOTE: A new stream can be added there if no header in file
3178 * (AVFMTCTX_NOHEADER). */
3179 ret = read_frame_internal(ic, &pkt1);
3180 if (ret == AVERROR(EAGAIN))
3188 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3189 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3191 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3192 &ic->packet_buffer_end);
3194 ret = AVERROR(ENOMEM);
3195 goto find_stream_info_err;
3197 if ((ret = av_dup_packet(pkt)) < 0)
3198 goto find_stream_info_err;
3201 st = ic->streams[pkt->stream_index];
3202 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3203 read_size += pkt->size;
3205 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3206 /* check for non-increasing dts */
3207 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3208 st->info->fps_last_dts >= pkt->dts) {
3209 av_log(ic, AV_LOG_DEBUG,
3210 "Non-increasing DTS in stream %d: packet %d with DTS "
3211 "%"PRId64", packet %d with DTS %"PRId64"\n",
3212 st->index, st->info->fps_last_dts_idx,
3213 st->info->fps_last_dts, st->codec_info_nb_frames,
3215 st->info->fps_first_dts =
3216 st->info->fps_last_dts = AV_NOPTS_VALUE;
3218 /* Check for a discontinuity in dts. If the difference in dts
3219 * is more than 1000 times the average packet duration in the
3220 * sequence, we treat it as a discontinuity. */
3221 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3222 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3223 (pkt->dts - st->info->fps_last_dts) / 1000 >
3224 (st->info->fps_last_dts - st->info->fps_first_dts) /
3225 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3226 av_log(ic, AV_LOG_WARNING,
3227 "DTS discontinuity in stream %d: packet %d with DTS "
3228 "%"PRId64", packet %d with DTS %"PRId64"\n",
3229 st->index, st->info->fps_last_dts_idx,
3230 st->info->fps_last_dts, st->codec_info_nb_frames,
3232 st->info->fps_first_dts =
3233 st->info->fps_last_dts = AV_NOPTS_VALUE;
3236 /* update stored dts values */
3237 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3238 st->info->fps_first_dts = pkt->dts;
3239 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3241 st->info->fps_last_dts = pkt->dts;
3242 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3244 if (st->codec_info_nb_frames>1) {
3246 if (st->time_base.den > 0)
3247 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3248 if (st->avg_frame_rate.num > 0)
3249 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3252 && st->codec_info_nb_frames>30
3253 && st->info->fps_first_dts != AV_NOPTS_VALUE
3254 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3255 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3257 if (t >= ic->max_analyze_duration) {
3258 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n",
3259 ic->max_analyze_duration,
3263 if (pkt->duration) {
3264 st->info->codec_info_duration += pkt->duration;
3265 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3268 #if FF_API_R_FRAME_RATE
3269 ff_rfps_add_frame(ic, st, pkt->dts);
3271 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3272 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3273 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3274 if (ff_alloc_extradata(st->codec, i))
3275 return AVERROR(ENOMEM);
3276 memcpy(st->codec->extradata, pkt->data,
3277 st->codec->extradata_size);
3281 /* If still no information, we try to open the codec and to
3282 * decompress the frame. We try to avoid that in most cases as
3283 * it takes longer and uses more memory. For MPEG-4, we need to
3284 * decompress for QuickTime.
3286 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3287 * least one frame of codec data, this makes sure the codec initializes
3288 * the channel configuration and does not only trust the values from
3290 try_decode_frame(ic, st, pkt,
3291 (options && i < orig_nb_streams) ? &options[i] : NULL);
3293 st->codec_info_nb_frames++;
3298 AVPacket empty_pkt = { 0 };
3300 av_init_packet(&empty_pkt);
3302 for (i = 0; i < ic->nb_streams; i++) {
3304 st = ic->streams[i];
3306 /* flush the decoders */
3307 if (st->info->found_decoder == 1) {
3309 err = try_decode_frame(ic, st, &empty_pkt,
3310 (options && i < orig_nb_streams)
3311 ? &options[i] : NULL);
3312 } while (err > 0 && !has_codec_parameters(st, NULL));
3315 av_log(ic, AV_LOG_INFO,
3316 "decoding for stream %d failed\n", st->index);
3322 // close codecs which were opened in try_decode_frame()
3323 for (i = 0; i < ic->nb_streams; i++) {
3324 st = ic->streams[i];
3325 avcodec_close(st->codec);
3328 ff_rfps_calculate(ic);
3330 for (i = 0; i < ic->nb_streams; i++) {
3331 st = ic->streams[i];
3332 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3333 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3334 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3335 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3336 st->codec->codec_tag= tag;
3339 /* estimate average framerate if not set by demuxer */
3340 if (st->info->codec_info_duration_fields &&
3341 !st->avg_frame_rate.num &&
3342 st->info->codec_info_duration) {
3344 double best_error = 0.01;
3346 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3347 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3348 st->info->codec_info_duration < 0)
3350 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3351 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3352 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3354 /* Round guessed framerate to a "standard" framerate if it's
3355 * within 1% of the original estimate. */
3356 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3357 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3358 double error = fabs(av_q2d(st->avg_frame_rate) /
3359 av_q2d(std_fps) - 1);
3361 if (error < best_error) {
3363 best_fps = std_fps.num;
3367 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3368 best_fps, 12 * 1001, INT_MAX);
3371 if (!st->r_frame_rate.num) {
3372 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3373 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3374 st->r_frame_rate.num = st->codec->time_base.den;
3375 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3377 st->r_frame_rate.num = st->time_base.den;
3378 st->r_frame_rate.den = st->time_base.num;
3381 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3382 if (!st->codec->bits_per_coded_sample)
3383 st->codec->bits_per_coded_sample =
3384 av_get_bits_per_sample(st->codec->codec_id);
3385 // set stream disposition based on audio service type
3386 switch (st->codec->audio_service_type) {
3387 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3388 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3390 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3391 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3393 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3394 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3396 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3397 st->disposition = AV_DISPOSITION_COMMENT;
3399 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3400 st->disposition = AV_DISPOSITION_KARAOKE;
3407 estimate_timings(ic, old_offset);
3409 if (ret >= 0 && ic->nb_streams)
3410 /* We could not have all the codec parameters before EOF. */
3412 for (i = 0; i < ic->nb_streams; i++) {
3414 st = ic->streams[i];
3415 if (!has_codec_parameters(st, &errmsg)) {
3417 avcodec_string(buf, sizeof(buf), st->codec, 0);
3418 av_log(ic, AV_LOG_WARNING,
3419 "Could not find codec parameters for stream %d (%s): %s\n"
3420 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3427 compute_chapters_end(ic);
3429 find_stream_info_err:
3430 for (i = 0; i < ic->nb_streams; i++) {
3431 st = ic->streams[i];
3432 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3433 ic->streams[i]->codec->thread_count = 0;
3435 av_freep(&st->info->duration_error);
3436 av_freep(&ic->streams[i]->info);
3439 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3440 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3444 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3448 for (i = 0; i < ic->nb_programs; i++) {
3449 if (ic->programs[i] == last) {
3453 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3454 if (ic->programs[i]->stream_index[j] == s)
3455 return ic->programs[i];
3461 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3462 int wanted_stream_nb, int related_stream,
3463 AVCodec **decoder_ret, int flags)
3465 int i, nb_streams = ic->nb_streams;
3466 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3467 unsigned *program = NULL;
3468 AVCodec *decoder = NULL, *best_decoder = NULL;
3470 if (related_stream >= 0 && wanted_stream_nb < 0) {
3471 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3473 program = p->stream_index;
3474 nb_streams = p->nb_stream_indexes;
3477 for (i = 0; i < nb_streams; i++) {
3478 int real_stream_index = program ? program[i] : i;
3479 AVStream *st = ic->streams[real_stream_index];
3480 AVCodecContext *avctx = st->codec;
3481 if (avctx->codec_type != type)
3483 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3485 if (wanted_stream_nb != real_stream_index &&
3486 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3487 AV_DISPOSITION_VISUAL_IMPAIRED))
3489 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3492 decoder = find_decoder(ic, st, st->codec->codec_id);
3495 ret = AVERROR_DECODER_NOT_FOUND;
3499 count = st->codec_info_nb_frames;
3500 bitrate = avctx->bit_rate;
3501 multiframe = FFMIN(5, count);
3502 if ((best_multiframe > multiframe) ||
3503 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3504 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3507 best_bitrate = bitrate;
3508 best_multiframe = multiframe;
3509 ret = real_stream_index;
3510 best_decoder = decoder;
3511 if (program && i == nb_streams - 1 && ret < 0) {
3513 nb_streams = ic->nb_streams;
3514 /* no related stream found, try again with everything */
3519 *decoder_ret = best_decoder;
3523 /*******************************************************/
3525 int av_read_play(AVFormatContext *s)
3527 if (s->iformat->read_play)
3528 return s->iformat->read_play(s);
3530 return avio_pause(s->pb, 0);
3531 return AVERROR(ENOSYS);
3534 int av_read_pause(AVFormatContext *s)
3536 if (s->iformat->read_pause)
3537 return s->iformat->read_pause(s);
3539 return avio_pause(s->pb, 1);
3540 return AVERROR(ENOSYS);
3543 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3545 av_assert0(s->nb_streams>0);
3546 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3548 for (j = 0; j < st->nb_side_data; j++)
3549 av_freep(&st->side_data[j].data);
3550 av_freep(&st->side_data);
3551 st->nb_side_data = 0;
3554 av_parser_close(st->parser);
3556 if (st->attached_pic.data)
3557 av_free_packet(&st->attached_pic);
3558 av_dict_free(&st->metadata);
3559 av_freep(&st->probe_data.buf);
3560 av_freep(&st->index_entries);
3561 av_freep(&st->codec->extradata);
3562 av_freep(&st->codec->subtitle_header);
3563 av_freep(&st->codec);
3564 av_freep(&st->priv_data);
3566 av_freep(&st->info->duration_error);
3567 av_freep(&st->info);
3568 av_freep(&s->streams[ --s->nb_streams ]);
3571 void avformat_free_context(AVFormatContext *s)
3579 if (s->iformat && s->iformat->priv_class && s->priv_data)
3580 av_opt_free(s->priv_data);
3581 if (s->oformat && s->oformat->priv_class && s->priv_data)
3582 av_opt_free(s->priv_data);
3584 for (i = s->nb_streams - 1; i >= 0; i--) {
3585 ff_free_stream(s, s->streams[i]);
3587 for (i = s->nb_programs - 1; i >= 0; i--) {
3588 av_dict_free(&s->programs[i]->metadata);
3589 av_freep(&s->programs[i]->stream_index);
3590 av_freep(&s->programs[i]);
3592 av_freep(&s->programs);
3593 av_freep(&s->priv_data);
3594 while (s->nb_chapters--) {
3595 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3596 av_freep(&s->chapters[s->nb_chapters]);
3598 av_freep(&s->chapters);
3599 av_dict_free(&s->metadata);
3600 av_freep(&s->streams);
3601 av_freep(&s->internal);
3605 #if FF_API_CLOSE_INPUT_FILE
3606 void av_close_input_file(AVFormatContext *s)
3608 avformat_close_input(&s);
3612 void avformat_close_input(AVFormatContext **ps)
3623 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3624 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3627 flush_packet_queue(s);
3630 if (s->iformat->read_close)
3631 s->iformat->read_close(s);
3633 avformat_free_context(s);
3640 #if FF_API_NEW_STREAM
3641 AVStream *av_new_stream(AVFormatContext *s, int id)
3643 AVStream *st = avformat_new_stream(s, NULL);
3650 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3656 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3658 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3661 s->streams = streams;
3663 st = av_mallocz(sizeof(AVStream));
3666 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3670 st->info->last_dts = AV_NOPTS_VALUE;
3672 st->codec = avcodec_alloc_context3(c);
3674 /* no default bitrate if decoding */
3675 st->codec->bit_rate = 0;
3676 st->index = s->nb_streams;
3677 st->start_time = AV_NOPTS_VALUE;
3678 st->duration = AV_NOPTS_VALUE;
3679 /* we set the current DTS to 0 so that formats without any timestamps
3680 * but durations get some timestamps, formats with some unknown
3681 * timestamps have their first few packets buffered and the
3682 * timestamps corrected before they are returned to the user */
3683 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3684 st->first_dts = AV_NOPTS_VALUE;
3685 st->probe_packets = MAX_PROBE_PACKETS;
3686 st->pts_wrap_reference = AV_NOPTS_VALUE;
3687 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3689 /* default pts setting is MPEG-like */
3690 avpriv_set_pts_info(st, 33, 1, 90000);
3691 st->last_IP_pts = AV_NOPTS_VALUE;
3692 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3693 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3694 st->pts_buffer[i] = AV_NOPTS_VALUE;
3696 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3698 #if FF_API_R_FRAME_RATE
3699 st->info->last_dts = AV_NOPTS_VALUE;
3701 st->info->fps_first_dts = AV_NOPTS_VALUE;
3702 st->info->fps_last_dts = AV_NOPTS_VALUE;
3704 st->inject_global_side_data = s->internal->inject_global_side_data;
3706 s->streams[s->nb_streams++] = st;
3710 AVProgram *av_new_program(AVFormatContext *ac, int id)
3712 AVProgram *program = NULL;
3715 av_dlog(ac, "new_program: id=0x%04x\n", id);
3717 for (i = 0; i < ac->nb_programs; i++)
3718 if (ac->programs[i]->id == id)
3719 program = ac->programs[i];
3722 program = av_mallocz(sizeof(AVProgram));
3725 dynarray_add(&ac->programs, &ac->nb_programs, program);
3726 program->discard = AVDISCARD_NONE;
3729 program->pts_wrap_reference = AV_NOPTS_VALUE;
3730 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3732 program->start_time =
3733 program->end_time = AV_NOPTS_VALUE;
3738 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3739 int64_t start, int64_t end, const char *title)
3741 AVChapter *chapter = NULL;
3744 for (i = 0; i < s->nb_chapters; i++)
3745 if (s->chapters[i]->id == id)
3746 chapter = s->chapters[i];
3749 chapter = av_mallocz(sizeof(AVChapter));
3752 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3754 av_dict_set(&chapter->metadata, "title", title, 0);
3756 chapter->time_base = time_base;
3757 chapter->start = start;
3763 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3766 AVProgram *program = NULL;
3769 if (idx >= ac->nb_streams) {
3770 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3774 for (i = 0; i < ac->nb_programs; i++) {
3775 if (ac->programs[i]->id != progid)
3777 program = ac->programs[i];
3778 for (j = 0; j < program->nb_stream_indexes; j++)
3779 if (program->stream_index[j] == idx)
3782 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3785 program->stream_index = tmp;
3786 program->stream_index[program->nb_stream_indexes++] = idx;
3791 static void print_fps(double d, const char *postfix)
3793 uint64_t v = lrintf(d * 100);
3795 av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3796 else if (v % (100 * 1000))
3797 av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3799 av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3802 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3804 if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3805 AVDictionaryEntry *tag = NULL;
3807 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3808 while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3809 if (strcmp("language", tag->key)) {
3810 const char *p = tag->value;
3811 av_log(ctx, AV_LOG_INFO,
3812 "%s %-16s: ", indent, tag->key);
3815 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3816 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3817 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3819 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3820 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3823 av_log(ctx, AV_LOG_INFO, "\n");
3828 /* "user interface" functions */
3829 static void dump_stream_format(AVFormatContext *ic, int i,
3830 int index, int is_output)
3833 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3834 AVStream *st = ic->streams[i];
3835 int g = av_gcd(st->time_base.num, st->time_base.den);
3836 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3837 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3838 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3839 /* the pid is an important information, so we display it */
3840 /* XXX: add a generic system */
3841 if (flags & AVFMT_SHOW_IDS)
3842 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3844 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3845 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3846 st->time_base.num / g, st->time_base.den / g);
3847 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3848 if (st->sample_aspect_ratio.num && // default
3849 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3850 AVRational display_aspect_ratio;
3851 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3852 st->codec->width * st->sample_aspect_ratio.num,
3853 st->codec->height * st->sample_aspect_ratio.den,
3855 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3856 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3857 display_aspect_ratio.num, display_aspect_ratio.den);
3859 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3860 if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3861 print_fps(av_q2d(st->avg_frame_rate), "fps");
3862 #if FF_API_R_FRAME_RATE
3863 if (st->r_frame_rate.den && st->r_frame_rate.num)
3864 print_fps(av_q2d(st->r_frame_rate), "tbr");
3866 if (st->time_base.den && st->time_base.num)
3867 print_fps(1 / av_q2d(st->time_base), "tbn");
3868 if (st->codec->time_base.den && st->codec->time_base.num)
3869 print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3871 if (st->disposition & AV_DISPOSITION_DEFAULT)
3872 av_log(NULL, AV_LOG_INFO, " (default)");
3873 if (st->disposition & AV_DISPOSITION_DUB)
3874 av_log(NULL, AV_LOG_INFO, " (dub)");
3875 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3876 av_log(NULL, AV_LOG_INFO, " (original)");
3877 if (st->disposition & AV_DISPOSITION_COMMENT)
3878 av_log(NULL, AV_LOG_INFO, " (comment)");
3879 if (st->disposition & AV_DISPOSITION_LYRICS)
3880 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3881 if (st->disposition & AV_DISPOSITION_KARAOKE)
3882 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3883 if (st->disposition & AV_DISPOSITION_FORCED)
3884 av_log(NULL, AV_LOG_INFO, " (forced)");
3885 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3886 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3887 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3888 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3889 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3890 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3891 av_log(NULL, AV_LOG_INFO, "\n");
3892 dump_metadata(NULL, st->metadata, " ");
3895 void av_dump_format(AVFormatContext *ic, int index,
3896 const char *url, int is_output)
3899 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3900 if (ic->nb_streams && !printed)
3903 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3904 is_output ? "Output" : "Input",
3906 is_output ? ic->oformat->name : ic->iformat->name,
3907 is_output ? "to" : "from", url);
3908 dump_metadata(NULL, ic->metadata, " ");
3910 av_log(NULL, AV_LOG_INFO, " Duration: ");
3911 if (ic->duration != AV_NOPTS_VALUE) {
3912 int hours, mins, secs, us;
3913 int64_t duration = ic->duration + 5000;
3914 secs = duration / AV_TIME_BASE;
3915 us = duration % AV_TIME_BASE;
3920 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3921 (100 * us) / AV_TIME_BASE);
3923 av_log(NULL, AV_LOG_INFO, "N/A");
3925 if (ic->start_time != AV_NOPTS_VALUE) {
3927 av_log(NULL, AV_LOG_INFO, ", start: ");
3928 secs = ic->start_time / AV_TIME_BASE;
3929 us = abs(ic->start_time % AV_TIME_BASE);
3930 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3931 secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3933 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3935 av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3937 av_log(NULL, AV_LOG_INFO, "N/A");
3938 av_log(NULL, AV_LOG_INFO, "\n");
3940 for (i = 0; i < ic->nb_chapters; i++) {
3941 AVChapter *ch = ic->chapters[i];
3942 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3943 av_log(NULL, AV_LOG_INFO,
3944 "start %f, ", ch->start * av_q2d(ch->time_base));
3945 av_log(NULL, AV_LOG_INFO,
3946 "end %f\n", ch->end * av_q2d(ch->time_base));
3948 dump_metadata(NULL, ch->metadata, " ");
3950 if (ic->nb_programs) {
3951 int j, k, total = 0;
3952 for (j = 0; j < ic->nb_programs; j++) {
3953 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3955 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3956 name ? name->value : "");
3957 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3958 for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3959 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3961 printed[ic->programs[j]->stream_index[k]] = 1;
3963 total += ic->programs[j]->nb_stream_indexes;
3965 if (total < ic->nb_streams)
3966 av_log(NULL, AV_LOG_INFO, " No Program\n");
3968 for (i = 0; i < ic->nb_streams; i++)
3970 dump_stream_format(ic, i, index, is_output);
3975 uint64_t ff_ntp_time(void)
3977 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3980 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3983 char *q, buf1[20], c;
3984 int nd, len, percentd_found;
3996 while (av_isdigit(*p))
3997 nd = nd * 10 + *p++ - '0';
3999 } while (av_isdigit(c));
4008 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4010 if ((q - buf + len) > buf_size - 1)
4012 memcpy(q, buf1, len);
4020 if ((q - buf) < buf_size - 1)
4024 if (!percentd_found)
4033 #define HEXDUMP_PRINT(...) \
4036 av_log(avcl, level, __VA_ARGS__); \
4038 fprintf(f, __VA_ARGS__); \
4041 static void hex_dump_internal(void *avcl, FILE *f, int level,
4042 const uint8_t *buf, int size)
4046 for (i = 0; i < size; i += 16) {
4050 HEXDUMP_PRINT("%08x ", i);
4051 for (j = 0; j < 16; j++) {
4053 HEXDUMP_PRINT(" %02x", buf[i + j]);
4058 for (j = 0; j < len; j++) {
4060 if (c < ' ' || c > '~')
4062 HEXDUMP_PRINT("%c", c);
4064 HEXDUMP_PRINT("\n");
4068 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
4070 hex_dump_internal(NULL, f, 0, buf, size);
4073 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
4075 hex_dump_internal(avcl, NULL, level, buf, size);
4078 static void pkt_dump_internal(void *avcl, FILE *f, int level, const AVPacket *pkt,
4079 int dump_payload, AVRational time_base)
4081 HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
4082 HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
4083 HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
4084 /* DTS is _always_ valid after av_read_frame() */
4085 HEXDUMP_PRINT(" dts=");
4086 if (pkt->dts == AV_NOPTS_VALUE)
4087 HEXDUMP_PRINT("N/A");
4089 HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
4090 /* PTS may not be known if B-frames are present. */
4091 HEXDUMP_PRINT(" pts=");
4092 if (pkt->pts == AV_NOPTS_VALUE)
4093 HEXDUMP_PRINT("N/A");
4095 HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
4096 HEXDUMP_PRINT("\n");
4097 HEXDUMP_PRINT(" size=%d\n", pkt->size);
4099 av_hex_dump(f, pkt->data, pkt->size);
4102 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
4104 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
4107 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
4110 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
4113 void av_url_split(char *proto, int proto_size,
4114 char *authorization, int authorization_size,
4115 char *hostname, int hostname_size,
4116 int *port_ptr, char *path, int path_size, const char *url)
4118 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4124 if (authorization_size > 0)
4125 authorization[0] = 0;
4126 if (hostname_size > 0)
4131 /* parse protocol */
4132 if ((p = strchr(url, ':'))) {
4133 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4140 /* no protocol means plain filename */
4141 av_strlcpy(path, url, path_size);
4145 /* separate path from hostname */
4146 ls = strchr(p, '/');
4147 ls2 = strchr(p, '?');
4151 ls = FFMIN(ls, ls2);
4153 av_strlcpy(path, ls, path_size);
4155 ls = &p[strlen(p)]; // XXX
4157 /* the rest is hostname, use that to parse auth/port */
4159 /* authorization (user[:pass]@hostname) */
4161 while ((at = strchr(p, '@')) && at < ls) {
4162 av_strlcpy(authorization, at2,
4163 FFMIN(authorization_size, at + 1 - at2));
4164 p = at + 1; /* skip '@' */
4167 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4169 av_strlcpy(hostname, p + 1,
4170 FFMIN(hostname_size, brk - p));
4171 if (brk[1] == ':' && port_ptr)
4172 *port_ptr = atoi(brk + 2);
4173 } else if ((col = strchr(p, ':')) && col < ls) {
4174 av_strlcpy(hostname, p,
4175 FFMIN(col + 1 - p, hostname_size));
4177 *port_ptr = atoi(col + 1);
4179 av_strlcpy(hostname, p,
4180 FFMIN(ls + 1 - p, hostname_size));
4184 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4187 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4190 'C', 'D', 'E', 'F' };
4191 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4194 'c', 'd', 'e', 'f' };
4195 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4197 for (i = 0; i < s; i++) {
4198 buff[i * 2] = hex_table[src[i] >> 4];
4199 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4205 int ff_hex_to_data(uint8_t *data, const char *p)
4212 p += strspn(p, SPACE_CHARS);
4215 c = av_toupper((unsigned char) *p++);
4216 if (c >= '0' && c <= '9')
4218 else if (c >= 'A' && c <= 'F')
4233 #if FF_API_SET_PTS_INFO
4234 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4235 unsigned int pts_num, unsigned int pts_den)
4237 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4241 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4242 unsigned int pts_num, unsigned int pts_den)
4245 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4246 if (new_tb.num != pts_num)
4247 av_log(NULL, AV_LOG_DEBUG,
4248 "st:%d removing common factor %d from timebase\n",
4249 s->index, pts_num / new_tb.num);
4251 av_log(NULL, AV_LOG_WARNING,
4252 "st:%d has too large timebase, reducing\n", s->index);
4254 if (new_tb.num <= 0 || new_tb.den <= 0) {
4255 av_log(NULL, AV_LOG_ERROR,
4256 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4257 new_tb.num, new_tb.den,
4261 s->time_base = new_tb;
4262 av_codec_set_pkt_timebase(s->codec, new_tb);
4263 s->pts_wrap_bits = pts_wrap_bits;
4266 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4269 const char *ptr = str;
4271 /* Parse key=value pairs. */
4274 char *dest = NULL, *dest_end;
4275 int key_len, dest_len = 0;
4277 /* Skip whitespace and potential commas. */
4278 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4285 if (!(ptr = strchr(key, '=')))
4288 key_len = ptr - key;
4290 callback_get_buf(context, key, key_len, &dest, &dest_len);
4291 dest_end = dest + dest_len - 1;
4295 while (*ptr && *ptr != '\"') {
4299 if (dest && dest < dest_end)
4303 if (dest && dest < dest_end)
4311 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4312 if (dest && dest < dest_end)
4320 int ff_find_stream_index(AVFormatContext *s, int id)
4323 for (i = 0; i < s->nb_streams; i++)
4324 if (s->streams[i]->id == id)
4329 int64_t ff_iso8601_to_unix_time(const char *datestr)
4331 struct tm time1 = { 0 }, time2 = { 0 };
4333 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4334 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4336 return av_timegm(&time2);
4338 return av_timegm(&time1);
4341 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4345 if (ofmt->query_codec)
4346 return ofmt->query_codec(codec_id, std_compliance);
4347 else if (ofmt->codec_tag)
4348 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4349 else if (codec_id == ofmt->video_codec ||
4350 codec_id == ofmt->audio_codec ||
4351 codec_id == ofmt->subtitle_codec)
4354 return AVERROR_PATCHWELCOME;
4357 int avformat_network_init(void)
4361 ff_network_inited_globally = 1;
4362 if ((ret = ff_network_init()) < 0)
4369 int avformat_network_deinit(void)
4378 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4379 uint64_t channel_layout, int32_t sample_rate,
4380 int32_t width, int32_t height)
4386 return AVERROR(EINVAL);
4389 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4391 if (channel_layout) {
4393 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4397 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4399 if (width || height) {
4401 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4403 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4405 return AVERROR(ENOMEM);
4406 bytestream_put_le32(&data, flags);
4408 bytestream_put_le32(&data, channels);
4410 bytestream_put_le64(&data, channel_layout);
4412 bytestream_put_le32(&data, sample_rate);
4413 if (width || height) {
4414 bytestream_put_le32(&data, width);
4415 bytestream_put_le32(&data, height);
4420 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4422 AVRational undef = {0, 1};
4423 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4424 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4425 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4427 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4428 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4429 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4430 stream_sample_aspect_ratio = undef;
4432 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4433 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4434 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4435 frame_sample_aspect_ratio = undef;
4437 if (stream_sample_aspect_ratio.num)
4438 return stream_sample_aspect_ratio;
4440 return frame_sample_aspect_ratio;
4443 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4445 AVRational fr = st->r_frame_rate;
4446 AVRational codec_fr = av_inv_q(st->codec->time_base);
4447 AVRational avg_fr = st->avg_frame_rate;
4449 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4450 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4455 if (st->codec->ticks_per_frame > 1) {
4456 codec_fr.den *= st->codec->ticks_per_frame;
4457 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4458 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4465 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4468 if (*spec <= '9' && *spec >= '0') /* opt:index */
4469 return strtol(spec, NULL, 0) == st->index;
4470 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4471 *spec == 't') { /* opt:[vasdt] */
4472 enum AVMediaType type;
4475 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4476 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4477 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4478 case 'd': type = AVMEDIA_TYPE_DATA; break;
4479 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4480 default: av_assert0(0);
4482 if (type != st->codec->codec_type)
4484 if (*spec++ == ':') { /* possibly followed by :index */
4485 int i, index = strtol(spec, NULL, 0);
4486 for (i = 0; i < s->nb_streams; i++)
4487 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4488 return i == st->index;
4492 } else if (*spec == 'p' && *(spec + 1) == ':') {
4496 prog_id = strtol(spec, &endptr, 0);
4497 for (i = 0; i < s->nb_programs; i++) {
4498 if (s->programs[i]->id != prog_id)
4501 if (*endptr++ == ':') {
4502 int stream_idx = strtol(endptr, NULL, 0);
4503 return stream_idx >= 0 &&
4504 stream_idx < s->programs[i]->nb_stream_indexes &&
4505 st->index == s->programs[i]->stream_index[stream_idx];
4508 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4509 if (st->index == s->programs[i]->stream_index[j])
4513 } else if (*spec == '#' ||
4514 (*spec == 'i' && *(spec + 1) == ':')) {
4517 spec += 1 + (*spec == 'i');
4518 stream_id = strtol(spec, &endptr, 0);
4520 return stream_id == st->id;
4521 } else if (!*spec) /* empty specifier, matches everything */
4524 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4525 return AVERROR(EINVAL);
4528 int ff_generate_avci_extradata(AVStream *st)
4530 static const uint8_t avci100_1080p_extradata[] = {
4532 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4533 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4534 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4535 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4536 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4537 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4538 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4539 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4540 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4542 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4545 static const uint8_t avci100_1080i_extradata[] = {
4547 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4548 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4549 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4550 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4551 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4552 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4553 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4554 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4555 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4556 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4557 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4559 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4562 static const uint8_t avci50_1080i_extradata[] = {
4564 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4565 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4566 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4567 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4568 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4569 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4570 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4571 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4572 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4573 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4574 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4576 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4579 static const uint8_t avci100_720p_extradata[] = {
4581 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4582 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4583 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4584 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4585 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4586 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4587 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4588 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4589 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4590 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4592 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4596 const uint8_t *data = NULL;
4599 if (st->codec->width == 1920) {
4600 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4601 data = avci100_1080p_extradata;
4602 size = sizeof(avci100_1080p_extradata);
4604 data = avci100_1080i_extradata;
4605 size = sizeof(avci100_1080i_extradata);
4607 } else if (st->codec->width == 1440) {
4608 data = avci50_1080i_extradata;
4609 size = sizeof(avci50_1080i_extradata);
4610 } else if (st->codec->width == 1280) {
4611 data = avci100_720p_extradata;
4612 size = sizeof(avci100_720p_extradata);
4618 av_freep(&st->codec->extradata);
4619 if (ff_alloc_extradata(st->codec, size))
4620 return AVERROR(ENOMEM);
4621 memcpy(st->codec->extradata, data, size);