2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
64 return LIBAVFORMAT_VERSION_INT;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts) {
81 return ts > (RELATIVE_TS_BASE - (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
94 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
95 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
96 timestamp < st->pts_wrap_reference)
97 return timestamp + (1ULL << st->pts_wrap_bits);
98 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99 timestamp >= st->pts_wrap_reference)
100 return timestamp - (1ULL << st->pts_wrap_bits);
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
113 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
115 if (st->codec->codec)
116 return st->codec->codec;
118 switch (st->codec->codec_type) {
119 case AVMEDIA_TYPE_VIDEO:
120 if (s->video_codec) return s->video_codec;
122 case AVMEDIA_TYPE_AUDIO:
123 if (s->audio_codec) return s->audio_codec;
125 case AVMEDIA_TYPE_SUBTITLE:
126 if (s->subtitle_codec) return s->subtitle_codec;
130 return avcodec_find_decoder(codec_id);
133 int av_format_get_probe_score(const AVFormatContext *s)
135 return s->probe_score;
138 /* an arbitrarily chosen "sane" max packet size -- 50M */
139 #define SANE_CHUNK_SIZE (50000000)
141 int ffio_limit(AVIOContext *s, int size)
143 if (s->maxsize>= 0) {
144 int64_t remaining= s->maxsize - avio_tell(s);
145 if (remaining < size) {
146 int64_t newsize = avio_size(s);
147 if (!s->maxsize || s->maxsize<newsize)
148 s->maxsize = newsize - !newsize;
149 remaining= s->maxsize - avio_tell(s);
150 remaining= FFMAX(remaining, 0);
153 if (s->maxsize>= 0 && remaining+1 < size) {
154 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
161 /* Read the data in sane-sized chunks and append to pkt.
162 * Return the number of bytes read or an error. */
163 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
165 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
166 int orig_size = pkt->size;
170 int prev_size = pkt->size;
173 /* When the caller requests a lot of data, limit it to the amount
174 * left in file or SANE_CHUNK_SIZE when it is not known. */
176 if (read_size > SANE_CHUNK_SIZE/10) {
177 read_size = ffio_limit(s, read_size);
178 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
180 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
183 ret = av_grow_packet(pkt, read_size);
187 ret = avio_read(s, pkt->data + prev_size, read_size);
188 if (ret != read_size) {
189 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
196 pkt->flags |= AV_PKT_FLAG_CORRUPT;
201 return pkt->size > orig_size ? pkt->size - orig_size : ret;
204 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
209 pkt->pos = avio_tell(s);
211 return append_packet_chunked(s, pkt, size);
214 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
217 return av_get_packet(s, pkt, size);
218 return append_packet_chunked(s, pkt, size);
221 int av_filename_number_test(const char *filename)
225 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
228 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
231 AVProbeData lpd = *pd;
232 AVInputFormat *fmt1 = NULL, *fmt;
233 int score, nodat = 0, score_max = 0;
234 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
237 lpd.buf = zerobuffer;
239 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
240 int id3len = ff_id3v2_tag_len(lpd.buf);
241 if (lpd.buf_size > id3len + 16) {
243 lpd.buf_size -= id3len;
249 while ((fmt1 = av_iformat_next(fmt1))) {
250 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
253 if (fmt1->read_probe) {
254 score = fmt1->read_probe(&lpd);
255 if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
256 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
257 } else if (fmt1->extensions) {
258 if (av_match_ext(lpd.filename, fmt1->extensions))
259 score = AVPROBE_SCORE_EXTENSION;
261 if (score > score_max) {
264 } else if (score == score_max)
268 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
269 *score_ret = score_max;
274 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
277 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
278 if (score_ret > *score_max) {
279 *score_max = score_ret;
285 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
288 return av_probe_input_format2(pd, is_opened, &score);
291 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
294 static const struct {
297 enum AVMediaType type;
299 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
300 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
301 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
302 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
303 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
304 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
305 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
306 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
307 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
308 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
312 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
314 if (fmt && st->request_probe <= score) {
316 av_log(s, AV_LOG_DEBUG,
317 "Probe with size=%d, packets=%d detected %s with score=%d\n",
318 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
320 for (i = 0; fmt_id_type[i].name; i++) {
321 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
322 st->codec->codec_id = fmt_id_type[i].id;
323 st->codec->codec_type = fmt_id_type[i].type;
331 /************************************************************/
332 /* input media file */
334 int av_demuxer_open(AVFormatContext *ic) {
337 if (ic->iformat->read_header) {
338 err = ic->iformat->read_header(ic);
343 if (ic->pb && !ic->data_offset)
344 ic->data_offset = avio_tell(ic->pb);
350 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
351 const char *filename, void *logctx,
352 unsigned int offset, unsigned int max_probe_size)
354 AVProbeData pd = { filename ? filename : "" };
357 int ret = 0, probe_size, buf_offset = 0;
361 max_probe_size = PROBE_BUF_MAX;
362 else if (max_probe_size > PROBE_BUF_MAX)
363 max_probe_size = PROBE_BUF_MAX;
364 else if (max_probe_size < PROBE_BUF_MIN) {
365 av_log(logctx, AV_LOG_ERROR,
366 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
367 return AVERROR(EINVAL);
370 if (offset >= max_probe_size)
371 return AVERROR(EINVAL);
373 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
374 if (!av_strcasecmp(mime_type, "audio/aacp")) {
375 *fmt = av_find_input_format("aac");
377 av_freep(&mime_type);
380 for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
381 probe_size = FFMIN(probe_size << 1,
382 FFMAX(max_probe_size, probe_size + 1))) {
383 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
385 /* Read probe data. */
386 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
388 if ((ret = avio_read(pb, buf + buf_offset,
389 probe_size - buf_offset)) < 0) {
390 /* Fail if error was not end of file, otherwise, lower score. */
391 if (ret != AVERROR_EOF) {
396 ret = 0; /* error was end of file, nothing read */
399 if (buf_offset < offset)
401 pd.buf_size = buf_offset - offset;
402 pd.buf = &buf[offset];
404 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
406 /* Guess file format. */
407 *fmt = av_probe_input_format2(&pd, 1, &score);
409 /* This can only be true in the last iteration. */
410 if (score <= AVPROBE_SCORE_RETRY) {
411 av_log(logctx, AV_LOG_WARNING,
412 "Format %s detected only with low score of %d, "
413 "misdetection possible!\n", (*fmt)->name, score);
415 av_log(logctx, AV_LOG_DEBUG,
416 "Format %s probed with size=%d and score=%d\n",
417 (*fmt)->name, probe_size, score);
419 FILE *f = fopen("probestat.tmp", "ab");
420 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
428 return AVERROR_INVALIDDATA;
431 /* Rewind. Reuse probe buffer to avoid seeking. */
432 ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
434 return ret < 0 ? ret : score;
437 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
438 const char *filename, void *logctx,
439 unsigned int offset, unsigned int max_probe_size)
441 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
442 return ret < 0 ? ret : 0;
445 /* Open input file and probe the format if necessary. */
446 static int init_input(AVFormatContext *s, const char *filename,
447 AVDictionary **options)
450 AVProbeData pd = { filename, NULL, 0 };
451 int score = AVPROBE_SCORE_RETRY;
454 s->flags |= AVFMT_FLAG_CUSTOM_IO;
456 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
458 else if (s->iformat->flags & AVFMT_NOFILE)
459 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
460 "will be ignored with AVFMT_NOFILE format.\n");
464 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
465 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
468 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
469 &s->interrupt_callback, options)) < 0)
473 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
477 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
478 AVPacketList **plast_pktl)
480 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
485 (*plast_pktl)->next = pktl;
487 *packet_buffer = pktl;
489 /* Add the packet in the buffered packet list. */
495 int avformat_queue_attached_pictures(AVFormatContext *s)
498 for (i = 0; i < s->nb_streams; i++)
499 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
500 s->streams[i]->discard < AVDISCARD_ALL) {
501 AVPacket copy = s->streams[i]->attached_pic;
502 copy.buf = av_buffer_ref(copy.buf);
504 return AVERROR(ENOMEM);
506 add_to_pktbuf(&s->raw_packet_buffer, ©,
507 &s->raw_packet_buffer_end);
512 int avformat_open_input(AVFormatContext **ps, const char *filename,
513 AVInputFormat *fmt, AVDictionary **options)
515 AVFormatContext *s = *ps;
517 AVDictionary *tmp = NULL;
518 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
520 if (!s && !(s = avformat_alloc_context()))
521 return AVERROR(ENOMEM);
523 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
524 return AVERROR(EINVAL);
530 av_dict_copy(&tmp, *options, 0);
532 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
535 if ((ret = init_input(s, filename, &tmp)) < 0)
537 s->probe_score = ret;
538 avio_skip(s->pb, s->skip_initial_bytes);
540 /* Check filename in case an image number is expected. */
541 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
542 if (!av_filename_number_test(filename)) {
543 ret = AVERROR(EINVAL);
548 s->duration = s->start_time = AV_NOPTS_VALUE;
549 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
551 /* Allocate private data. */
552 if (s->iformat->priv_data_size > 0) {
553 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
554 ret = AVERROR(ENOMEM);
557 if (s->iformat->priv_class) {
558 *(const AVClass **) s->priv_data = s->iformat->priv_class;
559 av_opt_set_defaults(s->priv_data);
560 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
565 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
567 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
569 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
570 if ((ret = s->iformat->read_header(s)) < 0)
573 if (id3v2_extra_meta) {
574 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
575 !strcmp(s->iformat->name, "tta")) {
576 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
579 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
581 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
583 if ((ret = avformat_queue_attached_pictures(s)) < 0)
586 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
587 s->data_offset = avio_tell(s->pb);
589 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
592 av_dict_free(options);
599 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
601 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
603 avformat_free_context(s);
608 /*******************************************************/
610 static void force_codec_ids(AVFormatContext *s, AVStream *st)
612 switch (st->codec->codec_type) {
613 case AVMEDIA_TYPE_VIDEO:
614 if (s->video_codec_id)
615 st->codec->codec_id = s->video_codec_id;
617 case AVMEDIA_TYPE_AUDIO:
618 if (s->audio_codec_id)
619 st->codec->codec_id = s->audio_codec_id;
621 case AVMEDIA_TYPE_SUBTITLE:
622 if (s->subtitle_codec_id)
623 st->codec->codec_id = s->subtitle_codec_id;
628 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
630 if (st->request_probe>0) {
631 AVProbeData *pd = &st->probe_data;
633 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
637 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
639 av_log(s, AV_LOG_WARNING,
640 "Failed to reallocate probe buffer for stream %d\n",
645 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
646 pd->buf_size += pkt->size;
647 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
650 st->probe_packets = 0;
652 av_log(s, AV_LOG_WARNING,
653 "nothing to probe for stream %d\n", st->index);
657 end= s->raw_packet_buffer_remaining_size <= 0
658 || st->probe_packets<= 0;
660 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
661 int score = set_codec_from_probe_data(s, st, pd);
662 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
666 st->request_probe = -1;
667 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
668 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
670 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
672 force_codec_ids(s, st);
678 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
680 int64_t ref = pkt->dts;
681 int i, pts_wrap_behavior;
682 int64_t pts_wrap_reference;
683 AVProgram *first_program;
685 if (ref == AV_NOPTS_VALUE)
687 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
689 ref &= (1LL << st->pts_wrap_bits)-1;
691 // reference time stamp should be 60 s before first time stamp
692 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
693 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
694 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
695 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
696 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
698 first_program = av_find_program_from_stream(s, NULL, stream_index);
700 if (!first_program) {
701 int default_stream_index = av_find_default_stream_index(s);
702 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
703 for (i = 0; i < s->nb_streams; i++) {
704 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
705 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
709 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
710 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
714 AVProgram *program = first_program;
716 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
717 pts_wrap_reference = program->pts_wrap_reference;
718 pts_wrap_behavior = program->pts_wrap_behavior;
721 program = av_find_program_from_stream(s, program, stream_index);
724 // update every program with differing pts_wrap_reference
725 program = first_program;
727 if (program->pts_wrap_reference != pts_wrap_reference) {
728 for (i = 0; i<program->nb_stream_indexes; i++) {
729 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
730 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
733 program->pts_wrap_reference = pts_wrap_reference;
734 program->pts_wrap_behavior = pts_wrap_behavior;
736 program = av_find_program_from_stream(s, program, stream_index);
742 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
748 AVPacketList *pktl = s->raw_packet_buffer;
752 st = s->streams[pkt->stream_index];
753 if (s->raw_packet_buffer_remaining_size <= 0)
754 if ((err = probe_codec(s, st, NULL)) < 0)
756 if (st->request_probe <= 0) {
757 s->raw_packet_buffer = pktl->next;
758 s->raw_packet_buffer_remaining_size += pkt->size;
767 ret = s->iformat->read_packet(s, pkt);
769 if (!pktl || ret == AVERROR(EAGAIN))
771 for (i = 0; i < s->nb_streams; i++) {
773 if (st->probe_packets)
774 if ((err = probe_codec(s, st, NULL)) < 0)
776 av_assert0(st->request_probe <= 0);
781 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
782 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
783 av_log(s, AV_LOG_WARNING,
784 "Dropped corrupted packet (stream = %d)\n",
790 if (pkt->stream_index >= (unsigned)s->nb_streams) {
791 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
795 st = s->streams[pkt->stream_index];
797 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
798 // correct first time stamps to negative values
799 if (!is_relative(st->first_dts))
800 st->first_dts = wrap_timestamp(st, st->first_dts);
801 if (!is_relative(st->start_time))
802 st->start_time = wrap_timestamp(st, st->start_time);
803 if (!is_relative(st->cur_dts))
804 st->cur_dts = wrap_timestamp(st, st->cur_dts);
807 pkt->dts = wrap_timestamp(st, pkt->dts);
808 pkt->pts = wrap_timestamp(st, pkt->pts);
810 force_codec_ids(s, st);
812 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
813 if (s->use_wallclock_as_timestamps)
814 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
816 if (!pktl && st->request_probe <= 0)
819 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
820 s->raw_packet_buffer_remaining_size -= pkt->size;
822 if ((err = probe_codec(s, st, pkt)) < 0)
827 #if FF_API_READ_PACKET
828 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
830 return ff_read_packet(s, pkt);
835 /**********************************************************/
837 static int determinable_frame_size(AVCodecContext *avctx)
839 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
840 avctx->codec_id == AV_CODEC_ID_MP1 ||
841 avctx->codec_id == AV_CODEC_ID_MP2 ||
842 avctx->codec_id == AV_CODEC_ID_MP3/* ||
843 avctx->codec_id == AV_CODEC_ID_CELT*/)
849 * Get the number of samples of an audio frame. Return -1 on error.
851 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
855 /* give frame_size priority if demuxing */
856 if (!mux && enc->frame_size > 1)
857 return enc->frame_size;
859 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
862 /* Fall back on using frame_size if muxing. */
863 if (enc->frame_size > 1)
864 return enc->frame_size;
866 //For WMA we currently have no other means to calculate duration thus we
867 //do it here by assuming CBR, which is true for all known cases.
868 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
869 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
870 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
877 * Return the frame duration in seconds. Return 0 if not available.
879 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
880 AVCodecParserContext *pc, AVPacket *pkt)
886 switch (st->codec->codec_type) {
887 case AVMEDIA_TYPE_VIDEO:
888 if (st->r_frame_rate.num && !pc) {
889 *pnum = st->r_frame_rate.den;
890 *pden = st->r_frame_rate.num;
891 } else if (st->time_base.num * 1000LL > st->time_base.den) {
892 *pnum = st->time_base.num;
893 *pden = st->time_base.den;
894 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
895 *pnum = st->codec->time_base.num;
896 *pden = st->codec->time_base.den;
897 if (pc && pc->repeat_pict) {
898 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
899 *pden /= 1 + pc->repeat_pict;
901 *pnum *= 1 + pc->repeat_pict;
903 /* If this codec can be interlaced or progressive then we need
904 * a parser to compute duration of a packet. Thus if we have
905 * no parser in such case leave duration undefined. */
906 if (st->codec->ticks_per_frame > 1 && !pc)
910 case AVMEDIA_TYPE_AUDIO:
911 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
912 if (frame_size <= 0 || st->codec->sample_rate <= 0)
915 *pden = st->codec->sample_rate;
922 static int is_intra_only(AVCodecContext *enc) {
923 const AVCodecDescriptor *desc;
925 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
928 desc = av_codec_get_codec_descriptor(enc);
930 desc = avcodec_descriptor_get(enc->codec_id);
931 av_codec_set_codec_descriptor(enc, desc);
934 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
938 static int has_decode_delay_been_guessed(AVStream *st)
940 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
941 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
943 #if CONFIG_H264_DECODER
944 if (st->codec->has_b_frames &&
945 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
948 if (st->codec->has_b_frames<3)
949 return st->nb_decoded_frames >= 7;
950 else if (st->codec->has_b_frames<4)
951 return st->nb_decoded_frames >= 18;
953 return st->nb_decoded_frames >= 20;
956 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
960 if (pktl == s->packet_buffer_end)
961 return s->parse_queue;
965 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
966 int64_t dts, int64_t pts, AVPacket *pkt)
968 AVStream *st = s->streams[stream_index];
969 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
970 int64_t pts_buffer[MAX_REORDER_DELAY+1];
974 if (st->first_dts != AV_NOPTS_VALUE ||
975 dts == AV_NOPTS_VALUE ||
976 st->cur_dts == AV_NOPTS_VALUE ||
980 delay = st->codec->has_b_frames;
981 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
983 shift = st->first_dts - RELATIVE_TS_BASE;
985 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
986 pts_buffer[i] = AV_NOPTS_VALUE;
988 if (is_relative(pts))
991 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
992 if (pktl->pkt.stream_index != stream_index)
994 if (is_relative(pktl->pkt.pts))
995 pktl->pkt.pts += shift;
997 if (is_relative(pktl->pkt.dts))
998 pktl->pkt.dts += shift;
1000 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1001 st->start_time = pktl->pkt.pts;
1003 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1004 pts_buffer[0] = pktl->pkt.pts;
1005 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1006 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1007 if (pktl->pkt.dts == AV_NOPTS_VALUE)
1008 pktl->pkt.dts = pts_buffer[0];
1012 if (st->start_time == AV_NOPTS_VALUE)
1013 st->start_time = pts;
1016 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1017 int stream_index, int duration)
1019 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1020 int64_t cur_dts = RELATIVE_TS_BASE;
1022 if (st->first_dts != AV_NOPTS_VALUE) {
1023 if (st->update_initial_durations_done)
1025 st->update_initial_durations_done = 1;
1026 cur_dts = st->first_dts;
1027 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1028 if (pktl->pkt.stream_index == stream_index) {
1029 if (pktl->pkt.pts != pktl->pkt.dts ||
1030 pktl->pkt.dts != AV_NOPTS_VALUE ||
1033 cur_dts -= duration;
1036 if (pktl && pktl->pkt.dts != st->first_dts) {
1037 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1038 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1042 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1045 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1046 st->first_dts = cur_dts;
1047 } else if (st->cur_dts != RELATIVE_TS_BASE)
1050 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1051 if (pktl->pkt.stream_index != stream_index)
1053 if (pktl->pkt.pts == pktl->pkt.dts &&
1054 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1055 !pktl->pkt.duration) {
1056 pktl->pkt.dts = cur_dts;
1057 if (!st->codec->has_b_frames)
1058 pktl->pkt.pts = cur_dts;
1059 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1060 pktl->pkt.duration = duration;
1063 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1066 st->cur_dts = cur_dts;
1069 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1070 AVCodecParserContext *pc, AVPacket *pkt)
1072 int num, den, presentation_delayed, delay, i;
1074 AVRational duration;
1076 if (s->flags & AVFMT_FLAG_NOFILLIN)
1079 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1080 pkt->dts = AV_NOPTS_VALUE;
1082 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1083 && !st->codec->has_b_frames)
1084 //FIXME Set low_delay = 0 when has_b_frames = 1
1085 st->codec->has_b_frames = 1;
1087 /* do we have a video B-frame ? */
1088 delay = st->codec->has_b_frames;
1089 presentation_delayed = 0;
1091 /* XXX: need has_b_frame, but cannot get it if the codec is
1092 * not initialized */
1094 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1095 presentation_delayed = 1;
1097 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1098 st->pts_wrap_bits < 63 &&
1099 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1100 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1101 pkt->dts -= 1LL << st->pts_wrap_bits;
1103 pkt->pts += 1LL << st->pts_wrap_bits;
1106 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1107 * We take the conservative approach and discard both.
1108 * Note: If this is misbehaving for an H.264 file, then possibly
1109 * presentation_delayed is not set correctly. */
1110 if (delay == 1 && pkt->dts == pkt->pts &&
1111 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1112 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1113 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1114 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1115 pkt->dts = AV_NOPTS_VALUE;
1118 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1119 if (pkt->duration == 0) {
1120 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1122 duration = (AVRational) {num, den};
1123 pkt->duration = av_rescale_rnd(1,
1124 num * (int64_t) st->time_base.den,
1125 den * (int64_t) st->time_base.num,
1130 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1131 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1133 /* Correct timestamps with byte offset if demuxers only have timestamps
1134 * on packet boundaries */
1135 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1136 /* this will estimate bitrate based on this frame's duration and size */
1137 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1138 if (pkt->pts != AV_NOPTS_VALUE)
1140 if (pkt->dts != AV_NOPTS_VALUE)
1144 /* This may be redundant, but it should not hurt. */
1145 if (pkt->dts != AV_NOPTS_VALUE &&
1146 pkt->pts != AV_NOPTS_VALUE &&
1147 pkt->pts > pkt->dts)
1148 presentation_delayed = 1;
1151 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1152 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1153 pkt->stream_index, pc, pkt->duration);
1154 /* Interpolate PTS and DTS if they are not present. We skip H264
1155 * currently because delay and has_b_frames are not reliably set. */
1156 if ((delay == 0 || (delay == 1 && pc)) &&
1157 st->codec->codec_id != AV_CODEC_ID_H264 &&
1158 st->codec->codec_id != AV_CODEC_ID_HEVC) {
1159 if (presentation_delayed) {
1160 /* DTS = decompression timestamp */
1161 /* PTS = presentation timestamp */
1162 if (pkt->dts == AV_NOPTS_VALUE)
1163 pkt->dts = st->last_IP_pts;
1164 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1165 if (pkt->dts == AV_NOPTS_VALUE)
1166 pkt->dts = st->cur_dts;
1168 /* This is tricky: the dts must be incremented by the duration
1169 * of the frame we are displaying, i.e. the last I- or P-frame. */
1170 if (st->last_IP_duration == 0)
1171 st->last_IP_duration = pkt->duration;
1172 if (pkt->dts != AV_NOPTS_VALUE)
1173 st->cur_dts = pkt->dts + st->last_IP_duration;
1174 st->last_IP_duration = pkt->duration;
1175 st->last_IP_pts = pkt->pts;
1176 /* Cannot compute PTS if not present (we can compute it only
1177 * by knowing the future. */
1178 } else if (pkt->pts != AV_NOPTS_VALUE ||
1179 pkt->dts != AV_NOPTS_VALUE ||
1182 /* presentation is not delayed : PTS and DTS are the same */
1183 if (pkt->pts == AV_NOPTS_VALUE)
1184 pkt->pts = pkt->dts;
1185 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1187 if (pkt->pts == AV_NOPTS_VALUE)
1188 pkt->pts = st->cur_dts;
1189 pkt->dts = pkt->pts;
1190 if (pkt->pts != AV_NOPTS_VALUE)
1191 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1195 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1196 st->pts_buffer[0] = pkt->pts;
1197 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1198 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1199 if (pkt->dts == AV_NOPTS_VALUE)
1200 pkt->dts = st->pts_buffer[0];
1202 // We skipped it above so we try here.
1203 if (st->codec->codec_id == AV_CODEC_ID_H264 ||
1204 st->codec->codec_id == AV_CODEC_ID_HEVC)
1205 // This should happen on the first packet
1206 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1207 if (pkt->dts > st->cur_dts)
1208 st->cur_dts = pkt->dts;
1210 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1211 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1214 if (is_intra_only(st->codec))
1215 pkt->flags |= AV_PKT_FLAG_KEY;
1217 pkt->convergence_duration = pc->convergence_duration;
1220 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1223 AVPacketList *pktl = *pkt_buf;
1224 *pkt_buf = pktl->next;
1225 av_free_packet(&pktl->pkt);
1228 *pkt_buf_end = NULL;
1232 * Parse a packet, add all split parts to parse_queue.
1234 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1236 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1238 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1239 AVStream *st = s->streams[stream_index];
1240 uint8_t *data = pkt ? pkt->data : NULL;
1241 int size = pkt ? pkt->size : 0;
1242 int ret = 0, got_output = 0;
1245 av_init_packet(&flush_pkt);
1248 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1249 // preserve 0-size sync packets
1250 compute_pkt_fields(s, st, st->parser, pkt);
1253 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1256 av_init_packet(&out_pkt);
1257 len = av_parser_parse2(st->parser, st->codec,
1258 &out_pkt.data, &out_pkt.size, data, size,
1259 pkt->pts, pkt->dts, pkt->pos);
1261 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1263 /* increment read pointer */
1267 got_output = !!out_pkt.size;
1272 if (pkt->side_data) {
1273 out_pkt.side_data = pkt->side_data;
1274 out_pkt.side_data_elems = pkt->side_data_elems;
1275 pkt->side_data = NULL;
1276 pkt->side_data_elems = 0;
1279 /* set the duration */
1280 out_pkt.duration = 0;
1281 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1282 if (st->codec->sample_rate > 0) {
1284 av_rescale_q_rnd(st->parser->duration,
1285 (AVRational) { 1, st->codec->sample_rate },
1289 } else if (st->codec->time_base.num != 0 &&
1290 st->codec->time_base.den != 0) {
1291 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1292 st->codec->time_base,
1297 out_pkt.stream_index = st->index;
1298 out_pkt.pts = st->parser->pts;
1299 out_pkt.dts = st->parser->dts;
1300 out_pkt.pos = st->parser->pos;
1302 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1303 out_pkt.pos = st->parser->frame_offset;
1305 if (st->parser->key_frame == 1 ||
1306 (st->parser->key_frame == -1 &&
1307 st->parser->pict_type == AV_PICTURE_TYPE_I))
1308 out_pkt.flags |= AV_PKT_FLAG_KEY;
1310 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1311 out_pkt.flags |= AV_PKT_FLAG_KEY;
1313 compute_pkt_fields(s, st, st->parser, &out_pkt);
1315 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1316 out_pkt.buf = pkt->buf;
1318 #if FF_API_DESTRUCT_PACKET
1319 FF_DISABLE_DEPRECATION_WARNINGS
1320 out_pkt.destruct = pkt->destruct;
1321 pkt->destruct = NULL;
1322 FF_ENABLE_DEPRECATION_WARNINGS
1325 if ((ret = av_dup_packet(&out_pkt)) < 0)
1328 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1329 av_free_packet(&out_pkt);
1330 ret = AVERROR(ENOMEM);
1335 /* end of the stream => close and free the parser */
1336 if (pkt == &flush_pkt) {
1337 av_parser_close(st->parser);
1342 av_free_packet(pkt);
1346 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1347 AVPacketList **pkt_buffer_end,
1351 av_assert0(*pkt_buffer);
1354 *pkt_buffer = pktl->next;
1356 *pkt_buffer_end = NULL;
1361 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1363 int ret = 0, i, got_packet = 0;
1365 av_init_packet(pkt);
1367 while (!got_packet && !s->parse_queue) {
1371 /* read next packet */
1372 ret = ff_read_packet(s, &cur_pkt);
1374 if (ret == AVERROR(EAGAIN))
1376 /* flush the parsers */
1377 for (i = 0; i < s->nb_streams; i++) {
1379 if (st->parser && st->need_parsing)
1380 parse_packet(s, NULL, st->index);
1382 /* all remaining packets are now in parse_queue =>
1383 * really terminate parsing */
1387 st = s->streams[cur_pkt.stream_index];
1389 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1390 cur_pkt.dts != AV_NOPTS_VALUE &&
1391 cur_pkt.pts < cur_pkt.dts) {
1392 av_log(s, AV_LOG_WARNING,
1393 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1394 cur_pkt.stream_index,
1395 av_ts2str(cur_pkt.pts),
1396 av_ts2str(cur_pkt.dts),
1399 if (s->debug & FF_FDEBUG_TS)
1400 av_log(s, AV_LOG_DEBUG,
1401 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1402 cur_pkt.stream_index,
1403 av_ts2str(cur_pkt.pts),
1404 av_ts2str(cur_pkt.dts),
1405 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1407 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1408 st->parser = av_parser_init(st->codec->codec_id);
1410 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1411 "%s, packets or times may be invalid.\n",
1412 avcodec_get_name(st->codec->codec_id));
1413 /* no parser available: just output the raw packets */
1414 st->need_parsing = AVSTREAM_PARSE_NONE;
1415 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1416 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1417 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1418 st->parser->flags |= PARSER_FLAG_ONCE;
1419 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1420 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1423 if (!st->need_parsing || !st->parser) {
1424 /* no parsing needed: we just output the packet as is */
1426 compute_pkt_fields(s, st, NULL, pkt);
1427 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1428 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1429 ff_reduce_index(s, st->index);
1430 av_add_index_entry(st, pkt->pos, pkt->dts,
1431 0, 0, AVINDEX_KEYFRAME);
1434 } else if (st->discard < AVDISCARD_ALL) {
1435 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1439 av_free_packet(&cur_pkt);
1441 if (pkt->flags & AV_PKT_FLAG_KEY)
1442 st->skip_to_keyframe = 0;
1443 if (st->skip_to_keyframe) {
1444 av_free_packet(&cur_pkt);
1452 if (!got_packet && s->parse_queue)
1453 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1456 AVStream *st = s->streams[pkt->stream_index];
1457 if (st->skip_samples) {
1458 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1460 AV_WL32(p, st->skip_samples);
1461 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1463 st->skip_samples = 0;
1467 if (ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1468 av_packet_merge_side_data(pkt);
1470 if (s->debug & FF_FDEBUG_TS)
1471 av_log(s, AV_LOG_DEBUG,
1472 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1473 "size=%d, duration=%d, flags=%d\n",
1475 av_ts2str(pkt->pts),
1476 av_ts2str(pkt->dts),
1477 pkt->size, pkt->duration, pkt->flags);
1482 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1484 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1490 ret = s->packet_buffer
1491 ? read_from_packet_buffer(&s->packet_buffer,
1492 &s->packet_buffer_end, pkt)
1493 : read_frame_internal(s, pkt);
1500 AVPacketList *pktl = s->packet_buffer;
1503 AVPacket *next_pkt = &pktl->pkt;
1505 if (next_pkt->dts != AV_NOPTS_VALUE) {
1506 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1507 // last dts seen for this stream. if any of packets following
1508 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1509 int64_t last_dts = next_pkt->dts;
1510 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1511 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1512 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1513 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1515 next_pkt->pts = pktl->pkt.dts;
1517 if (last_dts != AV_NOPTS_VALUE) {
1518 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1519 last_dts = pktl->pkt.dts;
1524 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1525 // Fixing the last reference frame had none pts issue (For MXF etc).
1526 // We only do this when
1528 // 2. we are not able to resolve a pts value for current packet.
1529 // 3. the packets for this stream at the end of the files had valid dts.
1530 next_pkt->pts = last_dts + next_pkt->duration;
1532 pktl = s->packet_buffer;
1535 /* read packet from packet buffer, if there is data */
1536 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1537 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1538 ret = read_from_packet_buffer(&s->packet_buffer,
1539 &s->packet_buffer_end, pkt);
1544 ret = read_frame_internal(s, pkt);
1546 if (pktl && ret != AVERROR(EAGAIN)) {
1553 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1554 &s->packet_buffer_end)) < 0)
1555 return AVERROR(ENOMEM);
1560 st = s->streams[pkt->stream_index];
1561 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1562 ff_reduce_index(s, st->index);
1563 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1566 if (is_relative(pkt->dts))
1567 pkt->dts -= RELATIVE_TS_BASE;
1568 if (is_relative(pkt->pts))
1569 pkt->pts -= RELATIVE_TS_BASE;
1574 /* XXX: suppress the packet queue */
1575 static void flush_packet_queue(AVFormatContext *s)
1577 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1578 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1579 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1581 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1584 /*******************************************************/
1587 int av_find_default_stream_index(AVFormatContext *s)
1589 int first_audio_index = -1;
1593 if (s->nb_streams <= 0)
1595 for (i = 0; i < s->nb_streams; i++) {
1597 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1598 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1601 if (first_audio_index < 0 &&
1602 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1603 first_audio_index = i;
1605 return first_audio_index >= 0 ? first_audio_index : 0;
1608 /** Flush the frame reader. */
1609 void ff_read_frame_flush(AVFormatContext *s)
1614 flush_packet_queue(s);
1616 /* Reset read state for each stream. */
1617 for (i = 0; i < s->nb_streams; i++) {
1621 av_parser_close(st->parser);
1624 st->last_IP_pts = AV_NOPTS_VALUE;
1625 if (st->first_dts == AV_NOPTS_VALUE)
1626 st->cur_dts = RELATIVE_TS_BASE;
1628 /* We set the current DTS to an unspecified origin. */
1629 st->cur_dts = AV_NOPTS_VALUE;
1631 st->probe_packets = MAX_PROBE_PACKETS;
1633 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1634 st->pts_buffer[j] = AV_NOPTS_VALUE;
1638 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1642 for (i = 0; i < s->nb_streams; i++) {
1643 AVStream *st = s->streams[i];
1646 av_rescale(timestamp,
1647 st->time_base.den * (int64_t) ref_st->time_base.num,
1648 st->time_base.num * (int64_t) ref_st->time_base.den);
1652 void ff_reduce_index(AVFormatContext *s, int stream_index)
1654 AVStream *st = s->streams[stream_index];
1655 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1657 if ((unsigned) st->nb_index_entries >= max_entries) {
1659 for (i = 0; 2 * i < st->nb_index_entries; i++)
1660 st->index_entries[i] = st->index_entries[2 * i];
1661 st->nb_index_entries = i;
1665 int ff_add_index_entry(AVIndexEntry **index_entries,
1666 int *nb_index_entries,
1667 unsigned int *index_entries_allocated_size,
1668 int64_t pos, int64_t timestamp,
1669 int size, int distance, int flags)
1671 AVIndexEntry *entries, *ie;
1674 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1677 if (timestamp == AV_NOPTS_VALUE)
1678 return AVERROR(EINVAL);
1680 if (size < 0 || size > 0x3FFFFFFF)
1681 return AVERROR(EINVAL);
1683 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1684 timestamp -= RELATIVE_TS_BASE;
1686 entries = av_fast_realloc(*index_entries,
1687 index_entries_allocated_size,
1688 (*nb_index_entries + 1) *
1689 sizeof(AVIndexEntry));
1693 *index_entries = entries;
1695 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1696 timestamp, AVSEEK_FLAG_ANY);
1699 index = (*nb_index_entries)++;
1700 ie = &entries[index];
1701 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1703 ie = &entries[index];
1704 if (ie->timestamp != timestamp) {
1705 if (ie->timestamp <= timestamp)
1707 memmove(entries + index + 1, entries + index,
1708 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1709 (*nb_index_entries)++;
1710 } else if (ie->pos == pos && distance < ie->min_distance)
1711 // do not reduce the distance
1712 distance = ie->min_distance;
1716 ie->timestamp = timestamp;
1717 ie->min_distance = distance;
1724 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1725 int size, int distance, int flags)
1727 timestamp = wrap_timestamp(st, timestamp);
1728 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1729 &st->index_entries_allocated_size, pos,
1730 timestamp, size, distance, flags);
1733 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1734 int64_t wanted_timestamp, int flags)
1742 // Optimize appending index entries at the end.
1743 if (b && entries[b - 1].timestamp < wanted_timestamp)
1748 timestamp = entries[m].timestamp;
1749 if (timestamp >= wanted_timestamp)
1751 if (timestamp <= wanted_timestamp)
1754 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1756 if (!(flags & AVSEEK_FLAG_ANY))
1757 while (m >= 0 && m < nb_entries &&
1758 !(entries[m].flags & AVINDEX_KEYFRAME))
1759 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1761 if (m == nb_entries)
1766 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1768 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1769 wanted_timestamp, flags);
1772 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1773 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1775 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1776 if (stream_index >= 0)
1777 ts = wrap_timestamp(s->streams[stream_index], ts);
1781 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1782 int64_t target_ts, int flags)
1784 AVInputFormat *avif = s->iformat;
1785 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1786 int64_t ts_min, ts_max, ts;
1791 if (stream_index < 0)
1794 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1797 ts_min = AV_NOPTS_VALUE;
1798 pos_limit = -1; // GCC falsely says it may be uninitialized.
1800 st = s->streams[stream_index];
1801 if (st->index_entries) {
1804 /* FIXME: Whole function must be checked for non-keyframe entries in
1805 * index case, especially read_timestamp(). */
1806 index = av_index_search_timestamp(st, target_ts,
1807 flags | AVSEEK_FLAG_BACKWARD);
1808 index = FFMAX(index, 0);
1809 e = &st->index_entries[index];
1811 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1813 ts_min = e->timestamp;
1814 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1815 pos_min, av_ts2str(ts_min));
1817 av_assert1(index == 0);
1820 index = av_index_search_timestamp(st, target_ts,
1821 flags & ~AVSEEK_FLAG_BACKWARD);
1822 av_assert0(index < st->nb_index_entries);
1824 e = &st->index_entries[index];
1825 av_assert1(e->timestamp >= target_ts);
1827 ts_max = e->timestamp;
1828 pos_limit = pos_max - e->min_distance;
1829 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1830 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1834 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1835 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1840 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1843 ff_read_frame_flush(s);
1844 ff_update_cur_dts(s, st, ts);
1849 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1850 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1852 int64_t step = 1024;
1853 int64_t limit, ts_max;
1854 int64_t filesize = avio_size(s->pb);
1855 int64_t pos_max = filesize - 1;
1858 pos_max = FFMAX(0, (pos_max) - step);
1859 ts_max = ff_read_timestamp(s, stream_index,
1860 &pos_max, limit, read_timestamp);
1862 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1863 if (ts_max == AV_NOPTS_VALUE)
1867 int64_t tmp_pos = pos_max + 1;
1868 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1869 &tmp_pos, INT64_MAX, read_timestamp);
1870 if (tmp_ts == AV_NOPTS_VALUE)
1872 av_assert0(tmp_pos > pos_max);
1875 if (tmp_pos >= filesize)
1887 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1888 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1889 int64_t ts_min, int64_t ts_max,
1890 int flags, int64_t *ts_ret,
1891 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1892 int64_t *, int64_t))
1899 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1901 if (ts_min == AV_NOPTS_VALUE) {
1902 pos_min = s->data_offset;
1903 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1904 if (ts_min == AV_NOPTS_VALUE)
1908 if (ts_min >= target_ts) {
1913 if (ts_max == AV_NOPTS_VALUE) {
1914 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1916 pos_limit = pos_max;
1919 if (ts_max <= target_ts) {
1924 if (ts_min > ts_max)
1926 else if (ts_min == ts_max)
1927 pos_limit = pos_min;
1930 while (pos_min < pos_limit) {
1932 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1933 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1934 assert(pos_limit <= pos_max);
1936 if (no_change == 0) {
1937 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1938 // interpolate position (better than dichotomy)
1939 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1941 pos_min - approximate_keyframe_distance;
1942 } else if (no_change == 1) {
1943 // bisection if interpolation did not change min / max pos last time
1944 pos = (pos_min + pos_limit) >> 1;
1946 /* linear search if bisection failed, can only happen if there
1947 * are very few or no keyframes between min/max */
1952 else if (pos > pos_limit)
1956 // May pass pos_limit instead of -1.
1957 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1962 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1963 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1964 pos_min, pos, pos_max,
1965 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1966 pos_limit, start_pos, no_change);
1967 if (ts == AV_NOPTS_VALUE) {
1968 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1971 assert(ts != AV_NOPTS_VALUE);
1972 if (target_ts <= ts) {
1973 pos_limit = start_pos - 1;
1977 if (target_ts >= ts) {
1983 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1984 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1987 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1989 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1990 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1991 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1997 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1998 int64_t pos, int flags)
2000 int64_t pos_min, pos_max;
2002 pos_min = s->data_offset;
2003 pos_max = avio_size(s->pb) - 1;
2007 else if (pos > pos_max)
2010 avio_seek(s->pb, pos, SEEK_SET);
2012 s->io_repositioned = 1;
2017 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2018 int64_t timestamp, int flags)
2025 st = s->streams[stream_index];
2027 index = av_index_search_timestamp(st, timestamp, flags);
2029 if (index < 0 && st->nb_index_entries &&
2030 timestamp < st->index_entries[0].timestamp)
2033 if (index < 0 || index == st->nb_index_entries - 1) {
2037 if (st->nb_index_entries) {
2038 av_assert0(st->index_entries);
2039 ie = &st->index_entries[st->nb_index_entries - 1];
2040 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2042 ff_update_cur_dts(s, st, ie->timestamp);
2044 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2050 read_status = av_read_frame(s, &pkt);
2051 } while (read_status == AVERROR(EAGAIN));
2052 if (read_status < 0)
2054 av_free_packet(&pkt);
2055 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2056 if (pkt.flags & AV_PKT_FLAG_KEY)
2058 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2059 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2064 index = av_index_search_timestamp(st, timestamp, flags);
2069 ff_read_frame_flush(s);
2070 if (s->iformat->read_seek)
2071 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2073 ie = &st->index_entries[index];
2074 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2076 ff_update_cur_dts(s, st, ie->timestamp);
2081 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2082 int64_t timestamp, int flags)
2087 if (flags & AVSEEK_FLAG_BYTE) {
2088 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2090 ff_read_frame_flush(s);
2091 return seek_frame_byte(s, stream_index, timestamp, flags);
2094 if (stream_index < 0) {
2095 stream_index = av_find_default_stream_index(s);
2096 if (stream_index < 0)
2099 st = s->streams[stream_index];
2100 /* timestamp for default must be expressed in AV_TIME_BASE units */
2101 timestamp = av_rescale(timestamp, st->time_base.den,
2102 AV_TIME_BASE * (int64_t) st->time_base.num);
2105 /* first, we try the format specific seek */
2106 if (s->iformat->read_seek) {
2107 ff_read_frame_flush(s);
2108 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2114 if (s->iformat->read_timestamp &&
2115 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2116 ff_read_frame_flush(s);
2117 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2118 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2119 ff_read_frame_flush(s);
2120 return seek_frame_generic(s, stream_index, timestamp, flags);
2125 int av_seek_frame(AVFormatContext *s, int stream_index,
2126 int64_t timestamp, int flags)
2130 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2131 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2132 if ((flags & AVSEEK_FLAG_BACKWARD))
2136 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2137 flags & ~AVSEEK_FLAG_BACKWARD);
2140 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2143 ret = avformat_queue_attached_pictures(s);
2148 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2149 int64_t ts, int64_t max_ts, int flags)
2151 if (min_ts > ts || max_ts < ts)
2153 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2154 return AVERROR(EINVAL);
2157 flags |= AVSEEK_FLAG_ANY;
2158 flags &= ~AVSEEK_FLAG_BACKWARD;
2160 if (s->iformat->read_seek2) {
2162 ff_read_frame_flush(s);
2164 if (stream_index == -1 && s->nb_streams == 1) {
2165 AVRational time_base = s->streams[0]->time_base;
2166 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2167 min_ts = av_rescale_rnd(min_ts, time_base.den,
2168 time_base.num * (int64_t)AV_TIME_BASE,
2169 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2170 max_ts = av_rescale_rnd(max_ts, time_base.den,
2171 time_base.num * (int64_t)AV_TIME_BASE,
2172 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2175 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2179 ret = avformat_queue_attached_pictures(s);
2183 if (s->iformat->read_timestamp) {
2184 // try to seek via read_timestamp()
2187 // Fall back on old API if new is not implemented but old is.
2188 // Note the old API has somewhat different semantics.
2189 if (s->iformat->read_seek || 1) {
2190 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2191 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2192 if (ret<0 && ts != min_ts && max_ts != ts) {
2193 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2195 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2200 // try some generic seek like seek_frame_generic() but with new ts semantics
2201 return -1; //unreachable
2204 /*******************************************************/
2207 * Return TRUE if the stream has accurate duration in any stream.
2209 * @return TRUE if the stream has accurate duration for at least one component.
2211 static int has_duration(AVFormatContext *ic)
2216 for (i = 0; i < ic->nb_streams; i++) {
2217 st = ic->streams[i];
2218 if (st->duration != AV_NOPTS_VALUE)
2221 if (ic->duration != AV_NOPTS_VALUE)
2227 * Estimate the stream timings from the one of each components.
2229 * Also computes the global bitrate if possible.
2231 static void update_stream_timings(AVFormatContext *ic)
2233 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2234 int64_t duration, duration1, filesize;
2239 start_time = INT64_MAX;
2240 start_time_text = INT64_MAX;
2241 end_time = INT64_MIN;
2242 duration = INT64_MIN;
2243 for (i = 0; i < ic->nb_streams; i++) {
2244 st = ic->streams[i];
2245 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2246 start_time1 = av_rescale_q(st->start_time, st->time_base,
2248 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2249 if (start_time1 < start_time_text)
2250 start_time_text = start_time1;
2252 start_time = FFMIN(start_time, start_time1);
2253 end_time1 = AV_NOPTS_VALUE;
2254 if (st->duration != AV_NOPTS_VALUE) {
2255 end_time1 = start_time1 +
2256 av_rescale_q(st->duration, st->time_base,
2258 end_time = FFMAX(end_time, end_time1);
2260 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2261 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2262 p->start_time = start_time1;
2263 if (p->end_time < end_time1)
2264 p->end_time = end_time1;
2267 if (st->duration != AV_NOPTS_VALUE) {
2268 duration1 = av_rescale_q(st->duration, st->time_base,
2270 duration = FFMAX(duration, duration1);
2273 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2274 start_time = start_time_text;
2275 else if (start_time > start_time_text)
2276 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2278 if (start_time != INT64_MAX) {
2279 ic->start_time = start_time;
2280 if (end_time != INT64_MIN) {
2281 if (ic->nb_programs) {
2282 for (i = 0; i < ic->nb_programs; i++) {
2283 p = ic->programs[i];
2284 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2285 duration = FFMAX(duration, p->end_time - p->start_time);
2288 duration = FFMAX(duration, end_time - start_time);
2291 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2292 ic->duration = duration;
2294 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2295 /* compute the bitrate */
2296 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2297 (double) ic->duration;
2298 if (bitrate >= 0 && bitrate <= INT_MAX)
2299 ic->bit_rate = bitrate;
2303 static void fill_all_stream_timings(AVFormatContext *ic)
2308 update_stream_timings(ic);
2309 for (i = 0; i < ic->nb_streams; i++) {
2310 st = ic->streams[i];
2311 if (st->start_time == AV_NOPTS_VALUE) {
2312 if (ic->start_time != AV_NOPTS_VALUE)
2313 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2315 if (ic->duration != AV_NOPTS_VALUE)
2316 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2322 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2324 int64_t filesize, duration;
2325 int i, show_warning = 0;
2328 /* if bit_rate is already set, we believe it */
2329 if (ic->bit_rate <= 0) {
2331 for (i = 0; i < ic->nb_streams; i++) {
2332 st = ic->streams[i];
2333 if (st->codec->bit_rate > 0) {
2334 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2338 bit_rate += st->codec->bit_rate;
2341 ic->bit_rate = bit_rate;
2344 /* if duration is already set, we believe it */
2345 if (ic->duration == AV_NOPTS_VALUE &&
2346 ic->bit_rate != 0) {
2347 filesize = ic->pb ? avio_size(ic->pb) : 0;
2349 for (i = 0; i < ic->nb_streams; i++) {
2350 st = ic->streams[i];
2351 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2352 && st->duration == AV_NOPTS_VALUE) {
2353 duration = av_rescale(8 * filesize, st->time_base.den,
2355 (int64_t) st->time_base.num);
2356 st->duration = duration;
2363 av_log(ic, AV_LOG_WARNING,
2364 "Estimating duration from bitrate, this may be inaccurate\n");
2367 #define DURATION_MAX_READ_SIZE 250000LL
2368 #define DURATION_MAX_RETRY 4
2370 /* only usable for MPEG-PS streams */
2371 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2373 AVPacket pkt1, *pkt = &pkt1;
2375 int read_size, i, ret;
2377 int64_t filesize, offset, duration;
2380 /* flush packet queue */
2381 flush_packet_queue(ic);
2383 for (i = 0; i < ic->nb_streams; i++) {
2384 st = ic->streams[i];
2385 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2386 av_log(st->codec, AV_LOG_WARNING,
2387 "start time is not set in estimate_timings_from_pts\n");
2390 av_parser_close(st->parser);
2395 /* estimate the end time (duration) */
2396 /* XXX: may need to support wrapping */
2397 filesize = ic->pb ? avio_size(ic->pb) : 0;
2398 end_time = AV_NOPTS_VALUE;
2400 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2404 avio_seek(ic->pb, offset, SEEK_SET);
2407 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2411 ret = ff_read_packet(ic, pkt);
2412 } while (ret == AVERROR(EAGAIN));
2415 read_size += pkt->size;
2416 st = ic->streams[pkt->stream_index];
2417 if (pkt->pts != AV_NOPTS_VALUE &&
2418 (st->start_time != AV_NOPTS_VALUE ||
2419 st->first_dts != AV_NOPTS_VALUE)) {
2420 duration = end_time = pkt->pts;
2421 if (st->start_time != AV_NOPTS_VALUE)
2422 duration -= st->start_time;
2424 duration -= st->first_dts;
2426 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2427 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2428 st->duration = duration;
2429 st->info->last_duration = duration;
2432 av_free_packet(pkt);
2434 } while (end_time == AV_NOPTS_VALUE &&
2435 filesize > (DURATION_MAX_READ_SIZE << retry) &&
2436 ++retry <= DURATION_MAX_RETRY);
2438 fill_all_stream_timings(ic);
2440 avio_seek(ic->pb, old_offset, SEEK_SET);
2441 for (i = 0; i < ic->nb_streams; i++) {
2442 st = ic->streams[i];
2443 st->cur_dts = st->first_dts;
2444 st->last_IP_pts = AV_NOPTS_VALUE;
2448 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2452 /* get the file size, if possible */
2453 if (ic->iformat->flags & AVFMT_NOFILE) {
2456 file_size = avio_size(ic->pb);
2457 file_size = FFMAX(0, file_size);
2460 if ((!strcmp(ic->iformat->name, "mpeg") ||
2461 !strcmp(ic->iformat->name, "mpegts")) &&
2462 file_size && ic->pb->seekable) {
2463 /* get accurate estimate from the PTSes */
2464 estimate_timings_from_pts(ic, old_offset);
2465 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2466 } else if (has_duration(ic)) {
2467 /* at least one component has timings - we use them for all
2469 fill_all_stream_timings(ic);
2470 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2472 /* less precise: use bitrate info */
2473 estimate_timings_from_bit_rate(ic);
2474 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2476 update_stream_timings(ic);
2480 AVStream av_unused *st;
2481 for (i = 0; i < ic->nb_streams; i++) {
2482 st = ic->streams[i];
2483 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2484 (double) st->start_time / AV_TIME_BASE,
2485 (double) st->duration / AV_TIME_BASE);
2488 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2489 (double) ic->start_time / AV_TIME_BASE,
2490 (double) ic->duration / AV_TIME_BASE,
2491 ic->bit_rate / 1000);
2495 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2497 AVCodecContext *avctx = st->codec;
2499 #define FAIL(errmsg) do { \
2501 *errmsg_ptr = errmsg; \
2505 switch (avctx->codec_type) {
2506 case AVMEDIA_TYPE_AUDIO:
2507 if (!avctx->frame_size && determinable_frame_size(avctx))
2508 FAIL("unspecified frame size");
2509 if (st->info->found_decoder >= 0 &&
2510 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2511 FAIL("unspecified sample format");
2512 if (!avctx->sample_rate)
2513 FAIL("unspecified sample rate");
2514 if (!avctx->channels)
2515 FAIL("unspecified number of channels");
2516 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2517 FAIL("no decodable DTS frames");
2519 case AVMEDIA_TYPE_VIDEO:
2521 FAIL("unspecified size");
2522 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2523 FAIL("unspecified pixel format");
2524 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2525 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2526 FAIL("no frame in rv30/40 and no sar");
2528 case AVMEDIA_TYPE_SUBTITLE:
2529 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2530 FAIL("unspecified size");
2532 case AVMEDIA_TYPE_DATA:
2533 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2536 if (avctx->codec_id == AV_CODEC_ID_NONE)
2537 FAIL("unknown codec");
2541 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2542 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2543 AVDictionary **options)
2545 const AVCodec *codec;
2546 int got_picture = 1, ret = 0;
2547 AVFrame *frame = av_frame_alloc();
2548 AVSubtitle subtitle;
2549 AVPacket pkt = *avpkt;
2552 return AVERROR(ENOMEM);
2554 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2555 AVDictionary *thread_opt = NULL;
2557 codec = find_decoder(s, st, st->codec->codec_id);
2560 st->info->found_decoder = -1;
2565 /* Force thread count to 1 since the H.264 decoder will not extract
2566 * SPS and PPS to extradata during multi-threaded decoding. */
2567 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2568 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2570 av_dict_free(&thread_opt);
2572 st->info->found_decoder = -1;
2575 st->info->found_decoder = 1;
2576 } else if (!st->info->found_decoder)
2577 st->info->found_decoder = 1;
2579 if (st->info->found_decoder < 0) {
2584 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2586 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2587 (!st->codec_info_nb_frames &&
2588 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2590 switch (st->codec->codec_type) {
2591 case AVMEDIA_TYPE_VIDEO:
2592 ret = avcodec_decode_video2(st->codec, frame,
2593 &got_picture, &pkt);
2595 case AVMEDIA_TYPE_AUDIO:
2596 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2598 case AVMEDIA_TYPE_SUBTITLE:
2599 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2600 &got_picture, &pkt);
2608 st->nb_decoded_frames++;
2615 if (!pkt.data && !got_picture)
2619 av_frame_free(&frame);
2623 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2625 while (tags->id != AV_CODEC_ID_NONE) {
2633 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2636 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2637 if (tag == tags[i].tag)
2639 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2640 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2642 return AV_CODEC_ID_NONE;
2645 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2650 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2652 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2654 return AV_CODEC_ID_NONE;
2659 if (sflags & (1 << (bps - 1))) {
2662 return AV_CODEC_ID_PCM_S8;
2664 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2666 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2668 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2670 return AV_CODEC_ID_NONE;
2675 return AV_CODEC_ID_PCM_U8;
2677 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2679 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2681 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2683 return AV_CODEC_ID_NONE;
2689 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2692 if (!av_codec_get_tag2(tags, id, &tag))
2697 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2701 for (i = 0; tags && tags[i]; i++) {
2702 const AVCodecTag *codec_tags = tags[i];
2703 while (codec_tags->id != AV_CODEC_ID_NONE) {
2704 if (codec_tags->id == id) {
2705 *tag = codec_tags->tag;
2714 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2717 for (i = 0; tags && tags[i]; i++) {
2718 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2719 if (id != AV_CODEC_ID_NONE)
2722 return AV_CODEC_ID_NONE;
2725 static void compute_chapters_end(AVFormatContext *s)
2728 int64_t max_time = s->duration +
2729 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2731 for (i = 0; i < s->nb_chapters; i++)
2732 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2733 AVChapter *ch = s->chapters[i];
2734 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2738 for (j = 0; j < s->nb_chapters; j++) {
2739 AVChapter *ch1 = s->chapters[j];
2740 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2742 if (j != i && next_start > ch->start && next_start < end)
2745 ch->end = (end == INT64_MAX) ? ch->start : end;
2749 static int get_std_framerate(int i)
2752 return (i + 1) * 1001;
2754 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2757 /* Is the time base unreliable?
2758 * This is a heuristic to balance between quick acceptance of the values in
2759 * the headers vs. some extra checks.
2760 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2761 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2762 * And there are "variable" fps files this needs to detect as well. */
2763 static int tb_unreliable(AVCodecContext *c)
2765 if (c->time_base.den >= 101L * c->time_base.num ||
2766 c->time_base.den < 5L * c->time_base.num ||
2767 // c->codec_tag == AV_RL32("DIVX") ||
2768 // c->codec_tag == AV_RL32("XVID") ||
2769 c->codec_tag == AV_RL32("mp4v") ||
2770 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2771 c->codec_id == AV_CODEC_ID_H264)
2776 #if FF_API_FORMAT_PARAMETERS
2777 int av_find_stream_info(AVFormatContext *ic)
2779 return avformat_find_stream_info(ic, NULL);
2783 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2787 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2788 avctx->extradata_size = 0;
2789 return AVERROR(EINVAL);
2791 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2792 if (avctx->extradata) {
2793 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2794 avctx->extradata_size = size;
2797 avctx->extradata_size = 0;
2798 ret = AVERROR(ENOMEM);
2803 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2805 int ret = ff_alloc_extradata(avctx, size);
2808 ret = avio_read(pb, avctx->extradata, size);
2810 av_freep(&avctx->extradata);
2811 avctx->extradata_size = 0;
2812 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2813 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2819 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2822 int64_t last = st->info->last_dts;
2824 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2825 && ts - (uint64_t)last < INT64_MAX) {
2826 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2827 int64_t duration = ts - last;
2829 if (!st->info->duration_error)
2830 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2831 if (!st->info->duration_error)
2832 return AVERROR(ENOMEM);
2834 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2835 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2836 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2837 if (st->info->duration_error[0][1][i] < 1e10) {
2838 int framerate = get_std_framerate(i);
2839 double sdts = dts*framerate/(1001*12);
2840 for (j= 0; j<2; j++) {
2841 int64_t ticks = llrint(sdts+j*0.5);
2842 double error= sdts - ticks + j*0.5;
2843 st->info->duration_error[j][0][i] += error;
2844 st->info->duration_error[j][1][i] += error*error;
2848 st->info->duration_count++;
2849 st->info->rfps_duration_sum += duration;
2851 if (st->info->duration_count % 10 == 0) {
2852 int n = st->info->duration_count;
2853 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2854 if (st->info->duration_error[0][1][i] < 1e10) {
2855 double a0 = st->info->duration_error[0][0][i] / n;
2856 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2857 double a1 = st->info->duration_error[1][0][i] / n;
2858 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2859 if (error0 > 0.04 && error1 > 0.04) {
2860 st->info->duration_error[0][1][i] = 2e10;
2861 st->info->duration_error[1][1][i] = 2e10;
2867 // ignore the first 4 values, they might have some random jitter
2868 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2869 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2871 if (ts != AV_NOPTS_VALUE)
2872 st->info->last_dts = ts;
2877 void ff_rfps_calculate(AVFormatContext *ic)
2881 for (i = 0; i < ic->nb_streams; i++) {
2882 AVStream *st = ic->streams[i];
2884 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2886 // the check for tb_unreliable() is not completely correct, since this is not about handling
2887 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2888 // ipmovie.c produces.
2889 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)
2890 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);
2891 if (st->info->duration_count>1 && !st->r_frame_rate.num
2892 && tb_unreliable(st->codec)) {
2894 double best_error= 0.01;
2896 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2899 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2901 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2904 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2907 for (k= 0; k<2; k++) {
2908 int n = st->info->duration_count;
2909 double a= st->info->duration_error[k][0][j] / n;
2910 double error= st->info->duration_error[k][1][j]/n - a*a;
2912 if (error < best_error && best_error> 0.000000001) {
2914 num = get_std_framerate(j);
2917 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2920 // do not increase frame rate by more than 1 % in order to match a standard rate.
2921 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2922 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2925 av_freep(&st->info->duration_error);
2926 st->info->last_dts = AV_NOPTS_VALUE;
2927 st->info->duration_count = 0;
2928 st->info->rfps_duration_sum = 0;
2932 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2934 int i, count, ret = 0, j;
2937 AVPacket pkt1, *pkt;
2938 int64_t old_offset = avio_tell(ic->pb);
2939 // new streams might appear, no options for those
2940 int orig_nb_streams = ic->nb_streams;
2941 int flush_codecs = ic->probesize > 0;
2944 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2945 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2947 for (i = 0; i < ic->nb_streams; i++) {
2948 const AVCodec *codec;
2949 AVDictionary *thread_opt = NULL;
2950 st = ic->streams[i];
2952 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2953 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2954 /* if (!st->time_base.num)
2956 if (!st->codec->time_base.num)
2957 st->codec->time_base = st->time_base;
2959 // only for the split stuff
2960 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2961 st->parser = av_parser_init(st->codec->codec_id);
2963 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
2964 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2965 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2966 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2968 } else if (st->need_parsing) {
2969 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2970 "%s, packets or times may be invalid.\n",
2971 avcodec_get_name(st->codec->codec_id));
2974 codec = find_decoder(ic, st, st->codec->codec_id);
2976 /* Force thread count to 1 since the H.264 decoder will not extract
2977 * SPS and PPS to extradata during multi-threaded decoding. */
2978 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2980 /* Ensure that subtitle_header is properly set. */
2981 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2982 && codec && !st->codec->codec) {
2983 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2984 av_log(ic, AV_LOG_WARNING,
2985 "Failed to open codec in av_find_stream_info\n");
2988 // Try to just open decoders, in case this is enough to get parameters.
2989 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2990 if (codec && !st->codec->codec)
2991 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2992 av_log(ic, AV_LOG_WARNING,
2993 "Failed to open codec in av_find_stream_info\n");
2996 av_dict_free(&thread_opt);
2999 for (i = 0; i < ic->nb_streams; i++) {
3000 #if FF_API_R_FRAME_RATE
3001 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3003 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3004 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3010 if (ff_check_interrupt(&ic->interrupt_callback)) {
3012 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3016 /* check if one codec still needs to be handled */
3017 for (i = 0; i < ic->nb_streams; i++) {
3018 int fps_analyze_framecount = 20;
3020 st = ic->streams[i];
3021 if (!has_codec_parameters(st, NULL))
3023 /* If the timebase is coarse (like the usual millisecond precision
3024 * of mkv), we need to analyze more frames to reliably arrive at
3025 * the correct fps. */
3026 if (av_q2d(st->time_base) > 0.0005)
3027 fps_analyze_framecount *= 2;
3028 if (ic->fps_probe_size >= 0)
3029 fps_analyze_framecount = ic->fps_probe_size;
3030 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3031 fps_analyze_framecount = 0;
3032 /* variable fps and no guess at the real fps */
3033 if (tb_unreliable(st->codec) &&
3034 !(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3035 st->info->duration_count < fps_analyze_framecount &&
3036 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3038 if (st->parser && st->parser->parser->split &&
3039 !st->codec->extradata)
3041 if (st->first_dts == AV_NOPTS_VALUE &&
3042 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3043 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3046 if (i == ic->nb_streams) {
3047 /* NOTE: If the format has no header, then we need to read some
3048 * packets to get most of the streams, so we cannot stop here. */
3049 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3050 /* If we found the info for all the codecs, we can stop. */
3052 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3057 /* We did not get all the codec info, but we read too much data. */
3058 if (read_size >= ic->probesize) {
3060 av_log(ic, AV_LOG_DEBUG,
3061 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3062 for (i = 0; i < ic->nb_streams; i++)
3063 if (!ic->streams[i]->r_frame_rate.num &&
3064 ic->streams[i]->info->duration_count <= 1 &&
3065 strcmp(ic->iformat->name, "image2"))
3066 av_log(ic, AV_LOG_WARNING,
3067 "Stream #%d: not enough frames to estimate rate; "
3068 "consider increasing probesize\n", i);
3072 /* NOTE: A new stream can be added there if no header in file
3073 * (AVFMTCTX_NOHEADER). */
3074 ret = read_frame_internal(ic, &pkt1);
3075 if (ret == AVERROR(EAGAIN))
3083 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3084 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3086 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3087 &ic->packet_buffer_end);
3089 ret = AVERROR(ENOMEM);
3090 goto find_stream_info_err;
3092 if ((ret = av_dup_packet(pkt)) < 0)
3093 goto find_stream_info_err;
3096 st = ic->streams[pkt->stream_index];
3097 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3098 read_size += pkt->size;
3100 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3101 /* check for non-increasing dts */
3102 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3103 st->info->fps_last_dts >= pkt->dts) {
3104 av_log(ic, AV_LOG_DEBUG,
3105 "Non-increasing DTS in stream %d: packet %d with DTS "
3106 "%"PRId64", packet %d with DTS %"PRId64"\n",
3107 st->index, st->info->fps_last_dts_idx,
3108 st->info->fps_last_dts, st->codec_info_nb_frames,
3110 st->info->fps_first_dts =
3111 st->info->fps_last_dts = AV_NOPTS_VALUE;
3113 /* Check for a discontinuity in dts. If the difference in dts
3114 * is more than 1000 times the average packet duration in the
3115 * sequence, we treat it as a discontinuity. */
3116 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3117 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3118 (pkt->dts - st->info->fps_last_dts) / 1000 >
3119 (st->info->fps_last_dts - st->info->fps_first_dts) /
3120 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3121 av_log(ic, AV_LOG_WARNING,
3122 "DTS discontinuity in stream %d: packet %d with DTS "
3123 "%"PRId64", packet %d with DTS %"PRId64"\n",
3124 st->index, st->info->fps_last_dts_idx,
3125 st->info->fps_last_dts, st->codec_info_nb_frames,
3127 st->info->fps_first_dts =
3128 st->info->fps_last_dts = AV_NOPTS_VALUE;
3131 /* update stored dts values */
3132 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3133 st->info->fps_first_dts = pkt->dts;
3134 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3136 st->info->fps_last_dts = pkt->dts;
3137 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3139 if (st->codec_info_nb_frames>1) {
3141 if (st->time_base.den > 0)
3142 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3143 if (st->avg_frame_rate.num > 0)
3144 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3147 && st->codec_info_nb_frames>30
3148 && st->info->fps_first_dts != AV_NOPTS_VALUE
3149 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3150 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3152 if (t >= ic->max_analyze_duration) {
3153 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3156 if (pkt->duration) {
3157 st->info->codec_info_duration += pkt->duration;
3158 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3161 #if FF_API_R_FRAME_RATE
3162 ff_rfps_add_frame(ic, st, pkt->dts);
3164 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3165 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3166 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3167 if (ff_alloc_extradata(st->codec, i))
3168 return AVERROR(ENOMEM);
3169 memcpy(st->codec->extradata, pkt->data,
3170 st->codec->extradata_size);
3174 /* If still no information, we try to open the codec and to
3175 * decompress the frame. We try to avoid that in most cases as
3176 * it takes longer and uses more memory. For MPEG-4, we need to
3177 * decompress for QuickTime.
3179 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3180 * least one frame of codec data, this makes sure the codec initializes
3181 * the channel configuration and does not only trust the values from
3183 try_decode_frame(ic, st, pkt,
3184 (options && i < orig_nb_streams) ? &options[i] : NULL);
3186 st->codec_info_nb_frames++;
3191 AVPacket empty_pkt = { 0 };
3193 av_init_packet(&empty_pkt);
3195 for (i = 0; i < ic->nb_streams; i++) {
3197 st = ic->streams[i];
3199 /* flush the decoders */
3200 if (st->info->found_decoder == 1) {
3202 err = try_decode_frame(ic, st, &empty_pkt,
3203 (options && i < orig_nb_streams)
3204 ? &options[i] : NULL);
3205 } while (err > 0 && !has_codec_parameters(st, NULL));
3208 av_log(ic, AV_LOG_INFO,
3209 "decoding for stream %d failed\n", st->index);
3215 // close codecs which were opened in try_decode_frame()
3216 for (i = 0; i < ic->nb_streams; i++) {
3217 st = ic->streams[i];
3218 avcodec_close(st->codec);
3221 ff_rfps_calculate(ic);
3223 for (i = 0; i < ic->nb_streams; i++) {
3224 st = ic->streams[i];
3225 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3226 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3227 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3228 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3229 st->codec->codec_tag= tag;
3232 /* estimate average framerate if not set by demuxer */
3233 if (st->info->codec_info_duration_fields &&
3234 !st->avg_frame_rate.num &&
3235 st->info->codec_info_duration) {
3237 double best_error = 0.01;
3239 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3240 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3241 st->info->codec_info_duration < 0)
3243 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3244 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3245 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3247 /* Round guessed framerate to a "standard" framerate if it's
3248 * within 1% of the original estimate. */
3249 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3250 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3251 double error = fabs(av_q2d(st->avg_frame_rate) /
3252 av_q2d(std_fps) - 1);
3254 if (error < best_error) {
3256 best_fps = std_fps.num;
3260 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3261 best_fps, 12 * 1001, INT_MAX);
3264 if (!st->r_frame_rate.num) {
3265 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3266 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3267 st->r_frame_rate.num = st->codec->time_base.den;
3268 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3270 st->r_frame_rate.num = st->time_base.den;
3271 st->r_frame_rate.den = st->time_base.num;
3274 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3275 if (!st->codec->bits_per_coded_sample)
3276 st->codec->bits_per_coded_sample =
3277 av_get_bits_per_sample(st->codec->codec_id);
3278 // set stream disposition based on audio service type
3279 switch (st->codec->audio_service_type) {
3280 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3281 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3283 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3284 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3286 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3287 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3289 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3290 st->disposition = AV_DISPOSITION_COMMENT;
3292 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3293 st->disposition = AV_DISPOSITION_KARAOKE;
3300 estimate_timings(ic, old_offset);
3302 if (ret >= 0 && ic->nb_streams)
3303 /* We could not have all the codec parameters before EOF. */
3305 for (i = 0; i < ic->nb_streams; i++) {
3307 st = ic->streams[i];
3308 if (!has_codec_parameters(st, &errmsg)) {
3310 avcodec_string(buf, sizeof(buf), st->codec, 0);
3311 av_log(ic, AV_LOG_WARNING,
3312 "Could not find codec parameters for stream %d (%s): %s\n"
3313 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3320 compute_chapters_end(ic);
3322 find_stream_info_err:
3323 for (i = 0; i < ic->nb_streams; i++) {
3324 st = ic->streams[i];
3325 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3326 ic->streams[i]->codec->thread_count = 0;
3328 av_freep(&st->info->duration_error);
3329 av_freep(&ic->streams[i]->info);
3332 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3333 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3337 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3341 for (i = 0; i < ic->nb_programs; i++) {
3342 if (ic->programs[i] == last) {
3346 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3347 if (ic->programs[i]->stream_index[j] == s)
3348 return ic->programs[i];
3354 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3355 int wanted_stream_nb, int related_stream,
3356 AVCodec **decoder_ret, int flags)
3358 int i, nb_streams = ic->nb_streams;
3359 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3360 unsigned *program = NULL;
3361 AVCodec *decoder = NULL, *best_decoder = NULL;
3363 if (related_stream >= 0 && wanted_stream_nb < 0) {
3364 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3366 program = p->stream_index;
3367 nb_streams = p->nb_stream_indexes;
3370 for (i = 0; i < nb_streams; i++) {
3371 int real_stream_index = program ? program[i] : i;
3372 AVStream *st = ic->streams[real_stream_index];
3373 AVCodecContext *avctx = st->codec;
3374 if (avctx->codec_type != type)
3376 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3378 if (wanted_stream_nb != real_stream_index &&
3379 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3380 AV_DISPOSITION_VISUAL_IMPAIRED))
3382 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3385 decoder = find_decoder(ic, st, st->codec->codec_id);
3388 ret = AVERROR_DECODER_NOT_FOUND;
3392 count = st->codec_info_nb_frames;
3393 bitrate = avctx->bit_rate;
3394 multiframe = FFMIN(5, count);
3395 if ((best_multiframe > multiframe) ||
3396 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3397 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3400 best_bitrate = bitrate;
3401 best_multiframe = multiframe;
3402 ret = real_stream_index;
3403 best_decoder = decoder;
3404 if (program && i == nb_streams - 1 && ret < 0) {
3406 nb_streams = ic->nb_streams;
3407 /* no related stream found, try again with everything */
3412 *decoder_ret = best_decoder;
3416 /*******************************************************/
3418 int av_read_play(AVFormatContext *s)
3420 if (s->iformat->read_play)
3421 return s->iformat->read_play(s);
3423 return avio_pause(s->pb, 0);
3424 return AVERROR(ENOSYS);
3427 int av_read_pause(AVFormatContext *s)
3429 if (s->iformat->read_pause)
3430 return s->iformat->read_pause(s);
3432 return avio_pause(s->pb, 1);
3433 return AVERROR(ENOSYS);
3436 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3437 av_assert0(s->nb_streams>0);
3438 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3441 av_parser_close(st->parser);
3443 if (st->attached_pic.data)
3444 av_free_packet(&st->attached_pic);
3445 av_dict_free(&st->metadata);
3446 av_freep(&st->probe_data.buf);
3447 av_freep(&st->index_entries);
3448 av_freep(&st->codec->extradata);
3449 av_freep(&st->codec->subtitle_header);
3450 av_freep(&st->codec);
3451 av_freep(&st->priv_data);
3453 av_freep(&st->info->duration_error);
3454 av_freep(&st->info);
3455 av_freep(&s->streams[ --s->nb_streams ]);
3458 void avformat_free_context(AVFormatContext *s)
3466 if (s->iformat && s->iformat->priv_class && s->priv_data)
3467 av_opt_free(s->priv_data);
3469 for (i = s->nb_streams - 1; i >= 0; i--) {
3470 ff_free_stream(s, s->streams[i]);
3472 for (i = s->nb_programs - 1; i >= 0; i--) {
3473 av_dict_free(&s->programs[i]->metadata);
3474 av_freep(&s->programs[i]->stream_index);
3475 av_freep(&s->programs[i]);
3477 av_freep(&s->programs);
3478 av_freep(&s->priv_data);
3479 while (s->nb_chapters--) {
3480 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3481 av_freep(&s->chapters[s->nb_chapters]);
3483 av_freep(&s->chapters);
3484 av_dict_free(&s->metadata);
3485 av_freep(&s->streams);
3486 av_freep(&s->internal);
3490 #if FF_API_CLOSE_INPUT_FILE
3491 void av_close_input_file(AVFormatContext *s)
3493 avformat_close_input(&s);
3497 void avformat_close_input(AVFormatContext **ps)
3508 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3509 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3512 flush_packet_queue(s);
3515 if (s->iformat->read_close)
3516 s->iformat->read_close(s);
3518 avformat_free_context(s);
3525 #if FF_API_NEW_STREAM
3526 AVStream *av_new_stream(AVFormatContext *s, int id)
3528 AVStream *st = avformat_new_stream(s, NULL);
3535 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3541 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3543 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3546 s->streams = streams;
3548 st = av_mallocz(sizeof(AVStream));
3551 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3555 st->info->last_dts = AV_NOPTS_VALUE;
3557 st->codec = avcodec_alloc_context3(c);
3559 /* no default bitrate if decoding */
3560 st->codec->bit_rate = 0;
3561 st->index = s->nb_streams;
3562 st->start_time = AV_NOPTS_VALUE;
3563 st->duration = AV_NOPTS_VALUE;
3564 /* we set the current DTS to 0 so that formats without any timestamps
3565 * but durations get some timestamps, formats with some unknown
3566 * timestamps have their first few packets buffered and the
3567 * timestamps corrected before they are returned to the user */
3568 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3569 st->first_dts = AV_NOPTS_VALUE;
3570 st->probe_packets = MAX_PROBE_PACKETS;
3571 st->pts_wrap_reference = AV_NOPTS_VALUE;
3572 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3574 /* default pts setting is MPEG-like */
3575 avpriv_set_pts_info(st, 33, 1, 90000);
3576 st->last_IP_pts = AV_NOPTS_VALUE;
3577 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3578 st->pts_buffer[i] = AV_NOPTS_VALUE;
3580 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3582 #if FF_API_R_FRAME_RATE
3583 st->info->last_dts = AV_NOPTS_VALUE;
3585 st->info->fps_first_dts = AV_NOPTS_VALUE;
3586 st->info->fps_last_dts = AV_NOPTS_VALUE;
3588 s->streams[s->nb_streams++] = st;
3592 AVProgram *av_new_program(AVFormatContext *ac, int id)
3594 AVProgram *program = NULL;
3597 av_dlog(ac, "new_program: id=0x%04x\n", id);
3599 for (i = 0; i < ac->nb_programs; i++)
3600 if (ac->programs[i]->id == id)
3601 program = ac->programs[i];
3604 program = av_mallocz(sizeof(AVProgram));
3607 dynarray_add(&ac->programs, &ac->nb_programs, program);
3608 program->discard = AVDISCARD_NONE;
3611 program->pts_wrap_reference = AV_NOPTS_VALUE;
3612 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3614 program->start_time =
3615 program->end_time = AV_NOPTS_VALUE;
3620 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3621 int64_t start, int64_t end, const char *title)
3623 AVChapter *chapter = NULL;
3626 for (i = 0; i < s->nb_chapters; i++)
3627 if (s->chapters[i]->id == id)
3628 chapter = s->chapters[i];
3631 chapter = av_mallocz(sizeof(AVChapter));
3634 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3636 av_dict_set(&chapter->metadata, "title", title, 0);
3638 chapter->time_base = time_base;
3639 chapter->start = start;
3645 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3648 AVProgram *program = NULL;
3651 if (idx >= ac->nb_streams) {
3652 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3656 for (i = 0; i < ac->nb_programs; i++) {
3657 if (ac->programs[i]->id != progid)
3659 program = ac->programs[i];
3660 for (j = 0; j < program->nb_stream_indexes; j++)
3661 if (program->stream_index[j] == idx)
3664 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3667 program->stream_index = tmp;
3668 program->stream_index[program->nb_stream_indexes++] = idx;
3673 static void print_fps(double d, const char *postfix)
3675 uint64_t v = lrintf(d * 100);
3677 av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3678 else if (v % (100 * 1000))
3679 av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3681 av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3684 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3686 if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3687 AVDictionaryEntry *tag = NULL;
3689 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3690 while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3691 if (strcmp("language", tag->key)) {
3692 const char *p = tag->value;
3693 av_log(ctx, AV_LOG_INFO,
3694 "%s %-16s: ", indent, tag->key);
3697 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3698 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3699 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3701 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3702 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3705 av_log(ctx, AV_LOG_INFO, "\n");
3710 /* "user interface" functions */
3711 static void dump_stream_format(AVFormatContext *ic, int i,
3712 int index, int is_output)
3715 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3716 AVStream *st = ic->streams[i];
3717 int g = av_gcd(st->time_base.num, st->time_base.den);
3718 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3719 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3720 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3721 /* the pid is an important information, so we display it */
3722 /* XXX: add a generic system */
3723 if (flags & AVFMT_SHOW_IDS)
3724 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3726 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3727 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3728 st->time_base.num / g, st->time_base.den / g);
3729 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3730 if (st->sample_aspect_ratio.num && // default
3731 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3732 AVRational display_aspect_ratio;
3733 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3734 st->codec->width * st->sample_aspect_ratio.num,
3735 st->codec->height * st->sample_aspect_ratio.den,
3737 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3738 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3739 display_aspect_ratio.num, display_aspect_ratio.den);
3741 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3742 if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3743 print_fps(av_q2d(st->avg_frame_rate), "fps");
3744 #if FF_API_R_FRAME_RATE
3745 if (st->r_frame_rate.den && st->r_frame_rate.num)
3746 print_fps(av_q2d(st->r_frame_rate), "tbr");
3748 if (st->time_base.den && st->time_base.num)
3749 print_fps(1 / av_q2d(st->time_base), "tbn");
3750 if (st->codec->time_base.den && st->codec->time_base.num)
3751 print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3753 if (st->disposition & AV_DISPOSITION_DEFAULT)
3754 av_log(NULL, AV_LOG_INFO, " (default)");
3755 if (st->disposition & AV_DISPOSITION_DUB)
3756 av_log(NULL, AV_LOG_INFO, " (dub)");
3757 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3758 av_log(NULL, AV_LOG_INFO, " (original)");
3759 if (st->disposition & AV_DISPOSITION_COMMENT)
3760 av_log(NULL, AV_LOG_INFO, " (comment)");
3761 if (st->disposition & AV_DISPOSITION_LYRICS)
3762 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3763 if (st->disposition & AV_DISPOSITION_KARAOKE)
3764 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3765 if (st->disposition & AV_DISPOSITION_FORCED)
3766 av_log(NULL, AV_LOG_INFO, " (forced)");
3767 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3768 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3769 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3770 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3771 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3772 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3773 av_log(NULL, AV_LOG_INFO, "\n");
3774 dump_metadata(NULL, st->metadata, " ");
3777 void av_dump_format(AVFormatContext *ic, int index,
3778 const char *url, int is_output)
3781 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3782 if (ic->nb_streams && !printed)
3785 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3786 is_output ? "Output" : "Input",
3788 is_output ? ic->oformat->name : ic->iformat->name,
3789 is_output ? "to" : "from", url);
3790 dump_metadata(NULL, ic->metadata, " ");
3792 av_log(NULL, AV_LOG_INFO, " Duration: ");
3793 if (ic->duration != AV_NOPTS_VALUE) {
3794 int hours, mins, secs, us;
3795 int64_t duration = ic->duration + 5000;
3796 secs = duration / AV_TIME_BASE;
3797 us = duration % AV_TIME_BASE;
3802 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3803 (100 * us) / AV_TIME_BASE);
3805 av_log(NULL, AV_LOG_INFO, "N/A");
3807 if (ic->start_time != AV_NOPTS_VALUE) {
3809 av_log(NULL, AV_LOG_INFO, ", start: ");
3810 secs = ic->start_time / AV_TIME_BASE;
3811 us = abs(ic->start_time % AV_TIME_BASE);
3812 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3813 secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3815 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3817 av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3819 av_log(NULL, AV_LOG_INFO, "N/A");
3820 av_log(NULL, AV_LOG_INFO, "\n");
3822 for (i = 0; i < ic->nb_chapters; i++) {
3823 AVChapter *ch = ic->chapters[i];
3824 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3825 av_log(NULL, AV_LOG_INFO,
3826 "start %f, ", ch->start * av_q2d(ch->time_base));
3827 av_log(NULL, AV_LOG_INFO,
3828 "end %f\n", ch->end * av_q2d(ch->time_base));
3830 dump_metadata(NULL, ch->metadata, " ");
3832 if (ic->nb_programs) {
3833 int j, k, total = 0;
3834 for (j = 0; j < ic->nb_programs; j++) {
3835 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3837 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3838 name ? name->value : "");
3839 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3840 for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3841 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3843 printed[ic->programs[j]->stream_index[k]] = 1;
3845 total += ic->programs[j]->nb_stream_indexes;
3847 if (total < ic->nb_streams)
3848 av_log(NULL, AV_LOG_INFO, " No Program\n");
3850 for (i = 0; i < ic->nb_streams; i++)
3852 dump_stream_format(ic, i, index, is_output);
3857 uint64_t ff_ntp_time(void)
3859 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3862 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3865 char *q, buf1[20], c;
3866 int nd, len, percentd_found;
3878 while (av_isdigit(*p))
3879 nd = nd * 10 + *p++ - '0';
3881 } while (av_isdigit(c));
3890 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3892 if ((q - buf + len) > buf_size - 1)
3894 memcpy(q, buf1, len);
3902 if ((q - buf) < buf_size - 1)
3906 if (!percentd_found)
3915 #define HEXDUMP_PRINT(...) \
3918 av_log(avcl, level, __VA_ARGS__); \
3920 fprintf(f, __VA_ARGS__); \
3923 static void hex_dump_internal(void *avcl, FILE *f, int level,
3924 const uint8_t *buf, int size)
3928 for (i = 0; i < size; i += 16) {
3932 HEXDUMP_PRINT("%08x ", i);
3933 for (j = 0; j < 16; j++) {
3935 HEXDUMP_PRINT(" %02x", buf[i + j]);
3940 for (j = 0; j < len; j++) {
3942 if (c < ' ' || c > '~')
3944 HEXDUMP_PRINT("%c", c);
3946 HEXDUMP_PRINT("\n");
3950 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3952 hex_dump_internal(NULL, f, 0, buf, size);
3955 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3957 hex_dump_internal(avcl, NULL, level, buf, size);
3960 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
3961 int dump_payload, AVRational time_base)
3963 HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
3964 HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
3965 HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3966 /* DTS is _always_ valid after av_read_frame() */
3967 HEXDUMP_PRINT(" dts=");
3968 if (pkt->dts == AV_NOPTS_VALUE)
3969 HEXDUMP_PRINT("N/A");
3971 HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3972 /* PTS may not be known if B-frames are present. */
3973 HEXDUMP_PRINT(" pts=");
3974 if (pkt->pts == AV_NOPTS_VALUE)
3975 HEXDUMP_PRINT("N/A");
3977 HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3978 HEXDUMP_PRINT("\n");
3979 HEXDUMP_PRINT(" size=%d\n", pkt->size);
3981 av_hex_dump(f, pkt->data, pkt->size);
3984 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3986 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3989 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3992 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3995 void av_url_split(char *proto, int proto_size,
3996 char *authorization, int authorization_size,
3997 char *hostname, int hostname_size,
3998 int *port_ptr, char *path, int path_size, const char *url)
4000 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4006 if (authorization_size > 0)
4007 authorization[0] = 0;
4008 if (hostname_size > 0)
4013 /* parse protocol */
4014 if ((p = strchr(url, ':'))) {
4015 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4022 /* no protocol means plain filename */
4023 av_strlcpy(path, url, path_size);
4027 /* separate path from hostname */
4028 ls = strchr(p, '/');
4029 ls2 = strchr(p, '?');
4033 ls = FFMIN(ls, ls2);
4035 av_strlcpy(path, ls, path_size);
4037 ls = &p[strlen(p)]; // XXX
4039 /* the rest is hostname, use that to parse auth/port */
4041 /* authorization (user[:pass]@hostname) */
4043 while ((at = strchr(p, '@')) && at < ls) {
4044 av_strlcpy(authorization, at2,
4045 FFMIN(authorization_size, at + 1 - at2));
4046 p = at + 1; /* skip '@' */
4049 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4051 av_strlcpy(hostname, p + 1,
4052 FFMIN(hostname_size, brk - p));
4053 if (brk[1] == ':' && port_ptr)
4054 *port_ptr = atoi(brk + 2);
4055 } else if ((col = strchr(p, ':')) && col < ls) {
4056 av_strlcpy(hostname, p,
4057 FFMIN(col + 1 - p, hostname_size));
4059 *port_ptr = atoi(col + 1);
4061 av_strlcpy(hostname, p,
4062 FFMIN(ls + 1 - p, hostname_size));
4066 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4069 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4072 'C', 'D', 'E', 'F' };
4073 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4076 'c', 'd', 'e', 'f' };
4077 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4079 for (i = 0; i < s; i++) {
4080 buff[i * 2] = hex_table[src[i] >> 4];
4081 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4087 int ff_hex_to_data(uint8_t *data, const char *p)
4094 p += strspn(p, SPACE_CHARS);
4097 c = av_toupper((unsigned char) *p++);
4098 if (c >= '0' && c <= '9')
4100 else if (c >= 'A' && c <= 'F')
4115 #if FF_API_SET_PTS_INFO
4116 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4117 unsigned int pts_num, unsigned int pts_den)
4119 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4123 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4124 unsigned int pts_num, unsigned int pts_den)
4127 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4128 if (new_tb.num != pts_num)
4129 av_log(NULL, AV_LOG_DEBUG,
4130 "st:%d removing common factor %d from timebase\n",
4131 s->index, pts_num / new_tb.num);
4133 av_log(NULL, AV_LOG_WARNING,
4134 "st:%d has too large timebase, reducing\n", s->index);
4136 if (new_tb.num <= 0 || new_tb.den <= 0) {
4137 av_log(NULL, AV_LOG_ERROR,
4138 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4139 new_tb.num, new_tb.den,
4143 s->time_base = new_tb;
4144 av_codec_set_pkt_timebase(s->codec, new_tb);
4145 s->pts_wrap_bits = pts_wrap_bits;
4148 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4151 const char *ptr = str;
4153 /* Parse key=value pairs. */
4156 char *dest = NULL, *dest_end;
4157 int key_len, dest_len = 0;
4159 /* Skip whitespace and potential commas. */
4160 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4167 if (!(ptr = strchr(key, '=')))
4170 key_len = ptr - key;
4172 callback_get_buf(context, key, key_len, &dest, &dest_len);
4173 dest_end = dest + dest_len - 1;
4177 while (*ptr && *ptr != '\"') {
4181 if (dest && dest < dest_end)
4185 if (dest && dest < dest_end)
4193 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4194 if (dest && dest < dest_end)
4202 int ff_find_stream_index(AVFormatContext *s, int id)
4205 for (i = 0; i < s->nb_streams; i++)
4206 if (s->streams[i]->id == id)
4211 int64_t ff_iso8601_to_unix_time(const char *datestr)
4213 struct tm time1 = { 0 }, time2 = { 0 };
4215 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4216 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4218 return av_timegm(&time2);
4220 return av_timegm(&time1);
4223 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4227 if (ofmt->query_codec)
4228 return ofmt->query_codec(codec_id, std_compliance);
4229 else if (ofmt->codec_tag)
4230 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4231 else if (codec_id == ofmt->video_codec ||
4232 codec_id == ofmt->audio_codec ||
4233 codec_id == ofmt->subtitle_codec)
4236 return AVERROR_PATCHWELCOME;
4239 int avformat_network_init(void)
4243 ff_network_inited_globally = 1;
4244 if ((ret = ff_network_init()) < 0)
4251 int avformat_network_deinit(void)
4260 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4261 uint64_t channel_layout, int32_t sample_rate,
4262 int32_t width, int32_t height)
4268 return AVERROR(EINVAL);
4271 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4273 if (channel_layout) {
4275 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4279 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4281 if (width || height) {
4283 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4285 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4287 return AVERROR(ENOMEM);
4288 bytestream_put_le32(&data, flags);
4290 bytestream_put_le32(&data, channels);
4292 bytestream_put_le64(&data, channel_layout);
4294 bytestream_put_le32(&data, sample_rate);
4295 if (width || height) {
4296 bytestream_put_le32(&data, width);
4297 bytestream_put_le32(&data, height);
4302 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4304 AVRational undef = {0, 1};
4305 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4306 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4307 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4309 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4310 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4311 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4312 stream_sample_aspect_ratio = undef;
4314 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4315 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4316 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4317 frame_sample_aspect_ratio = undef;
4319 if (stream_sample_aspect_ratio.num)
4320 return stream_sample_aspect_ratio;
4322 return frame_sample_aspect_ratio;
4325 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4327 AVRational fr = st->r_frame_rate;
4329 if (st->codec->ticks_per_frame > 1) {
4330 AVRational codec_fr = av_inv_q(st->codec->time_base);
4331 AVRational avg_fr = st->avg_frame_rate;
4332 codec_fr.den *= st->codec->ticks_per_frame;
4333 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4334 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4341 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4344 if (*spec <= '9' && *spec >= '0') /* opt:index */
4345 return strtol(spec, NULL, 0) == st->index;
4346 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4347 *spec == 't') { /* opt:[vasdt] */
4348 enum AVMediaType type;
4351 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4352 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4353 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4354 case 'd': type = AVMEDIA_TYPE_DATA; break;
4355 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4356 default: av_assert0(0);
4358 if (type != st->codec->codec_type)
4360 if (*spec++ == ':') { /* possibly followed by :index */
4361 int i, index = strtol(spec, NULL, 0);
4362 for (i = 0; i < s->nb_streams; i++)
4363 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4364 return i == st->index;
4368 } else if (*spec == 'p' && *(spec + 1) == ':') {
4372 prog_id = strtol(spec, &endptr, 0);
4373 for (i = 0; i < s->nb_programs; i++) {
4374 if (s->programs[i]->id != prog_id)
4377 if (*endptr++ == ':') {
4378 int stream_idx = strtol(endptr, NULL, 0);
4379 return stream_idx >= 0 &&
4380 stream_idx < s->programs[i]->nb_stream_indexes &&
4381 st->index == s->programs[i]->stream_index[stream_idx];
4384 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4385 if (st->index == s->programs[i]->stream_index[j])
4389 } else if (*spec == '#') {
4392 sid = strtol(spec + 1, &endptr, 0);
4394 return st->id == sid;
4395 } else if (!*spec) /* empty specifier, matches everything */
4398 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4399 return AVERROR(EINVAL);
4402 int ff_generate_avci_extradata(AVStream *st)
4404 static const uint8_t avci100_1080p_extradata[] = {
4406 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4407 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4408 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4409 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4410 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4411 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4412 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4413 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4414 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4416 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4419 static const uint8_t avci100_1080i_extradata[] = {
4421 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4422 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4423 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4424 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4425 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4426 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4427 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4428 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4429 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4430 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4431 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4433 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4436 static const uint8_t avci50_1080i_extradata[] = {
4438 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4439 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4440 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4441 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4442 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4443 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4444 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4445 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4446 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4447 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4448 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4450 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4453 static const uint8_t avci100_720p_extradata[] = {
4455 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4456 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4457 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4458 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4459 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4460 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4461 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4462 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4463 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4464 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4466 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4470 const uint8_t *data = NULL;
4473 if (st->codec->width == 1920) {
4474 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4475 data = avci100_1080p_extradata;
4476 size = sizeof(avci100_1080p_extradata);
4478 data = avci100_1080i_extradata;
4479 size = sizeof(avci100_1080i_extradata);
4481 } else if (st->codec->width == 1440) {
4482 data = avci50_1080i_extradata;
4483 size = sizeof(avci50_1080i_extradata);
4484 } else if (st->codec->width == 1280) {
4485 data = avci100_720p_extradata;
4486 size = sizeof(avci100_720p_extradata);
4492 av_freep(&st->codec->extradata);
4493 if (ff_alloc_extradata(st->codec, size))
4494 return AVERROR(ENOMEM);
4495 memcpy(st->codec->extradata, data, size);