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 if (presentation_delayed) {
1159 /* DTS = decompression timestamp */
1160 /* PTS = presentation timestamp */
1161 if (pkt->dts == AV_NOPTS_VALUE)
1162 pkt->dts = st->last_IP_pts;
1163 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1164 if (pkt->dts == AV_NOPTS_VALUE)
1165 pkt->dts = st->cur_dts;
1167 /* This is tricky: the dts must be incremented by the duration
1168 * of the frame we are displaying, i.e. the last I- or P-frame. */
1169 if (st->last_IP_duration == 0)
1170 st->last_IP_duration = pkt->duration;
1171 if (pkt->dts != AV_NOPTS_VALUE)
1172 st->cur_dts = pkt->dts + st->last_IP_duration;
1173 st->last_IP_duration = pkt->duration;
1174 st->last_IP_pts = pkt->pts;
1175 /* Cannot compute PTS if not present (we can compute it only
1176 * by knowing the future. */
1177 } else if (pkt->pts != AV_NOPTS_VALUE ||
1178 pkt->dts != AV_NOPTS_VALUE ||
1181 /* presentation is not delayed : PTS and DTS are the same */
1182 if (pkt->pts == AV_NOPTS_VALUE)
1183 pkt->pts = pkt->dts;
1184 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1186 if (pkt->pts == AV_NOPTS_VALUE)
1187 pkt->pts = st->cur_dts;
1188 pkt->dts = pkt->pts;
1189 if (pkt->pts != AV_NOPTS_VALUE)
1190 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1194 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1195 st->pts_buffer[0] = pkt->pts;
1196 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1197 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1198 if (pkt->dts == AV_NOPTS_VALUE)
1199 pkt->dts = st->pts_buffer[0];
1201 // We skipped it above so we try here.
1202 if (st->codec->codec_id == AV_CODEC_ID_H264)
1203 // This should happen on the first packet
1204 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1205 if (pkt->dts > st->cur_dts)
1206 st->cur_dts = pkt->dts;
1208 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1209 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1212 if (is_intra_only(st->codec))
1213 pkt->flags |= AV_PKT_FLAG_KEY;
1215 pkt->convergence_duration = pc->convergence_duration;
1218 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1221 AVPacketList *pktl = *pkt_buf;
1222 *pkt_buf = pktl->next;
1223 av_free_packet(&pktl->pkt);
1226 *pkt_buf_end = NULL;
1230 * Parse a packet, add all split parts to parse_queue.
1232 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1234 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1236 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1237 AVStream *st = s->streams[stream_index];
1238 uint8_t *data = pkt ? pkt->data : NULL;
1239 int size = pkt ? pkt->size : 0;
1240 int ret = 0, got_output = 0;
1243 av_init_packet(&flush_pkt);
1246 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1247 // preserve 0-size sync packets
1248 compute_pkt_fields(s, st, st->parser, pkt);
1251 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1254 av_init_packet(&out_pkt);
1255 len = av_parser_parse2(st->parser, st->codec,
1256 &out_pkt.data, &out_pkt.size, data, size,
1257 pkt->pts, pkt->dts, pkt->pos);
1259 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1261 /* increment read pointer */
1265 got_output = !!out_pkt.size;
1270 if (pkt->side_data) {
1271 out_pkt.side_data = pkt->side_data;
1272 out_pkt.side_data_elems = pkt->side_data_elems;
1273 pkt->side_data = NULL;
1274 pkt->side_data_elems = 0;
1277 /* set the duration */
1278 out_pkt.duration = 0;
1279 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1280 if (st->codec->sample_rate > 0) {
1282 av_rescale_q_rnd(st->parser->duration,
1283 (AVRational) { 1, st->codec->sample_rate },
1287 } else if (st->codec->time_base.num != 0 &&
1288 st->codec->time_base.den != 0) {
1289 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1290 st->codec->time_base,
1295 out_pkt.stream_index = st->index;
1296 out_pkt.pts = st->parser->pts;
1297 out_pkt.dts = st->parser->dts;
1298 out_pkt.pos = st->parser->pos;
1300 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1301 out_pkt.pos = st->parser->frame_offset;
1303 if (st->parser->key_frame == 1 ||
1304 (st->parser->key_frame == -1 &&
1305 st->parser->pict_type == AV_PICTURE_TYPE_I))
1306 out_pkt.flags |= AV_PKT_FLAG_KEY;
1308 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1309 out_pkt.flags |= AV_PKT_FLAG_KEY;
1311 compute_pkt_fields(s, st, st->parser, &out_pkt);
1313 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1314 out_pkt.buf = pkt->buf;
1316 #if FF_API_DESTRUCT_PACKET
1317 FF_DISABLE_DEPRECATION_WARNINGS
1318 out_pkt.destruct = pkt->destruct;
1319 pkt->destruct = NULL;
1320 FF_ENABLE_DEPRECATION_WARNINGS
1323 if ((ret = av_dup_packet(&out_pkt)) < 0)
1326 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1327 av_free_packet(&out_pkt);
1328 ret = AVERROR(ENOMEM);
1333 /* end of the stream => close and free the parser */
1334 if (pkt == &flush_pkt) {
1335 av_parser_close(st->parser);
1340 av_free_packet(pkt);
1344 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1345 AVPacketList **pkt_buffer_end,
1349 av_assert0(*pkt_buffer);
1352 *pkt_buffer = pktl->next;
1354 *pkt_buffer_end = NULL;
1359 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1361 int ret = 0, i, got_packet = 0;
1363 av_init_packet(pkt);
1365 while (!got_packet && !s->parse_queue) {
1369 /* read next packet */
1370 ret = ff_read_packet(s, &cur_pkt);
1372 if (ret == AVERROR(EAGAIN))
1374 /* flush the parsers */
1375 for (i = 0; i < s->nb_streams; i++) {
1377 if (st->parser && st->need_parsing)
1378 parse_packet(s, NULL, st->index);
1380 /* all remaining packets are now in parse_queue =>
1381 * really terminate parsing */
1385 st = s->streams[cur_pkt.stream_index];
1387 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1388 cur_pkt.dts != AV_NOPTS_VALUE &&
1389 cur_pkt.pts < cur_pkt.dts) {
1390 av_log(s, AV_LOG_WARNING,
1391 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1392 cur_pkt.stream_index,
1393 av_ts2str(cur_pkt.pts),
1394 av_ts2str(cur_pkt.dts),
1397 if (s->debug & FF_FDEBUG_TS)
1398 av_log(s, AV_LOG_DEBUG,
1399 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1400 cur_pkt.stream_index,
1401 av_ts2str(cur_pkt.pts),
1402 av_ts2str(cur_pkt.dts),
1403 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1405 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1406 st->parser = av_parser_init(st->codec->codec_id);
1408 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1409 "%s, packets or times may be invalid.\n",
1410 avcodec_get_name(st->codec->codec_id));
1411 /* no parser available: just output the raw packets */
1412 st->need_parsing = AVSTREAM_PARSE_NONE;
1413 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1414 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1415 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1416 st->parser->flags |= PARSER_FLAG_ONCE;
1417 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1418 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1421 if (!st->need_parsing || !st->parser) {
1422 /* no parsing needed: we just output the packet as is */
1424 compute_pkt_fields(s, st, NULL, pkt);
1425 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1426 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1427 ff_reduce_index(s, st->index);
1428 av_add_index_entry(st, pkt->pos, pkt->dts,
1429 0, 0, AVINDEX_KEYFRAME);
1432 } else if (st->discard < AVDISCARD_ALL) {
1433 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1437 av_free_packet(&cur_pkt);
1439 if (pkt->flags & AV_PKT_FLAG_KEY)
1440 st->skip_to_keyframe = 0;
1441 if (st->skip_to_keyframe) {
1442 av_free_packet(&cur_pkt);
1450 if (!got_packet && s->parse_queue)
1451 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1454 AVStream *st = s->streams[pkt->stream_index];
1455 if (st->skip_samples) {
1456 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1458 AV_WL32(p, st->skip_samples);
1459 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1461 st->skip_samples = 0;
1465 if (ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1466 av_packet_merge_side_data(pkt);
1468 if (s->debug & FF_FDEBUG_TS)
1469 av_log(s, AV_LOG_DEBUG,
1470 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1471 "size=%d, duration=%d, flags=%d\n",
1473 av_ts2str(pkt->pts),
1474 av_ts2str(pkt->dts),
1475 pkt->size, pkt->duration, pkt->flags);
1480 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1482 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1488 ret = s->packet_buffer
1489 ? read_from_packet_buffer(&s->packet_buffer,
1490 &s->packet_buffer_end, pkt)
1491 : read_frame_internal(s, pkt);
1498 AVPacketList *pktl = s->packet_buffer;
1501 AVPacket *next_pkt = &pktl->pkt;
1503 if (next_pkt->dts != AV_NOPTS_VALUE) {
1504 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1505 // last dts seen for this stream. if any of packets following
1506 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1507 int64_t last_dts = next_pkt->dts;
1508 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1509 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1510 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1511 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1513 next_pkt->pts = pktl->pkt.dts;
1515 if (last_dts != AV_NOPTS_VALUE) {
1516 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1517 last_dts = pktl->pkt.dts;
1522 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1523 // Fixing the last reference frame had none pts issue (For MXF etc).
1524 // We only do this when
1526 // 2. we are not able to resolve a pts value for current packet.
1527 // 3. the packets for this stream at the end of the files had valid dts.
1528 next_pkt->pts = last_dts + next_pkt->duration;
1530 pktl = s->packet_buffer;
1533 /* read packet from packet buffer, if there is data */
1534 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1535 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1536 ret = read_from_packet_buffer(&s->packet_buffer,
1537 &s->packet_buffer_end, pkt);
1542 ret = read_frame_internal(s, pkt);
1544 if (pktl && ret != AVERROR(EAGAIN)) {
1551 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1552 &s->packet_buffer_end)) < 0)
1553 return AVERROR(ENOMEM);
1558 st = s->streams[pkt->stream_index];
1559 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1560 ff_reduce_index(s, st->index);
1561 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1564 if (is_relative(pkt->dts))
1565 pkt->dts -= RELATIVE_TS_BASE;
1566 if (is_relative(pkt->pts))
1567 pkt->pts -= RELATIVE_TS_BASE;
1572 /* XXX: suppress the packet queue */
1573 static void flush_packet_queue(AVFormatContext *s)
1575 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1576 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1577 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1579 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1582 /*******************************************************/
1585 int av_find_default_stream_index(AVFormatContext *s)
1587 int first_audio_index = -1;
1591 if (s->nb_streams <= 0)
1593 for (i = 0; i < s->nb_streams; i++) {
1595 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1596 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1599 if (first_audio_index < 0 &&
1600 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1601 first_audio_index = i;
1603 return first_audio_index >= 0 ? first_audio_index : 0;
1606 /** Flush the frame reader. */
1607 void ff_read_frame_flush(AVFormatContext *s)
1612 flush_packet_queue(s);
1614 /* Reset read state for each stream. */
1615 for (i = 0; i < s->nb_streams; i++) {
1619 av_parser_close(st->parser);
1622 st->last_IP_pts = AV_NOPTS_VALUE;
1623 if (st->first_dts == AV_NOPTS_VALUE)
1624 st->cur_dts = RELATIVE_TS_BASE;
1626 /* We set the current DTS to an unspecified origin. */
1627 st->cur_dts = AV_NOPTS_VALUE;
1629 st->probe_packets = MAX_PROBE_PACKETS;
1631 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1632 st->pts_buffer[j] = AV_NOPTS_VALUE;
1636 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1640 for (i = 0; i < s->nb_streams; i++) {
1641 AVStream *st = s->streams[i];
1644 av_rescale(timestamp,
1645 st->time_base.den * (int64_t) ref_st->time_base.num,
1646 st->time_base.num * (int64_t) ref_st->time_base.den);
1650 void ff_reduce_index(AVFormatContext *s, int stream_index)
1652 AVStream *st = s->streams[stream_index];
1653 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1655 if ((unsigned) st->nb_index_entries >= max_entries) {
1657 for (i = 0; 2 * i < st->nb_index_entries; i++)
1658 st->index_entries[i] = st->index_entries[2 * i];
1659 st->nb_index_entries = i;
1663 int ff_add_index_entry(AVIndexEntry **index_entries,
1664 int *nb_index_entries,
1665 unsigned int *index_entries_allocated_size,
1666 int64_t pos, int64_t timestamp,
1667 int size, int distance, int flags)
1669 AVIndexEntry *entries, *ie;
1672 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1675 if (timestamp == AV_NOPTS_VALUE)
1676 return AVERROR(EINVAL);
1678 if (size < 0 || size > 0x3FFFFFFF)
1679 return AVERROR(EINVAL);
1681 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1682 timestamp -= RELATIVE_TS_BASE;
1684 entries = av_fast_realloc(*index_entries,
1685 index_entries_allocated_size,
1686 (*nb_index_entries + 1) *
1687 sizeof(AVIndexEntry));
1691 *index_entries = entries;
1693 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1694 timestamp, AVSEEK_FLAG_ANY);
1697 index = (*nb_index_entries)++;
1698 ie = &entries[index];
1699 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1701 ie = &entries[index];
1702 if (ie->timestamp != timestamp) {
1703 if (ie->timestamp <= timestamp)
1705 memmove(entries + index + 1, entries + index,
1706 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1707 (*nb_index_entries)++;
1708 } else if (ie->pos == pos && distance < ie->min_distance)
1709 // do not reduce the distance
1710 distance = ie->min_distance;
1714 ie->timestamp = timestamp;
1715 ie->min_distance = distance;
1722 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1723 int size, int distance, int flags)
1725 timestamp = wrap_timestamp(st, timestamp);
1726 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1727 &st->index_entries_allocated_size, pos,
1728 timestamp, size, distance, flags);
1731 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1732 int64_t wanted_timestamp, int flags)
1740 // Optimize appending index entries at the end.
1741 if (b && entries[b - 1].timestamp < wanted_timestamp)
1746 timestamp = entries[m].timestamp;
1747 if (timestamp >= wanted_timestamp)
1749 if (timestamp <= wanted_timestamp)
1752 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1754 if (!(flags & AVSEEK_FLAG_ANY))
1755 while (m >= 0 && m < nb_entries &&
1756 !(entries[m].flags & AVINDEX_KEYFRAME))
1757 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1759 if (m == nb_entries)
1764 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1766 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1767 wanted_timestamp, flags);
1770 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1771 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1773 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1774 if (stream_index >= 0)
1775 ts = wrap_timestamp(s->streams[stream_index], ts);
1779 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1780 int64_t target_ts, int flags)
1782 AVInputFormat *avif = s->iformat;
1783 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1784 int64_t ts_min, ts_max, ts;
1789 if (stream_index < 0)
1792 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1795 ts_min = AV_NOPTS_VALUE;
1796 pos_limit = -1; // GCC falsely says it may be uninitialized.
1798 st = s->streams[stream_index];
1799 if (st->index_entries) {
1802 /* FIXME: Whole function must be checked for non-keyframe entries in
1803 * index case, especially read_timestamp(). */
1804 index = av_index_search_timestamp(st, target_ts,
1805 flags | AVSEEK_FLAG_BACKWARD);
1806 index = FFMAX(index, 0);
1807 e = &st->index_entries[index];
1809 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1811 ts_min = e->timestamp;
1812 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1813 pos_min, av_ts2str(ts_min));
1815 av_assert1(index == 0);
1818 index = av_index_search_timestamp(st, target_ts,
1819 flags & ~AVSEEK_FLAG_BACKWARD);
1820 av_assert0(index < st->nb_index_entries);
1822 e = &st->index_entries[index];
1823 av_assert1(e->timestamp >= target_ts);
1825 ts_max = e->timestamp;
1826 pos_limit = pos_max - e->min_distance;
1827 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1828 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1832 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1833 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1838 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1841 ff_read_frame_flush(s);
1842 ff_update_cur_dts(s, st, ts);
1847 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1848 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1850 int64_t step = 1024;
1851 int64_t limit, ts_max;
1852 int64_t filesize = avio_size(s->pb);
1853 int64_t pos_max = filesize - 1;
1856 pos_max = FFMAX(0, (pos_max) - step);
1857 ts_max = ff_read_timestamp(s, stream_index,
1858 &pos_max, limit, read_timestamp);
1860 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1861 if (ts_max == AV_NOPTS_VALUE)
1865 int64_t tmp_pos = pos_max + 1;
1866 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1867 &tmp_pos, INT64_MAX, read_timestamp);
1868 if (tmp_ts == AV_NOPTS_VALUE)
1870 av_assert0(tmp_pos > pos_max);
1873 if (tmp_pos >= filesize)
1885 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1886 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1887 int64_t ts_min, int64_t ts_max,
1888 int flags, int64_t *ts_ret,
1889 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1890 int64_t *, int64_t))
1897 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1899 if (ts_min == AV_NOPTS_VALUE) {
1900 pos_min = s->data_offset;
1901 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1902 if (ts_min == AV_NOPTS_VALUE)
1906 if (ts_min >= target_ts) {
1911 if (ts_max == AV_NOPTS_VALUE) {
1912 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1914 pos_limit = pos_max;
1917 if (ts_max <= target_ts) {
1922 if (ts_min > ts_max)
1924 else if (ts_min == ts_max)
1925 pos_limit = pos_min;
1928 while (pos_min < pos_limit) {
1930 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1931 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1932 assert(pos_limit <= pos_max);
1934 if (no_change == 0) {
1935 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1936 // interpolate position (better than dichotomy)
1937 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1939 pos_min - approximate_keyframe_distance;
1940 } else if (no_change == 1) {
1941 // bisection if interpolation did not change min / max pos last time
1942 pos = (pos_min + pos_limit) >> 1;
1944 /* linear search if bisection failed, can only happen if there
1945 * are very few or no keyframes between min/max */
1950 else if (pos > pos_limit)
1954 // May pass pos_limit instead of -1.
1955 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1960 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1961 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1962 pos_min, pos, pos_max,
1963 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1964 pos_limit, start_pos, no_change);
1965 if (ts == AV_NOPTS_VALUE) {
1966 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1969 assert(ts != AV_NOPTS_VALUE);
1970 if (target_ts <= ts) {
1971 pos_limit = start_pos - 1;
1975 if (target_ts >= ts) {
1981 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1982 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1985 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1987 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1988 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1989 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1995 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1996 int64_t pos, int flags)
1998 int64_t pos_min, pos_max;
2000 pos_min = s->data_offset;
2001 pos_max = avio_size(s->pb) - 1;
2005 else if (pos > pos_max)
2008 avio_seek(s->pb, pos, SEEK_SET);
2010 s->io_repositioned = 1;
2015 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2016 int64_t timestamp, int flags)
2023 st = s->streams[stream_index];
2025 index = av_index_search_timestamp(st, timestamp, flags);
2027 if (index < 0 && st->nb_index_entries &&
2028 timestamp < st->index_entries[0].timestamp)
2031 if (index < 0 || index == st->nb_index_entries - 1) {
2035 if (st->nb_index_entries) {
2036 av_assert0(st->index_entries);
2037 ie = &st->index_entries[st->nb_index_entries - 1];
2038 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2040 ff_update_cur_dts(s, st, ie->timestamp);
2042 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2048 read_status = av_read_frame(s, &pkt);
2049 } while (read_status == AVERROR(EAGAIN));
2050 if (read_status < 0)
2052 av_free_packet(&pkt);
2053 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2054 if (pkt.flags & AV_PKT_FLAG_KEY)
2056 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2057 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);
2062 index = av_index_search_timestamp(st, timestamp, flags);
2067 ff_read_frame_flush(s);
2068 if (s->iformat->read_seek)
2069 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2071 ie = &st->index_entries[index];
2072 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2074 ff_update_cur_dts(s, st, ie->timestamp);
2079 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2080 int64_t timestamp, int flags)
2085 if (flags & AVSEEK_FLAG_BYTE) {
2086 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2088 ff_read_frame_flush(s);
2089 return seek_frame_byte(s, stream_index, timestamp, flags);
2092 if (stream_index < 0) {
2093 stream_index = av_find_default_stream_index(s);
2094 if (stream_index < 0)
2097 st = s->streams[stream_index];
2098 /* timestamp for default must be expressed in AV_TIME_BASE units */
2099 timestamp = av_rescale(timestamp, st->time_base.den,
2100 AV_TIME_BASE * (int64_t) st->time_base.num);
2103 /* first, we try the format specific seek */
2104 if (s->iformat->read_seek) {
2105 ff_read_frame_flush(s);
2106 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2112 if (s->iformat->read_timestamp &&
2113 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2114 ff_read_frame_flush(s);
2115 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2116 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2117 ff_read_frame_flush(s);
2118 return seek_frame_generic(s, stream_index, timestamp, flags);
2123 int av_seek_frame(AVFormatContext *s, int stream_index,
2124 int64_t timestamp, int flags)
2128 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2129 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2130 if ((flags & AVSEEK_FLAG_BACKWARD))
2134 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2135 flags & ~AVSEEK_FLAG_BACKWARD);
2138 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2141 ret = avformat_queue_attached_pictures(s);
2146 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2147 int64_t ts, int64_t max_ts, int flags)
2149 if (min_ts > ts || max_ts < ts)
2151 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2152 return AVERROR(EINVAL);
2155 flags |= AVSEEK_FLAG_ANY;
2156 flags &= ~AVSEEK_FLAG_BACKWARD;
2158 if (s->iformat->read_seek2) {
2160 ff_read_frame_flush(s);
2162 if (stream_index == -1 && s->nb_streams == 1) {
2163 AVRational time_base = s->streams[0]->time_base;
2164 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2165 min_ts = av_rescale_rnd(min_ts, time_base.den,
2166 time_base.num * (int64_t)AV_TIME_BASE,
2167 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2168 max_ts = av_rescale_rnd(max_ts, time_base.den,
2169 time_base.num * (int64_t)AV_TIME_BASE,
2170 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2173 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2177 ret = avformat_queue_attached_pictures(s);
2181 if (s->iformat->read_timestamp) {
2182 // try to seek via read_timestamp()
2185 // Fall back on old API if new is not implemented but old is.
2186 // Note the old API has somewhat different semantics.
2187 if (s->iformat->read_seek || 1) {
2188 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2189 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2190 if (ret<0 && ts != min_ts && max_ts != ts) {
2191 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2193 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2198 // try some generic seek like seek_frame_generic() but with new ts semantics
2199 return -1; //unreachable
2202 /*******************************************************/
2205 * Return TRUE if the stream has accurate duration in any stream.
2207 * @return TRUE if the stream has accurate duration for at least one component.
2209 static int has_duration(AVFormatContext *ic)
2214 for (i = 0; i < ic->nb_streams; i++) {
2215 st = ic->streams[i];
2216 if (st->duration != AV_NOPTS_VALUE)
2219 if (ic->duration != AV_NOPTS_VALUE)
2225 * Estimate the stream timings from the one of each components.
2227 * Also computes the global bitrate if possible.
2229 static void update_stream_timings(AVFormatContext *ic)
2231 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2232 int64_t duration, duration1, filesize;
2237 start_time = INT64_MAX;
2238 start_time_text = INT64_MAX;
2239 end_time = INT64_MIN;
2240 duration = INT64_MIN;
2241 for (i = 0; i < ic->nb_streams; i++) {
2242 st = ic->streams[i];
2243 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2244 start_time1 = av_rescale_q(st->start_time, st->time_base,
2246 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2247 if (start_time1 < start_time_text)
2248 start_time_text = start_time1;
2250 start_time = FFMIN(start_time, start_time1);
2251 end_time1 = AV_NOPTS_VALUE;
2252 if (st->duration != AV_NOPTS_VALUE) {
2253 end_time1 = start_time1 +
2254 av_rescale_q(st->duration, st->time_base,
2256 end_time = FFMAX(end_time, end_time1);
2258 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2259 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2260 p->start_time = start_time1;
2261 if (p->end_time < end_time1)
2262 p->end_time = end_time1;
2265 if (st->duration != AV_NOPTS_VALUE) {
2266 duration1 = av_rescale_q(st->duration, st->time_base,
2268 duration = FFMAX(duration, duration1);
2271 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2272 start_time = start_time_text;
2273 else if (start_time > start_time_text)
2274 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2276 if (start_time != INT64_MAX) {
2277 ic->start_time = start_time;
2278 if (end_time != INT64_MIN) {
2279 if (ic->nb_programs) {
2280 for (i = 0; i < ic->nb_programs; i++) {
2281 p = ic->programs[i];
2282 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2283 duration = FFMAX(duration, p->end_time - p->start_time);
2286 duration = FFMAX(duration, end_time - start_time);
2289 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2290 ic->duration = duration;
2292 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2293 /* compute the bitrate */
2294 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2295 (double) ic->duration;
2296 if (bitrate >= 0 && bitrate <= INT_MAX)
2297 ic->bit_rate = bitrate;
2301 static void fill_all_stream_timings(AVFormatContext *ic)
2306 update_stream_timings(ic);
2307 for (i = 0; i < ic->nb_streams; i++) {
2308 st = ic->streams[i];
2309 if (st->start_time == AV_NOPTS_VALUE) {
2310 if (ic->start_time != AV_NOPTS_VALUE)
2311 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2313 if (ic->duration != AV_NOPTS_VALUE)
2314 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2320 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2322 int64_t filesize, duration;
2323 int i, show_warning = 0;
2326 /* if bit_rate is already set, we believe it */
2327 if (ic->bit_rate <= 0) {
2329 for (i = 0; i < ic->nb_streams; i++) {
2330 st = ic->streams[i];
2331 if (st->codec->bit_rate > 0) {
2332 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2336 bit_rate += st->codec->bit_rate;
2339 ic->bit_rate = bit_rate;
2342 /* if duration is already set, we believe it */
2343 if (ic->duration == AV_NOPTS_VALUE &&
2344 ic->bit_rate != 0) {
2345 filesize = ic->pb ? avio_size(ic->pb) : 0;
2347 for (i = 0; i < ic->nb_streams; i++) {
2348 st = ic->streams[i];
2349 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2350 && st->duration == AV_NOPTS_VALUE) {
2351 duration = av_rescale(8 * filesize, st->time_base.den,
2353 (int64_t) st->time_base.num);
2354 st->duration = duration;
2361 av_log(ic, AV_LOG_WARNING,
2362 "Estimating duration from bitrate, this may be inaccurate\n");
2365 #define DURATION_MAX_READ_SIZE 250000LL
2366 #define DURATION_MAX_RETRY 4
2368 /* only usable for MPEG-PS streams */
2369 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2371 AVPacket pkt1, *pkt = &pkt1;
2373 int read_size, i, ret;
2375 int64_t filesize, offset, duration;
2378 /* flush packet queue */
2379 flush_packet_queue(ic);
2381 for (i = 0; i < ic->nb_streams; i++) {
2382 st = ic->streams[i];
2383 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2384 av_log(st->codec, AV_LOG_WARNING,
2385 "start time is not set in estimate_timings_from_pts\n");
2388 av_parser_close(st->parser);
2393 /* estimate the end time (duration) */
2394 /* XXX: may need to support wrapping */
2395 filesize = ic->pb ? avio_size(ic->pb) : 0;
2396 end_time = AV_NOPTS_VALUE;
2398 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2402 avio_seek(ic->pb, offset, SEEK_SET);
2405 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2409 ret = ff_read_packet(ic, pkt);
2410 } while (ret == AVERROR(EAGAIN));
2413 read_size += pkt->size;
2414 st = ic->streams[pkt->stream_index];
2415 if (pkt->pts != AV_NOPTS_VALUE &&
2416 (st->start_time != AV_NOPTS_VALUE ||
2417 st->first_dts != AV_NOPTS_VALUE)) {
2418 duration = end_time = pkt->pts;
2419 if (st->start_time != AV_NOPTS_VALUE)
2420 duration -= st->start_time;
2422 duration -= st->first_dts;
2424 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2425 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2426 st->duration = duration;
2427 st->info->last_duration = duration;
2430 av_free_packet(pkt);
2432 } while (end_time == AV_NOPTS_VALUE &&
2433 filesize > (DURATION_MAX_READ_SIZE << retry) &&
2434 ++retry <= DURATION_MAX_RETRY);
2436 fill_all_stream_timings(ic);
2438 avio_seek(ic->pb, old_offset, SEEK_SET);
2439 for (i = 0; i < ic->nb_streams; i++) {
2440 st = ic->streams[i];
2441 st->cur_dts = st->first_dts;
2442 st->last_IP_pts = AV_NOPTS_VALUE;
2446 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2450 /* get the file size, if possible */
2451 if (ic->iformat->flags & AVFMT_NOFILE) {
2454 file_size = avio_size(ic->pb);
2455 file_size = FFMAX(0, file_size);
2458 if ((!strcmp(ic->iformat->name, "mpeg") ||
2459 !strcmp(ic->iformat->name, "mpegts")) &&
2460 file_size && ic->pb->seekable) {
2461 /* get accurate estimate from the PTSes */
2462 estimate_timings_from_pts(ic, old_offset);
2463 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2464 } else if (has_duration(ic)) {
2465 /* at least one component has timings - we use them for all
2467 fill_all_stream_timings(ic);
2468 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2470 /* less precise: use bitrate info */
2471 estimate_timings_from_bit_rate(ic);
2472 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2474 update_stream_timings(ic);
2478 AVStream av_unused *st;
2479 for (i = 0; i < ic->nb_streams; i++) {
2480 st = ic->streams[i];
2481 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2482 (double) st->start_time / AV_TIME_BASE,
2483 (double) st->duration / AV_TIME_BASE);
2486 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2487 (double) ic->start_time / AV_TIME_BASE,
2488 (double) ic->duration / AV_TIME_BASE,
2489 ic->bit_rate / 1000);
2493 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2495 AVCodecContext *avctx = st->codec;
2497 #define FAIL(errmsg) do { \
2499 *errmsg_ptr = errmsg; \
2503 switch (avctx->codec_type) {
2504 case AVMEDIA_TYPE_AUDIO:
2505 if (!avctx->frame_size && determinable_frame_size(avctx))
2506 FAIL("unspecified frame size");
2507 if (st->info->found_decoder >= 0 &&
2508 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2509 FAIL("unspecified sample format");
2510 if (!avctx->sample_rate)
2511 FAIL("unspecified sample rate");
2512 if (!avctx->channels)
2513 FAIL("unspecified number of channels");
2514 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2515 FAIL("no decodable DTS frames");
2517 case AVMEDIA_TYPE_VIDEO:
2519 FAIL("unspecified size");
2520 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2521 FAIL("unspecified pixel format");
2522 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2523 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2524 FAIL("no frame in rv30/40 and no sar");
2526 case AVMEDIA_TYPE_SUBTITLE:
2527 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2528 FAIL("unspecified size");
2530 case AVMEDIA_TYPE_DATA:
2531 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2534 if (avctx->codec_id == AV_CODEC_ID_NONE)
2535 FAIL("unknown codec");
2539 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2540 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2541 AVDictionary **options)
2543 const AVCodec *codec;
2544 int got_picture = 1, ret = 0;
2545 AVFrame *frame = av_frame_alloc();
2546 AVSubtitle subtitle;
2547 AVPacket pkt = *avpkt;
2550 return AVERROR(ENOMEM);
2552 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2553 AVDictionary *thread_opt = NULL;
2555 codec = find_decoder(s, st, st->codec->codec_id);
2558 st->info->found_decoder = -1;
2563 /* Force thread count to 1 since the H.264 decoder will not extract
2564 * SPS and PPS to extradata during multi-threaded decoding. */
2565 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2566 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2568 av_dict_free(&thread_opt);
2570 st->info->found_decoder = -1;
2573 st->info->found_decoder = 1;
2574 } else if (!st->info->found_decoder)
2575 st->info->found_decoder = 1;
2577 if (st->info->found_decoder < 0) {
2582 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2584 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2585 (!st->codec_info_nb_frames &&
2586 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2588 switch (st->codec->codec_type) {
2589 case AVMEDIA_TYPE_VIDEO:
2590 ret = avcodec_decode_video2(st->codec, frame,
2591 &got_picture, &pkt);
2593 case AVMEDIA_TYPE_AUDIO:
2594 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2596 case AVMEDIA_TYPE_SUBTITLE:
2597 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2598 &got_picture, &pkt);
2606 st->nb_decoded_frames++;
2613 if (!pkt.data && !got_picture)
2617 av_frame_free(&frame);
2621 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2623 while (tags->id != AV_CODEC_ID_NONE) {
2631 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2634 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2635 if (tag == tags[i].tag)
2637 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2638 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2640 return AV_CODEC_ID_NONE;
2643 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2648 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2650 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2652 return AV_CODEC_ID_NONE;
2657 if (sflags & (1 << (bps - 1))) {
2660 return AV_CODEC_ID_PCM_S8;
2662 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2664 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2666 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2668 return AV_CODEC_ID_NONE;
2673 return AV_CODEC_ID_PCM_U8;
2675 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2677 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2679 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2681 return AV_CODEC_ID_NONE;
2687 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2690 if (!av_codec_get_tag2(tags, id, &tag))
2695 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2699 for (i = 0; tags && tags[i]; i++) {
2700 const AVCodecTag *codec_tags = tags[i];
2701 while (codec_tags->id != AV_CODEC_ID_NONE) {
2702 if (codec_tags->id == id) {
2703 *tag = codec_tags->tag;
2712 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2715 for (i = 0; tags && tags[i]; i++) {
2716 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2717 if (id != AV_CODEC_ID_NONE)
2720 return AV_CODEC_ID_NONE;
2723 static void compute_chapters_end(AVFormatContext *s)
2726 int64_t max_time = s->duration +
2727 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2729 for (i = 0; i < s->nb_chapters; i++)
2730 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2731 AVChapter *ch = s->chapters[i];
2732 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2736 for (j = 0; j < s->nb_chapters; j++) {
2737 AVChapter *ch1 = s->chapters[j];
2738 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2740 if (j != i && next_start > ch->start && next_start < end)
2743 ch->end = (end == INT64_MAX) ? ch->start : end;
2747 static int get_std_framerate(int i)
2750 return (i + 1) * 1001;
2752 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2755 /* Is the time base unreliable?
2756 * This is a heuristic to balance between quick acceptance of the values in
2757 * the headers vs. some extra checks.
2758 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2759 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2760 * And there are "variable" fps files this needs to detect as well. */
2761 static int tb_unreliable(AVCodecContext *c)
2763 if (c->time_base.den >= 101L * c->time_base.num ||
2764 c->time_base.den < 5L * c->time_base.num ||
2765 // c->codec_tag == AV_RL32("DIVX") ||
2766 // c->codec_tag == AV_RL32("XVID") ||
2767 c->codec_tag == AV_RL32("mp4v") ||
2768 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2769 c->codec_id == AV_CODEC_ID_H264)
2774 #if FF_API_FORMAT_PARAMETERS
2775 int av_find_stream_info(AVFormatContext *ic)
2777 return avformat_find_stream_info(ic, NULL);
2781 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2785 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2786 avctx->extradata_size = 0;
2787 return AVERROR(EINVAL);
2789 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2790 if (avctx->extradata) {
2791 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2792 avctx->extradata_size = size;
2795 avctx->extradata_size = 0;
2796 ret = AVERROR(ENOMEM);
2801 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2803 int ret = ff_alloc_extradata(avctx, size);
2806 ret = avio_read(pb, avctx->extradata, size);
2808 av_freep(&avctx->extradata);
2809 avctx->extradata_size = 0;
2810 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2811 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2817 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2820 int64_t last = st->info->last_dts;
2822 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2823 && ts - (uint64_t)last < INT64_MAX) {
2824 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2825 int64_t duration = ts - last;
2827 if (!st->info->duration_error)
2828 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2829 if (!st->info->duration_error)
2830 return AVERROR(ENOMEM);
2832 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2833 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2834 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2835 if (st->info->duration_error[0][1][i] < 1e10) {
2836 int framerate = get_std_framerate(i);
2837 double sdts = dts*framerate/(1001*12);
2838 for (j= 0; j<2; j++) {
2839 int64_t ticks = llrint(sdts+j*0.5);
2840 double error= sdts - ticks + j*0.5;
2841 st->info->duration_error[j][0][i] += error;
2842 st->info->duration_error[j][1][i] += error*error;
2846 st->info->duration_count++;
2847 st->info->rfps_duration_sum += duration;
2849 if (st->info->duration_count % 10 == 0) {
2850 int n = st->info->duration_count;
2851 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2852 if (st->info->duration_error[0][1][i] < 1e10) {
2853 double a0 = st->info->duration_error[0][0][i] / n;
2854 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2855 double a1 = st->info->duration_error[1][0][i] / n;
2856 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2857 if (error0 > 0.04 && error1 > 0.04) {
2858 st->info->duration_error[0][1][i] = 2e10;
2859 st->info->duration_error[1][1][i] = 2e10;
2865 // ignore the first 4 values, they might have some random jitter
2866 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2867 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2869 if (ts != AV_NOPTS_VALUE)
2870 st->info->last_dts = ts;
2875 void ff_rfps_calculate(AVFormatContext *ic)
2879 for (i = 0; i < ic->nb_streams; i++) {
2880 AVStream *st = ic->streams[i];
2882 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2884 // the check for tb_unreliable() is not completely correct, since this is not about handling
2885 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2886 // ipmovie.c produces.
2887 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)
2888 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);
2889 if (st->info->duration_count>1 && !st->r_frame_rate.num
2890 && tb_unreliable(st->codec)) {
2892 double best_error= 0.01;
2894 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2897 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2899 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2902 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2905 for (k= 0; k<2; k++) {
2906 int n = st->info->duration_count;
2907 double a= st->info->duration_error[k][0][j] / n;
2908 double error= st->info->duration_error[k][1][j]/n - a*a;
2910 if (error < best_error && best_error> 0.000000001) {
2912 num = get_std_framerate(j);
2915 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2918 // do not increase frame rate by more than 1 % in order to match a standard rate.
2919 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2920 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2923 av_freep(&st->info->duration_error);
2924 st->info->last_dts = AV_NOPTS_VALUE;
2925 st->info->duration_count = 0;
2926 st->info->rfps_duration_sum = 0;
2930 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2932 int i, count, ret = 0, j;
2935 AVPacket pkt1, *pkt;
2936 int64_t old_offset = avio_tell(ic->pb);
2937 // new streams might appear, no options for those
2938 int orig_nb_streams = ic->nb_streams;
2939 int flush_codecs = ic->probesize > 0;
2942 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2943 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2945 for (i = 0; i < ic->nb_streams; i++) {
2946 const AVCodec *codec;
2947 AVDictionary *thread_opt = NULL;
2948 st = ic->streams[i];
2950 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2951 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2952 /* if (!st->time_base.num)
2954 if (!st->codec->time_base.num)
2955 st->codec->time_base = st->time_base;
2957 // only for the split stuff
2958 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2959 st->parser = av_parser_init(st->codec->codec_id);
2961 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
2962 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2963 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2964 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2966 } else if (st->need_parsing) {
2967 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2968 "%s, packets or times may be invalid.\n",
2969 avcodec_get_name(st->codec->codec_id));
2972 codec = find_decoder(ic, st, st->codec->codec_id);
2974 /* Force thread count to 1 since the H.264 decoder will not extract
2975 * SPS and PPS to extradata during multi-threaded decoding. */
2976 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2978 /* Ensure that subtitle_header is properly set. */
2979 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2980 && codec && !st->codec->codec) {
2981 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2982 av_log(ic, AV_LOG_WARNING,
2983 "Failed to open codec in av_find_stream_info\n");
2986 // Try to just open decoders, in case this is enough to get parameters.
2987 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2988 if (codec && !st->codec->codec)
2989 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2990 av_log(ic, AV_LOG_WARNING,
2991 "Failed to open codec in av_find_stream_info\n");
2994 av_dict_free(&thread_opt);
2997 for (i = 0; i < ic->nb_streams; i++) {
2998 #if FF_API_R_FRAME_RATE
2999 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3001 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3002 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3008 if (ff_check_interrupt(&ic->interrupt_callback)) {
3010 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3014 /* check if one codec still needs to be handled */
3015 for (i = 0; i < ic->nb_streams; i++) {
3016 int fps_analyze_framecount = 20;
3018 st = ic->streams[i];
3019 if (!has_codec_parameters(st, NULL))
3021 /* If the timebase is coarse (like the usual millisecond precision
3022 * of mkv), we need to analyze more frames to reliably arrive at
3023 * the correct fps. */
3024 if (av_q2d(st->time_base) > 0.0005)
3025 fps_analyze_framecount *= 2;
3026 if (ic->fps_probe_size >= 0)
3027 fps_analyze_framecount = ic->fps_probe_size;
3028 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3029 fps_analyze_framecount = 0;
3030 /* variable fps and no guess at the real fps */
3031 if (tb_unreliable(st->codec) &&
3032 !(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3033 st->info->duration_count < fps_analyze_framecount &&
3034 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3036 if (st->parser && st->parser->parser->split &&
3037 !st->codec->extradata)
3039 if (st->first_dts == AV_NOPTS_VALUE &&
3040 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3041 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3044 if (i == ic->nb_streams) {
3045 /* NOTE: If the format has no header, then we need to read some
3046 * packets to get most of the streams, so we cannot stop here. */
3047 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3048 /* If we found the info for all the codecs, we can stop. */
3050 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3055 /* We did not get all the codec info, but we read too much data. */
3056 if (read_size >= ic->probesize) {
3058 av_log(ic, AV_LOG_DEBUG,
3059 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3060 for (i = 0; i < ic->nb_streams; i++)
3061 if (!ic->streams[i]->r_frame_rate.num &&
3062 ic->streams[i]->info->duration_count <= 1 &&
3063 strcmp(ic->iformat->name, "image2"))
3064 av_log(ic, AV_LOG_WARNING,
3065 "Stream #%d: not enough frames to estimate rate; "
3066 "consider increasing probesize\n", i);
3070 /* NOTE: A new stream can be added there if no header in file
3071 * (AVFMTCTX_NOHEADER). */
3072 ret = read_frame_internal(ic, &pkt1);
3073 if (ret == AVERROR(EAGAIN))
3081 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3082 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3084 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3085 &ic->packet_buffer_end);
3087 ret = AVERROR(ENOMEM);
3088 goto find_stream_info_err;
3090 if ((ret = av_dup_packet(pkt)) < 0)
3091 goto find_stream_info_err;
3094 st = ic->streams[pkt->stream_index];
3095 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3096 read_size += pkt->size;
3098 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3099 /* check for non-increasing dts */
3100 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3101 st->info->fps_last_dts >= pkt->dts) {
3102 av_log(ic, AV_LOG_DEBUG,
3103 "Non-increasing DTS in stream %d: packet %d with DTS "
3104 "%"PRId64", packet %d with DTS %"PRId64"\n",
3105 st->index, st->info->fps_last_dts_idx,
3106 st->info->fps_last_dts, st->codec_info_nb_frames,
3108 st->info->fps_first_dts =
3109 st->info->fps_last_dts = AV_NOPTS_VALUE;
3111 /* Check for a discontinuity in dts. If the difference in dts
3112 * is more than 1000 times the average packet duration in the
3113 * sequence, we treat it as a discontinuity. */
3114 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3115 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3116 (pkt->dts - st->info->fps_last_dts) / 1000 >
3117 (st->info->fps_last_dts - st->info->fps_first_dts) /
3118 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3119 av_log(ic, AV_LOG_WARNING,
3120 "DTS discontinuity in stream %d: packet %d with DTS "
3121 "%"PRId64", packet %d with DTS %"PRId64"\n",
3122 st->index, st->info->fps_last_dts_idx,
3123 st->info->fps_last_dts, st->codec_info_nb_frames,
3125 st->info->fps_first_dts =
3126 st->info->fps_last_dts = AV_NOPTS_VALUE;
3129 /* update stored dts values */
3130 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3131 st->info->fps_first_dts = pkt->dts;
3132 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3134 st->info->fps_last_dts = pkt->dts;
3135 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3137 if (st->codec_info_nb_frames>1) {
3139 if (st->time_base.den > 0)
3140 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3141 if (st->avg_frame_rate.num > 0)
3142 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3145 && st->codec_info_nb_frames>30
3146 && st->info->fps_first_dts != AV_NOPTS_VALUE
3147 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3148 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3150 if (t >= ic->max_analyze_duration) {
3151 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3154 if (pkt->duration) {
3155 st->info->codec_info_duration += pkt->duration;
3156 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3159 #if FF_API_R_FRAME_RATE
3160 ff_rfps_add_frame(ic, st, pkt->dts);
3162 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3163 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3164 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3165 if (ff_alloc_extradata(st->codec, i))
3166 return AVERROR(ENOMEM);
3167 memcpy(st->codec->extradata, pkt->data,
3168 st->codec->extradata_size);
3172 /* If still no information, we try to open the codec and to
3173 * decompress the frame. We try to avoid that in most cases as
3174 * it takes longer and uses more memory. For MPEG-4, we need to
3175 * decompress for QuickTime.
3177 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3178 * least one frame of codec data, this makes sure the codec initializes
3179 * the channel configuration and does not only trust the values from
3181 try_decode_frame(ic, st, pkt,
3182 (options && i < orig_nb_streams) ? &options[i] : NULL);
3184 st->codec_info_nb_frames++;
3189 AVPacket empty_pkt = { 0 };
3191 av_init_packet(&empty_pkt);
3193 for (i = 0; i < ic->nb_streams; i++) {
3195 st = ic->streams[i];
3197 /* flush the decoders */
3198 if (st->info->found_decoder == 1) {
3200 err = try_decode_frame(ic, st, &empty_pkt,
3201 (options && i < orig_nb_streams)
3202 ? &options[i] : NULL);
3203 } while (err > 0 && !has_codec_parameters(st, NULL));
3206 av_log(ic, AV_LOG_INFO,
3207 "decoding for stream %d failed\n", st->index);
3213 // close codecs which were opened in try_decode_frame()
3214 for (i = 0; i < ic->nb_streams; i++) {
3215 st = ic->streams[i];
3216 avcodec_close(st->codec);
3219 ff_rfps_calculate(ic);
3221 for (i = 0; i < ic->nb_streams; i++) {
3222 st = ic->streams[i];
3223 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3224 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3225 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3226 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3227 st->codec->codec_tag= tag;
3230 /* estimate average framerate if not set by demuxer */
3231 if (st->info->codec_info_duration_fields &&
3232 !st->avg_frame_rate.num &&
3233 st->info->codec_info_duration) {
3235 double best_error = 0.01;
3237 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3238 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3239 st->info->codec_info_duration < 0)
3241 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3242 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3243 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3245 /* Round guessed framerate to a "standard" framerate if it's
3246 * within 1% of the original estimate. */
3247 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3248 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3249 double error = fabs(av_q2d(st->avg_frame_rate) /
3250 av_q2d(std_fps) - 1);
3252 if (error < best_error) {
3254 best_fps = std_fps.num;
3258 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3259 best_fps, 12 * 1001, INT_MAX);
3262 if (!st->r_frame_rate.num) {
3263 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3264 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3265 st->r_frame_rate.num = st->codec->time_base.den;
3266 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3268 st->r_frame_rate.num = st->time_base.den;
3269 st->r_frame_rate.den = st->time_base.num;
3272 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3273 if (!st->codec->bits_per_coded_sample)
3274 st->codec->bits_per_coded_sample =
3275 av_get_bits_per_sample(st->codec->codec_id);
3276 // set stream disposition based on audio service type
3277 switch (st->codec->audio_service_type) {
3278 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3279 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3281 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3282 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3284 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3285 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3287 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3288 st->disposition = AV_DISPOSITION_COMMENT;
3290 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3291 st->disposition = AV_DISPOSITION_KARAOKE;
3298 estimate_timings(ic, old_offset);
3300 if (ret >= 0 && ic->nb_streams)
3301 /* We could not have all the codec parameters before EOF. */
3303 for (i = 0; i < ic->nb_streams; i++) {
3305 st = ic->streams[i];
3306 if (!has_codec_parameters(st, &errmsg)) {
3308 avcodec_string(buf, sizeof(buf), st->codec, 0);
3309 av_log(ic, AV_LOG_WARNING,
3310 "Could not find codec parameters for stream %d (%s): %s\n"
3311 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3318 compute_chapters_end(ic);
3320 find_stream_info_err:
3321 for (i = 0; i < ic->nb_streams; i++) {
3322 st = ic->streams[i];
3323 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3324 ic->streams[i]->codec->thread_count = 0;
3326 av_freep(&st->info->duration_error);
3327 av_freep(&ic->streams[i]->info);
3330 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3331 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3335 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3339 for (i = 0; i < ic->nb_programs; i++) {
3340 if (ic->programs[i] == last) {
3344 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3345 if (ic->programs[i]->stream_index[j] == s)
3346 return ic->programs[i];
3352 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3353 int wanted_stream_nb, int related_stream,
3354 AVCodec **decoder_ret, int flags)
3356 int i, nb_streams = ic->nb_streams;
3357 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3358 unsigned *program = NULL;
3359 AVCodec *decoder = NULL, *best_decoder = NULL;
3361 if (related_stream >= 0 && wanted_stream_nb < 0) {
3362 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3364 program = p->stream_index;
3365 nb_streams = p->nb_stream_indexes;
3368 for (i = 0; i < nb_streams; i++) {
3369 int real_stream_index = program ? program[i] : i;
3370 AVStream *st = ic->streams[real_stream_index];
3371 AVCodecContext *avctx = st->codec;
3372 if (avctx->codec_type != type)
3374 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3376 if (wanted_stream_nb != real_stream_index &&
3377 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3378 AV_DISPOSITION_VISUAL_IMPAIRED))
3380 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3383 decoder = find_decoder(ic, st, st->codec->codec_id);
3386 ret = AVERROR_DECODER_NOT_FOUND;
3390 count = st->codec_info_nb_frames;
3391 bitrate = avctx->bit_rate;
3392 multiframe = FFMIN(5, count);
3393 if ((best_multiframe > multiframe) ||
3394 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3395 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3398 best_bitrate = bitrate;
3399 best_multiframe = multiframe;
3400 ret = real_stream_index;
3401 best_decoder = decoder;
3402 if (program && i == nb_streams - 1 && ret < 0) {
3404 nb_streams = ic->nb_streams;
3405 /* no related stream found, try again with everything */
3410 *decoder_ret = best_decoder;
3414 /*******************************************************/
3416 int av_read_play(AVFormatContext *s)
3418 if (s->iformat->read_play)
3419 return s->iformat->read_play(s);
3421 return avio_pause(s->pb, 0);
3422 return AVERROR(ENOSYS);
3425 int av_read_pause(AVFormatContext *s)
3427 if (s->iformat->read_pause)
3428 return s->iformat->read_pause(s);
3430 return avio_pause(s->pb, 1);
3431 return AVERROR(ENOSYS);
3434 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3435 av_assert0(s->nb_streams>0);
3436 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3439 av_parser_close(st->parser);
3441 if (st->attached_pic.data)
3442 av_free_packet(&st->attached_pic);
3443 av_dict_free(&st->metadata);
3444 av_freep(&st->probe_data.buf);
3445 av_freep(&st->index_entries);
3446 av_freep(&st->codec->extradata);
3447 av_freep(&st->codec->subtitle_header);
3448 av_freep(&st->codec);
3449 av_freep(&st->priv_data);
3451 av_freep(&st->info->duration_error);
3452 av_freep(&st->info);
3453 av_freep(&s->streams[ --s->nb_streams ]);
3456 void avformat_free_context(AVFormatContext *s)
3464 if (s->iformat && s->iformat->priv_class && s->priv_data)
3465 av_opt_free(s->priv_data);
3467 for (i = s->nb_streams - 1; i >= 0; i--) {
3468 ff_free_stream(s, s->streams[i]);
3470 for (i = s->nb_programs - 1; i >= 0; i--) {
3471 av_dict_free(&s->programs[i]->metadata);
3472 av_freep(&s->programs[i]->stream_index);
3473 av_freep(&s->programs[i]);
3475 av_freep(&s->programs);
3476 av_freep(&s->priv_data);
3477 while (s->nb_chapters--) {
3478 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3479 av_freep(&s->chapters[s->nb_chapters]);
3481 av_freep(&s->chapters);
3482 av_dict_free(&s->metadata);
3483 av_freep(&s->streams);
3484 av_freep(&s->internal);
3488 #if FF_API_CLOSE_INPUT_FILE
3489 void av_close_input_file(AVFormatContext *s)
3491 avformat_close_input(&s);
3495 void avformat_close_input(AVFormatContext **ps)
3506 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3507 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3510 flush_packet_queue(s);
3513 if (s->iformat->read_close)
3514 s->iformat->read_close(s);
3516 avformat_free_context(s);
3523 #if FF_API_NEW_STREAM
3524 AVStream *av_new_stream(AVFormatContext *s, int id)
3526 AVStream *st = avformat_new_stream(s, NULL);
3533 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3539 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3541 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3544 s->streams = streams;
3546 st = av_mallocz(sizeof(AVStream));
3549 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3553 st->info->last_dts = AV_NOPTS_VALUE;
3555 st->codec = avcodec_alloc_context3(c);
3557 /* no default bitrate if decoding */
3558 st->codec->bit_rate = 0;
3559 st->index = s->nb_streams;
3560 st->start_time = AV_NOPTS_VALUE;
3561 st->duration = AV_NOPTS_VALUE;
3562 /* we set the current DTS to 0 so that formats without any timestamps
3563 * but durations get some timestamps, formats with some unknown
3564 * timestamps have their first few packets buffered and the
3565 * timestamps corrected before they are returned to the user */
3566 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3567 st->first_dts = AV_NOPTS_VALUE;
3568 st->probe_packets = MAX_PROBE_PACKETS;
3569 st->pts_wrap_reference = AV_NOPTS_VALUE;
3570 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3572 /* default pts setting is MPEG-like */
3573 avpriv_set_pts_info(st, 33, 1, 90000);
3574 st->last_IP_pts = AV_NOPTS_VALUE;
3575 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3576 st->pts_buffer[i] = AV_NOPTS_VALUE;
3578 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3580 #if FF_API_R_FRAME_RATE
3581 st->info->last_dts = AV_NOPTS_VALUE;
3583 st->info->fps_first_dts = AV_NOPTS_VALUE;
3584 st->info->fps_last_dts = AV_NOPTS_VALUE;
3586 s->streams[s->nb_streams++] = st;
3590 AVProgram *av_new_program(AVFormatContext *ac, int id)
3592 AVProgram *program = NULL;
3595 av_dlog(ac, "new_program: id=0x%04x\n", id);
3597 for (i = 0; i < ac->nb_programs; i++)
3598 if (ac->programs[i]->id == id)
3599 program = ac->programs[i];
3602 program = av_mallocz(sizeof(AVProgram));
3605 dynarray_add(&ac->programs, &ac->nb_programs, program);
3606 program->discard = AVDISCARD_NONE;
3609 program->pts_wrap_reference = AV_NOPTS_VALUE;
3610 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3612 program->start_time =
3613 program->end_time = AV_NOPTS_VALUE;
3618 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3619 int64_t start, int64_t end, const char *title)
3621 AVChapter *chapter = NULL;
3624 for (i = 0; i < s->nb_chapters; i++)
3625 if (s->chapters[i]->id == id)
3626 chapter = s->chapters[i];
3629 chapter = av_mallocz(sizeof(AVChapter));
3632 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3634 av_dict_set(&chapter->metadata, "title", title, 0);
3636 chapter->time_base = time_base;
3637 chapter->start = start;
3643 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3646 AVProgram *program = NULL;
3649 if (idx >= ac->nb_streams) {
3650 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3654 for (i = 0; i < ac->nb_programs; i++) {
3655 if (ac->programs[i]->id != progid)
3657 program = ac->programs[i];
3658 for (j = 0; j < program->nb_stream_indexes; j++)
3659 if (program->stream_index[j] == idx)
3662 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3665 program->stream_index = tmp;
3666 program->stream_index[program->nb_stream_indexes++] = idx;
3671 static void print_fps(double d, const char *postfix)
3673 uint64_t v = lrintf(d * 100);
3675 av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3676 else if (v % (100 * 1000))
3677 av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3679 av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3682 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3684 if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3685 AVDictionaryEntry *tag = NULL;
3687 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3688 while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3689 if (strcmp("language", tag->key)) {
3690 const char *p = tag->value;
3691 av_log(ctx, AV_LOG_INFO,
3692 "%s %-16s: ", indent, tag->key);
3695 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3696 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3697 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3699 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3700 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3703 av_log(ctx, AV_LOG_INFO, "\n");
3708 /* "user interface" functions */
3709 static void dump_stream_format(AVFormatContext *ic, int i,
3710 int index, int is_output)
3713 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3714 AVStream *st = ic->streams[i];
3715 int g = av_gcd(st->time_base.num, st->time_base.den);
3716 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3717 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3718 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3719 /* the pid is an important information, so we display it */
3720 /* XXX: add a generic system */
3721 if (flags & AVFMT_SHOW_IDS)
3722 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3724 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3725 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3726 st->time_base.num / g, st->time_base.den / g);
3727 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3728 if (st->sample_aspect_ratio.num && // default
3729 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3730 AVRational display_aspect_ratio;
3731 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3732 st->codec->width * st->sample_aspect_ratio.num,
3733 st->codec->height * st->sample_aspect_ratio.den,
3735 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3736 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3737 display_aspect_ratio.num, display_aspect_ratio.den);
3739 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3740 if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3741 print_fps(av_q2d(st->avg_frame_rate), "fps");
3742 #if FF_API_R_FRAME_RATE
3743 if (st->r_frame_rate.den && st->r_frame_rate.num)
3744 print_fps(av_q2d(st->r_frame_rate), "tbr");
3746 if (st->time_base.den && st->time_base.num)
3747 print_fps(1 / av_q2d(st->time_base), "tbn");
3748 if (st->codec->time_base.den && st->codec->time_base.num)
3749 print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3751 if (st->disposition & AV_DISPOSITION_DEFAULT)
3752 av_log(NULL, AV_LOG_INFO, " (default)");
3753 if (st->disposition & AV_DISPOSITION_DUB)
3754 av_log(NULL, AV_LOG_INFO, " (dub)");
3755 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3756 av_log(NULL, AV_LOG_INFO, " (original)");
3757 if (st->disposition & AV_DISPOSITION_COMMENT)
3758 av_log(NULL, AV_LOG_INFO, " (comment)");
3759 if (st->disposition & AV_DISPOSITION_LYRICS)
3760 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3761 if (st->disposition & AV_DISPOSITION_KARAOKE)
3762 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3763 if (st->disposition & AV_DISPOSITION_FORCED)
3764 av_log(NULL, AV_LOG_INFO, " (forced)");
3765 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3766 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3767 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3768 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3769 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3770 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3771 av_log(NULL, AV_LOG_INFO, "\n");
3772 dump_metadata(NULL, st->metadata, " ");
3775 void av_dump_format(AVFormatContext *ic, int index,
3776 const char *url, int is_output)
3779 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3780 if (ic->nb_streams && !printed)
3783 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3784 is_output ? "Output" : "Input",
3786 is_output ? ic->oformat->name : ic->iformat->name,
3787 is_output ? "to" : "from", url);
3788 dump_metadata(NULL, ic->metadata, " ");
3790 av_log(NULL, AV_LOG_INFO, " Duration: ");
3791 if (ic->duration != AV_NOPTS_VALUE) {
3792 int hours, mins, secs, us;
3793 int64_t duration = ic->duration + 5000;
3794 secs = duration / AV_TIME_BASE;
3795 us = duration % AV_TIME_BASE;
3800 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3801 (100 * us) / AV_TIME_BASE);
3803 av_log(NULL, AV_LOG_INFO, "N/A");
3805 if (ic->start_time != AV_NOPTS_VALUE) {
3807 av_log(NULL, AV_LOG_INFO, ", start: ");
3808 secs = ic->start_time / AV_TIME_BASE;
3809 us = abs(ic->start_time % AV_TIME_BASE);
3810 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3811 secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3813 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3815 av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3817 av_log(NULL, AV_LOG_INFO, "N/A");
3818 av_log(NULL, AV_LOG_INFO, "\n");
3820 for (i = 0; i < ic->nb_chapters; i++) {
3821 AVChapter *ch = ic->chapters[i];
3822 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3823 av_log(NULL, AV_LOG_INFO,
3824 "start %f, ", ch->start * av_q2d(ch->time_base));
3825 av_log(NULL, AV_LOG_INFO,
3826 "end %f\n", ch->end * av_q2d(ch->time_base));
3828 dump_metadata(NULL, ch->metadata, " ");
3830 if (ic->nb_programs) {
3831 int j, k, total = 0;
3832 for (j = 0; j < ic->nb_programs; j++) {
3833 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3835 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3836 name ? name->value : "");
3837 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3838 for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3839 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3841 printed[ic->programs[j]->stream_index[k]] = 1;
3843 total += ic->programs[j]->nb_stream_indexes;
3845 if (total < ic->nb_streams)
3846 av_log(NULL, AV_LOG_INFO, " No Program\n");
3848 for (i = 0; i < ic->nb_streams; i++)
3850 dump_stream_format(ic, i, index, is_output);
3855 uint64_t ff_ntp_time(void)
3857 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3860 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3863 char *q, buf1[20], c;
3864 int nd, len, percentd_found;
3876 while (av_isdigit(*p))
3877 nd = nd * 10 + *p++ - '0';
3879 } while (av_isdigit(c));
3888 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3890 if ((q - buf + len) > buf_size - 1)
3892 memcpy(q, buf1, len);
3900 if ((q - buf) < buf_size - 1)
3904 if (!percentd_found)
3913 #define HEXDUMP_PRINT(...) \
3916 av_log(avcl, level, __VA_ARGS__); \
3918 fprintf(f, __VA_ARGS__); \
3921 static void hex_dump_internal(void *avcl, FILE *f, int level,
3922 const uint8_t *buf, int size)
3926 for (i = 0; i < size; i += 16) {
3930 HEXDUMP_PRINT("%08x ", i);
3931 for (j = 0; j < 16; j++) {
3933 HEXDUMP_PRINT(" %02x", buf[i + j]);
3938 for (j = 0; j < len; j++) {
3940 if (c < ' ' || c > '~')
3942 HEXDUMP_PRINT("%c", c);
3944 HEXDUMP_PRINT("\n");
3948 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3950 hex_dump_internal(NULL, f, 0, buf, size);
3953 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3955 hex_dump_internal(avcl, NULL, level, buf, size);
3958 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
3959 int dump_payload, AVRational time_base)
3961 HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
3962 HEXDUMP_PRINT(" keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
3963 HEXDUMP_PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3964 /* DTS is _always_ valid after av_read_frame() */
3965 HEXDUMP_PRINT(" dts=");
3966 if (pkt->dts == AV_NOPTS_VALUE)
3967 HEXDUMP_PRINT("N/A");
3969 HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3970 /* PTS may not be known if B-frames are present. */
3971 HEXDUMP_PRINT(" pts=");
3972 if (pkt->pts == AV_NOPTS_VALUE)
3973 HEXDUMP_PRINT("N/A");
3975 HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3976 HEXDUMP_PRINT("\n");
3977 HEXDUMP_PRINT(" size=%d\n", pkt->size);
3979 av_hex_dump(f, pkt->data, pkt->size);
3982 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3984 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3987 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3990 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3993 void av_url_split(char *proto, int proto_size,
3994 char *authorization, int authorization_size,
3995 char *hostname, int hostname_size,
3996 int *port_ptr, char *path, int path_size, const char *url)
3998 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4004 if (authorization_size > 0)
4005 authorization[0] = 0;
4006 if (hostname_size > 0)
4011 /* parse protocol */
4012 if ((p = strchr(url, ':'))) {
4013 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4020 /* no protocol means plain filename */
4021 av_strlcpy(path, url, path_size);
4025 /* separate path from hostname */
4026 ls = strchr(p, '/');
4027 ls2 = strchr(p, '?');
4031 ls = FFMIN(ls, ls2);
4033 av_strlcpy(path, ls, path_size);
4035 ls = &p[strlen(p)]; // XXX
4037 /* the rest is hostname, use that to parse auth/port */
4039 /* authorization (user[:pass]@hostname) */
4041 while ((at = strchr(p, '@')) && at < ls) {
4042 av_strlcpy(authorization, at2,
4043 FFMIN(authorization_size, at + 1 - at2));
4044 p = at + 1; /* skip '@' */
4047 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4049 av_strlcpy(hostname, p + 1,
4050 FFMIN(hostname_size, brk - p));
4051 if (brk[1] == ':' && port_ptr)
4052 *port_ptr = atoi(brk + 2);
4053 } else if ((col = strchr(p, ':')) && col < ls) {
4054 av_strlcpy(hostname, p,
4055 FFMIN(col + 1 - p, hostname_size));
4057 *port_ptr = atoi(col + 1);
4059 av_strlcpy(hostname, p,
4060 FFMIN(ls + 1 - p, hostname_size));
4064 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4067 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4070 'C', 'D', 'E', 'F' };
4071 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4074 'c', 'd', 'e', 'f' };
4075 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4077 for (i = 0; i < s; i++) {
4078 buff[i * 2] = hex_table[src[i] >> 4];
4079 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4085 int ff_hex_to_data(uint8_t *data, const char *p)
4092 p += strspn(p, SPACE_CHARS);
4095 c = av_toupper((unsigned char) *p++);
4096 if (c >= '0' && c <= '9')
4098 else if (c >= 'A' && c <= 'F')
4113 #if FF_API_SET_PTS_INFO
4114 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4115 unsigned int pts_num, unsigned int pts_den)
4117 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4121 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4122 unsigned int pts_num, unsigned int pts_den)
4125 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4126 if (new_tb.num != pts_num)
4127 av_log(NULL, AV_LOG_DEBUG,
4128 "st:%d removing common factor %d from timebase\n",
4129 s->index, pts_num / new_tb.num);
4131 av_log(NULL, AV_LOG_WARNING,
4132 "st:%d has too large timebase, reducing\n", s->index);
4134 if (new_tb.num <= 0 || new_tb.den <= 0) {
4135 av_log(NULL, AV_LOG_ERROR,
4136 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4137 new_tb.num, new_tb.den,
4141 s->time_base = new_tb;
4142 av_codec_set_pkt_timebase(s->codec, new_tb);
4143 s->pts_wrap_bits = pts_wrap_bits;
4146 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4149 const char *ptr = str;
4151 /* Parse key=value pairs. */
4154 char *dest = NULL, *dest_end;
4155 int key_len, dest_len = 0;
4157 /* Skip whitespace and potential commas. */
4158 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4165 if (!(ptr = strchr(key, '=')))
4168 key_len = ptr - key;
4170 callback_get_buf(context, key, key_len, &dest, &dest_len);
4171 dest_end = dest + dest_len - 1;
4175 while (*ptr && *ptr != '\"') {
4179 if (dest && dest < dest_end)
4183 if (dest && dest < dest_end)
4191 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4192 if (dest && dest < dest_end)
4200 int ff_find_stream_index(AVFormatContext *s, int id)
4203 for (i = 0; i < s->nb_streams; i++)
4204 if (s->streams[i]->id == id)
4209 int64_t ff_iso8601_to_unix_time(const char *datestr)
4211 struct tm time1 = { 0 }, time2 = { 0 };
4213 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4214 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4216 return av_timegm(&time2);
4218 return av_timegm(&time1);
4221 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4225 if (ofmt->query_codec)
4226 return ofmt->query_codec(codec_id, std_compliance);
4227 else if (ofmt->codec_tag)
4228 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4229 else if (codec_id == ofmt->video_codec ||
4230 codec_id == ofmt->audio_codec ||
4231 codec_id == ofmt->subtitle_codec)
4234 return AVERROR_PATCHWELCOME;
4237 int avformat_network_init(void)
4241 ff_network_inited_globally = 1;
4242 if ((ret = ff_network_init()) < 0)
4249 int avformat_network_deinit(void)
4258 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4259 uint64_t channel_layout, int32_t sample_rate,
4260 int32_t width, int32_t height)
4266 return AVERROR(EINVAL);
4269 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4271 if (channel_layout) {
4273 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4277 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4279 if (width || height) {
4281 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4283 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4285 return AVERROR(ENOMEM);
4286 bytestream_put_le32(&data, flags);
4288 bytestream_put_le32(&data, channels);
4290 bytestream_put_le64(&data, channel_layout);
4292 bytestream_put_le32(&data, sample_rate);
4293 if (width || height) {
4294 bytestream_put_le32(&data, width);
4295 bytestream_put_le32(&data, height);
4300 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4302 AVRational undef = {0, 1};
4303 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4304 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4305 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4307 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4308 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4309 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4310 stream_sample_aspect_ratio = undef;
4312 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4313 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4314 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4315 frame_sample_aspect_ratio = undef;
4317 if (stream_sample_aspect_ratio.num)
4318 return stream_sample_aspect_ratio;
4320 return frame_sample_aspect_ratio;
4323 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4325 AVRational fr = st->r_frame_rate;
4327 if (st->codec->ticks_per_frame > 1) {
4328 AVRational codec_fr = av_inv_q(st->codec->time_base);
4329 AVRational avg_fr = st->avg_frame_rate;
4330 codec_fr.den *= st->codec->ticks_per_frame;
4331 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4332 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4339 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4342 if (*spec <= '9' && *spec >= '0') /* opt:index */
4343 return strtol(spec, NULL, 0) == st->index;
4344 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4345 *spec == 't') { /* opt:[vasdt] */
4346 enum AVMediaType type;
4349 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4350 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4351 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4352 case 'd': type = AVMEDIA_TYPE_DATA; break;
4353 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4354 default: av_assert0(0);
4356 if (type != st->codec->codec_type)
4358 if (*spec++ == ':') { /* possibly followed by :index */
4359 int i, index = strtol(spec, NULL, 0);
4360 for (i = 0; i < s->nb_streams; i++)
4361 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4362 return i == st->index;
4366 } else if (*spec == 'p' && *(spec + 1) == ':') {
4370 prog_id = strtol(spec, &endptr, 0);
4371 for (i = 0; i < s->nb_programs; i++) {
4372 if (s->programs[i]->id != prog_id)
4375 if (*endptr++ == ':') {
4376 int stream_idx = strtol(endptr, NULL, 0);
4377 return stream_idx >= 0 &&
4378 stream_idx < s->programs[i]->nb_stream_indexes &&
4379 st->index == s->programs[i]->stream_index[stream_idx];
4382 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4383 if (st->index == s->programs[i]->stream_index[j])
4387 } else if (*spec == '#') {
4390 sid = strtol(spec + 1, &endptr, 0);
4392 return st->id == sid;
4393 } else if (!*spec) /* empty specifier, matches everything */
4396 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4397 return AVERROR(EINVAL);
4400 int ff_generate_avci_extradata(AVStream *st)
4402 static const uint8_t avci100_1080p_extradata[] = {
4404 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4405 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4406 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4407 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4408 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4409 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4410 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4411 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4412 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4414 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4417 static const uint8_t avci100_1080i_extradata[] = {
4419 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4420 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4421 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4422 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4423 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4424 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4425 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4426 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4427 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4428 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4429 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4431 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4434 static const uint8_t avci50_1080i_extradata[] = {
4436 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4437 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4438 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4439 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4440 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4441 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4442 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4443 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4444 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4445 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4446 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4448 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4451 static const uint8_t avci100_720p_extradata[] = {
4453 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4454 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4455 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4456 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4457 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4458 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4459 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4460 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4461 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4462 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4464 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4468 const uint8_t *data = NULL;
4471 if (st->codec->width == 1920) {
4472 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4473 data = avci100_1080p_extradata;
4474 size = sizeof(avci100_1080p_extradata);
4476 data = avci100_1080i_extradata;
4477 size = sizeof(avci100_1080i_extradata);
4479 } else if (st->codec->width == 1440) {
4480 data = avci50_1080i_extradata;
4481 size = sizeof(avci50_1080i_extradata);
4482 } else if (st->codec->width == 1280) {
4483 data = avci100_720p_extradata;
4484 size = sizeof(avci100_720p_extradata);
4490 av_freep(&st->codec->extradata);
4491 if (ff_alloc_extradata(st->codec, size))
4492 return AVERROR(ENOMEM);
4493 memcpy(st->codec->extradata, data, size);