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
25 #include "avio_internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/raw.h"
29 #include "libavcodec/bytestream.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/pixdesc.h"
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/time.h"
41 #include "libavutil/timestamp.h"
43 #include "audiointerleave.h"
55 * various utility functions for use within FFmpeg
58 unsigned avformat_version(void)
60 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
61 return LIBAVFORMAT_VERSION_INT;
64 const char *avformat_configuration(void)
66 return FFMPEG_CONFIGURATION;
69 const char *avformat_license(void)
71 #define LICENSE_PREFIX "libavformat license: "
72 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
77 static int is_relative(int64_t ts) {
78 return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 * Wrap a given time stamp, if there is an indication for an overflow
85 * @param timestamp the time stamp to wrap
86 * @return resulting time stamp
88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
90 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
91 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
92 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
93 timestamp < st->pts_wrap_reference)
94 return timestamp + (1ULL<<st->pts_wrap_bits);
95 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
96 timestamp >= st->pts_wrap_reference)
97 return timestamp - (1ULL<<st->pts_wrap_bits);
102 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
104 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
105 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
107 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
109 if (st->codec->codec)
110 return st->codec->codec;
112 switch(st->codec->codec_type){
113 case AVMEDIA_TYPE_VIDEO:
114 if(s->video_codec) return s->video_codec;
116 case AVMEDIA_TYPE_AUDIO:
117 if(s->audio_codec) return s->audio_codec;
119 case AVMEDIA_TYPE_SUBTITLE:
120 if(s->subtitle_codec) return s->subtitle_codec;
124 return avcodec_find_decoder(codec_id);
127 int av_format_get_probe_score(const AVFormatContext *s)
129 return s->probe_score;
132 /* an arbitrarily chosen "sane" max packet size -- 50M */
133 #define SANE_CHUNK_SIZE (50000000)
135 int ffio_limit(AVIOContext *s, int size)
138 int64_t remaining= s->maxsize - avio_tell(s);
139 if(remaining < size){
140 int64_t newsize= avio_size(s);
141 if(!s->maxsize || s->maxsize<newsize)
142 s->maxsize= newsize - !newsize;
143 remaining= s->maxsize - avio_tell(s);
144 remaining= FFMAX(remaining, 0);
147 if(s->maxsize>=0 && remaining+1 < size){
148 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
156 * Read the data in sane-sized chunks and append to pkt.
157 * Return the number of bytes read or an error.
159 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
161 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
162 int orig_size = pkt->size;
166 int prev_size = pkt->size;
170 * When the caller requests a lot of data, limit it to the amount left
171 * in file or SANE_CHUNK_SIZE when it is not known
174 if (read_size > SANE_CHUNK_SIZE/10) {
175 read_size = ffio_limit(s, read_size);
176 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
178 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
181 ret = av_grow_packet(pkt, read_size);
185 ret = avio_read(s, pkt->data + prev_size, read_size);
186 if (ret != read_size) {
187 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
194 pkt->flags |= AV_PKT_FLAG_CORRUPT;
199 return pkt->size > orig_size ? pkt->size - orig_size : ret;
202 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
207 pkt->pos = avio_tell(s);
209 return append_packet_chunked(s, pkt, size);
212 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
215 return av_get_packet(s, pkt, size);
216 return append_packet_chunked(s, pkt, size);
220 int av_filename_number_test(const char *filename)
223 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
226 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
228 AVProbeData lpd = *pd;
229 AVInputFormat *fmt1 = NULL, *fmt;
230 int score, nodat = 0, score_max=0;
231 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
234 lpd.buf = zerobuffer;
236 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
237 int id3len = ff_id3v2_tag_len(lpd.buf);
238 if (lpd.buf_size > id3len + 16) {
240 lpd.buf_size -= id3len;
246 while ((fmt1 = av_iformat_next(fmt1))) {
247 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
250 if (fmt1->read_probe) {
251 score = fmt1->read_probe(&lpd);
252 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
253 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
254 } else if (fmt1->extensions) {
255 if (av_match_ext(lpd.filename, fmt1->extensions)) {
256 score = AVPROBE_SCORE_EXTENSION;
259 if (score > score_max) {
262 }else if (score == score_max)
266 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
267 *score_ret= score_max;
272 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
275 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
276 if(score_ret > *score_max){
277 *score_max= score_ret;
283 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
285 return av_probe_input_format2(pd, is_opened, &score);
288 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
290 static const struct {
291 const char *name; enum AVCodecID id; enum AVMediaType type;
293 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
294 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
295 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
296 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
297 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
298 { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
299 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
300 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
301 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
305 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
307 if (fmt && st->request_probe <= score) {
309 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
310 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
311 for (i = 0; fmt_id_type[i].name; i++) {
312 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
313 st->codec->codec_id = fmt_id_type[i].id;
314 st->codec->codec_type = fmt_id_type[i].type;
322 /************************************************************/
323 /* input media file */
325 int av_demuxer_open(AVFormatContext *ic){
328 if (ic->iformat->read_header) {
329 err = ic->iformat->read_header(ic);
334 if (ic->pb && !ic->data_offset)
335 ic->data_offset = avio_tell(ic->pb);
341 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
342 const char *filename, void *logctx,
343 unsigned int offset, unsigned int max_probe_size)
345 AVProbeData pd = { filename ? filename : "", NULL, -offset };
346 unsigned char *buf = NULL;
348 int ret = 0, probe_size, buf_offset = 0;
351 if (!max_probe_size) {
352 max_probe_size = PROBE_BUF_MAX;
353 } else if (max_probe_size > PROBE_BUF_MAX) {
354 max_probe_size = PROBE_BUF_MAX;
355 } else if (max_probe_size < PROBE_BUF_MIN) {
356 av_log(logctx, AV_LOG_ERROR,
357 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
358 return AVERROR(EINVAL);
361 if (offset >= max_probe_size) {
362 return AVERROR(EINVAL);
365 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
366 if (!av_strcasecmp(mime_type, "audio/aacp")) {
367 *fmt = av_find_input_format("aac");
369 av_freep(&mime_type);
372 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
373 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
375 if (probe_size < offset) {
378 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
380 /* read probe data */
381 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
383 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
384 /* fail if error was not end of file, otherwise, lower score */
385 if (ret != AVERROR_EOF) {
390 ret = 0; /* error was end of file, nothing read */
392 pd.buf_size = buf_offset += ret;
393 pd.buf = &buf[offset];
395 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
397 /* guess file format */
398 *fmt = av_probe_input_format2(&pd, 1, &score);
400 if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
401 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
403 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
405 FILE *f = fopen("probestat.tmp", "ab");
406 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
414 return AVERROR_INVALIDDATA;
417 /* rewind. reuse probe buffer to avoid seeking */
418 ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
420 return ret < 0 ? ret : score;
423 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
424 const char *filename, void *logctx,
425 unsigned int offset, unsigned int max_probe_size)
427 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
428 return ret < 0 ? ret : 0;
432 /* open input file and probe the format if necessary */
433 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
436 AVProbeData pd = {filename, NULL, 0};
437 int score = AVPROBE_SCORE_RETRY;
440 s->flags |= AVFMT_FLAG_CUSTOM_IO;
442 return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
443 else if (s->iformat->flags & AVFMT_NOFILE)
444 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
445 "will be ignored with AVFMT_NOFILE format.\n");
449 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
450 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
453 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
454 &s->interrupt_callback, options)) < 0)
458 return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
461 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
462 AVPacketList **plast_pktl){
463 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
468 (*plast_pktl)->next = pktl;
470 *packet_buffer = pktl;
472 /* add the packet in the buffered packet list */
478 int avformat_queue_attached_pictures(AVFormatContext *s)
481 for (i = 0; i < s->nb_streams; i++)
482 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
483 s->streams[i]->discard < AVDISCARD_ALL) {
484 AVPacket copy = s->streams[i]->attached_pic;
485 copy.buf = av_buffer_ref(copy.buf);
487 return AVERROR(ENOMEM);
489 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
494 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
496 AVFormatContext *s = *ps;
498 AVDictionary *tmp = NULL;
499 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
501 if (!s && !(s = avformat_alloc_context()))
502 return AVERROR(ENOMEM);
504 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
505 return AVERROR(EINVAL);
511 av_dict_copy(&tmp, *options, 0);
513 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
516 if ((ret = init_input(s, filename, &tmp)) < 0)
518 s->probe_score = ret;
519 avio_skip(s->pb, s->skip_initial_bytes);
521 /* check filename in case an image number is expected */
522 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
523 if (!av_filename_number_test(filename)) {
524 ret = AVERROR(EINVAL);
529 s->duration = s->start_time = AV_NOPTS_VALUE;
530 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
532 /* allocate private data */
533 if (s->iformat->priv_data_size > 0) {
534 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
535 ret = AVERROR(ENOMEM);
538 if (s->iformat->priv_class) {
539 *(const AVClass**)s->priv_data = s->iformat->priv_class;
540 av_opt_set_defaults(s->priv_data);
541 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
546 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
548 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
550 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
551 if ((ret = s->iformat->read_header(s)) < 0)
554 if (id3v2_extra_meta) {
555 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
556 !strcmp(s->iformat->name, "tta")) {
557 if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
560 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
562 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
564 if ((ret = avformat_queue_attached_pictures(s)) < 0)
567 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
568 s->data_offset = avio_tell(s->pb);
570 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
573 av_dict_free(options);
580 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
582 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
584 avformat_free_context(s);
589 /*******************************************************/
591 static void force_codec_ids(AVFormatContext *s, AVStream *st)
593 switch(st->codec->codec_type){
594 case AVMEDIA_TYPE_VIDEO:
595 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
597 case AVMEDIA_TYPE_AUDIO:
598 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
600 case AVMEDIA_TYPE_SUBTITLE:
601 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
606 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
608 if(st->request_probe>0){
609 AVProbeData *pd = &st->probe_data;
611 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
615 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
617 av_log(s, AV_LOG_WARNING,
618 "Failed to reallocate probe buffer for stream %d\n",
623 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
624 pd->buf_size += pkt->size;
625 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
628 st->probe_packets = 0;
630 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
635 end= s->raw_packet_buffer_remaining_size <= 0
636 || st->probe_packets<=0;
638 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
639 int score= set_codec_from_probe_data(s, st, pd);
640 if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
644 st->request_probe= -1;
645 if(st->codec->codec_id != AV_CODEC_ID_NONE){
646 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
648 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
650 force_codec_ids(s, st);
656 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
662 AVPacketList *pktl = s->raw_packet_buffer;
666 st = s->streams[pkt->stream_index];
667 if (s->raw_packet_buffer_remaining_size <= 0) {
668 if ((err = probe_codec(s, st, NULL)) < 0)
671 if(st->request_probe <= 0){
672 s->raw_packet_buffer = pktl->next;
673 s->raw_packet_buffer_remaining_size += pkt->size;
682 ret= s->iformat->read_packet(s, pkt);
684 if (!pktl || ret == AVERROR(EAGAIN))
686 for (i = 0; i < s->nb_streams; i++) {
688 if (st->probe_packets) {
689 if ((err = probe_codec(s, st, NULL)) < 0)
692 av_assert0(st->request_probe <= 0);
697 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
698 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
699 av_log(s, AV_LOG_WARNING,
700 "Dropped corrupted packet (stream = %d)\n",
706 if(pkt->stream_index >= (unsigned)s->nb_streams){
707 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
711 st= s->streams[pkt->stream_index];
712 pkt->dts = wrap_timestamp(st, pkt->dts);
713 pkt->pts = wrap_timestamp(st, pkt->pts);
715 force_codec_ids(s, st);
717 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
718 if (s->use_wallclock_as_timestamps)
719 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
721 if(!pktl && st->request_probe <= 0)
724 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
725 s->raw_packet_buffer_remaining_size -= pkt->size;
727 if ((err = probe_codec(s, st, pkt)) < 0)
732 #if FF_API_READ_PACKET
733 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
735 return ff_read_packet(s, pkt);
740 /**********************************************************/
742 static int determinable_frame_size(AVCodecContext *avctx)
744 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
745 avctx->codec_id == AV_CODEC_ID_MP1 ||
746 avctx->codec_id == AV_CODEC_ID_MP2 ||
747 avctx->codec_id == AV_CODEC_ID_MP3/* ||
748 avctx->codec_id == AV_CODEC_ID_CELT*/)
754 * Get the number of samples of an audio frame. Return -1 on error.
756 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
760 /* give frame_size priority if demuxing */
761 if (!mux && enc->frame_size > 1)
762 return enc->frame_size;
764 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
767 /* Fall back on using frame_size if muxing. */
768 if (enc->frame_size > 1)
769 return enc->frame_size;
771 //For WMA we currently have no other means to calculate duration thus we
772 //do it here by assuming CBR, which is true for all known cases.
773 if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
774 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
775 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
783 * Return the frame duration in seconds. Return 0 if not available.
785 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
786 AVCodecParserContext *pc, AVPacket *pkt)
792 switch(st->codec->codec_type) {
793 case AVMEDIA_TYPE_VIDEO:
794 if (st->r_frame_rate.num && !pc) {
795 *pnum = st->r_frame_rate.den;
796 *pden = st->r_frame_rate.num;
797 } else if(st->time_base.num*1000LL > st->time_base.den) {
798 *pnum = st->time_base.num;
799 *pden = st->time_base.den;
800 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801 *pnum = st->codec->time_base.num;
802 *pden = st->codec->time_base.den;
803 if (pc && pc->repeat_pict) {
804 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
805 *pden /= 1 + pc->repeat_pict;
807 *pnum *= 1 + pc->repeat_pict;
809 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
810 //Thus if we have no parser in such case leave duration undefined.
811 if(st->codec->ticks_per_frame>1 && !pc){
816 case AVMEDIA_TYPE_AUDIO:
817 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
818 if (frame_size <= 0 || st->codec->sample_rate <= 0)
821 *pden = st->codec->sample_rate;
828 static int is_intra_only(AVCodecContext *enc){
829 const AVCodecDescriptor *desc;
831 if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
834 desc = av_codec_get_codec_descriptor(enc);
836 desc = avcodec_descriptor_get(enc->codec_id);
837 av_codec_set_codec_descriptor(enc, desc);
840 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
844 static int has_decode_delay_been_guessed(AVStream *st)
846 if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
847 if(!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
849 #if CONFIG_H264_DECODER
850 if(st->codec->has_b_frames &&
851 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
854 if(st->codec->has_b_frames<3)
855 return st->nb_decoded_frames >= 7;
856 else if(st->codec->has_b_frames<4)
857 return st->nb_decoded_frames >= 18;
859 return st->nb_decoded_frames >= 20;
862 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
866 if (pktl == s->parse_queue_end)
867 return s->packet_buffer;
871 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
873 if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
874 st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
877 // reference time stamp should be 60 s before first time stamp
878 int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
879 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
880 int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
881 (st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
882 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
884 AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
886 if (!first_program) {
887 int default_stream_index = av_find_default_stream_index(s);
888 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
889 for (i=0; i<s->nb_streams; i++) {
890 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
891 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
895 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
896 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
900 AVProgram *program = first_program;
902 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
903 pts_wrap_reference = program->pts_wrap_reference;
904 pts_wrap_behavior = program->pts_wrap_behavior;
907 program = av_find_program_from_stream(s, program, stream_index);
910 // update every program with differing pts_wrap_reference
911 program = first_program;
913 if (program->pts_wrap_reference != pts_wrap_reference) {
914 for (i=0; i<program->nb_stream_indexes; i++) {
915 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
916 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
919 program->pts_wrap_reference = pts_wrap_reference;
920 program->pts_wrap_behavior = pts_wrap_behavior;
922 program = av_find_program_from_stream(s, program, stream_index);
930 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
931 int64_t dts, int64_t pts, AVPacket *pkt)
933 AVStream *st= s->streams[stream_index];
934 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
935 int64_t pts_buffer[MAX_REORDER_DELAY+1];
939 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
942 delay = st->codec->has_b_frames;
943 st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
945 shift = st->first_dts - RELATIVE_TS_BASE;
947 for (i=0; i<MAX_REORDER_DELAY+1; i++)
948 pts_buffer[i] = AV_NOPTS_VALUE;
950 if (is_relative(pts))
953 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
954 if(pktl->pkt.stream_index != stream_index)
956 if(is_relative(pktl->pkt.pts))
957 pktl->pkt.pts += shift;
959 if(is_relative(pktl->pkt.dts))
960 pktl->pkt.dts += shift;
962 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
963 st->start_time= pktl->pkt.pts;
965 if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
966 pts_buffer[0]= pktl->pkt.pts;
967 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
968 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
969 if(pktl->pkt.dts == AV_NOPTS_VALUE)
970 pktl->pkt.dts= pts_buffer[0];
974 if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
975 // correct first time stamps to negative values
976 st->first_dts = wrap_timestamp(st, st->first_dts);
977 st->cur_dts = wrap_timestamp(st, st->cur_dts);
978 pkt->dts = wrap_timestamp(st, pkt->dts);
979 pkt->pts = wrap_timestamp(st, pkt->pts);
980 pts = wrap_timestamp(st, pts);
983 if (st->start_time == AV_NOPTS_VALUE)
984 st->start_time = pts;
987 static void update_initial_durations(AVFormatContext *s, AVStream *st,
988 int stream_index, int duration)
990 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
991 int64_t cur_dts= RELATIVE_TS_BASE;
993 if(st->first_dts != AV_NOPTS_VALUE){
994 cur_dts= st->first_dts;
995 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
996 if(pktl->pkt.stream_index == stream_index){
997 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1002 if(pktl && pktl->pkt.dts != st->first_dts) {
1003 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1004 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1008 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1011 pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1012 st->first_dts = cur_dts;
1013 }else if(st->cur_dts != RELATIVE_TS_BASE)
1016 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1017 if(pktl->pkt.stream_index != stream_index)
1019 if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1020 && !pktl->pkt.duration){
1021 pktl->pkt.dts= cur_dts;
1022 if(!st->codec->has_b_frames)
1023 pktl->pkt.pts= cur_dts;
1024 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1025 pktl->pkt.duration = duration;
1028 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1031 st->cur_dts= cur_dts;
1034 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1035 AVCodecParserContext *pc, AVPacket *pkt)
1037 int num, den, presentation_delayed, delay, i;
1040 if (s->flags & AVFMT_FLAG_NOFILLIN)
1043 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1044 pkt->dts= AV_NOPTS_VALUE;
1046 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1047 && !st->codec->has_b_frames)
1048 //FIXME Set low_delay = 0 when has_b_frames = 1
1049 st->codec->has_b_frames = 1;
1051 /* do we have a video B-frame ? */
1052 delay= st->codec->has_b_frames;
1053 presentation_delayed = 0;
1055 /* XXX: need has_b_frame, but cannot get it if the codec is
1058 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1059 presentation_delayed = 1;
1061 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1062 st->pts_wrap_bits < 63 &&
1063 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1064 if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1065 pkt->dts -= 1LL<<st->pts_wrap_bits;
1067 pkt->pts += 1LL<<st->pts_wrap_bits;
1070 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1071 // we take the conservative approach and discard both
1072 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1073 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1074 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1075 if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1076 pkt->dts= AV_NOPTS_VALUE;
1079 if (pkt->duration == 0) {
1080 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1082 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1085 if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1086 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1088 /* correct timestamps with byte offset if demuxers only have timestamps
1089 on packet boundaries */
1090 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1091 /* this will estimate bitrate based on this frame's duration and size */
1092 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1093 if(pkt->pts != AV_NOPTS_VALUE)
1095 if(pkt->dts != AV_NOPTS_VALUE)
1099 /* This may be redundant, but it should not hurt. */
1100 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1101 presentation_delayed = 1;
1103 av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1104 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1105 /* interpolate PTS and DTS if they are not present */
1106 //We skip H264 currently because delay and has_b_frames are not reliably set
1107 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1108 if (presentation_delayed) {
1109 /* DTS = decompression timestamp */
1110 /* PTS = presentation timestamp */
1111 if (pkt->dts == AV_NOPTS_VALUE)
1112 pkt->dts = st->last_IP_pts;
1113 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1114 if (pkt->dts == AV_NOPTS_VALUE)
1115 pkt->dts = st->cur_dts;
1117 /* this is tricky: the dts must be incremented by the duration
1118 of the frame we are displaying, i.e. the last I- or P-frame */
1119 if (st->last_IP_duration == 0)
1120 st->last_IP_duration = pkt->duration;
1121 if(pkt->dts != AV_NOPTS_VALUE)
1122 st->cur_dts = pkt->dts + st->last_IP_duration;
1123 st->last_IP_duration = pkt->duration;
1124 st->last_IP_pts= pkt->pts;
1125 /* cannot compute PTS if not present (we can compute it only
1126 by knowing the future */
1127 } else if (pkt->pts != AV_NOPTS_VALUE ||
1128 pkt->dts != AV_NOPTS_VALUE ||
1130 int duration = pkt->duration;
1132 /* presentation is not delayed : PTS and DTS are the same */
1133 if (pkt->pts == AV_NOPTS_VALUE)
1134 pkt->pts = pkt->dts;
1135 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1137 if (pkt->pts == AV_NOPTS_VALUE)
1138 pkt->pts = st->cur_dts;
1139 pkt->dts = pkt->pts;
1140 if (pkt->pts != AV_NOPTS_VALUE)
1141 st->cur_dts = pkt->pts + duration;
1145 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1146 st->pts_buffer[0]= pkt->pts;
1147 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1148 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1149 if(pkt->dts == AV_NOPTS_VALUE)
1150 pkt->dts= st->pts_buffer[0];
1152 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1153 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1155 if(pkt->dts > st->cur_dts)
1156 st->cur_dts = pkt->dts;
1158 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1159 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1162 if (is_intra_only(st->codec))
1163 pkt->flags |= AV_PKT_FLAG_KEY;
1165 pkt->convergence_duration = pc->convergence_duration;
1168 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1171 AVPacketList *pktl = *pkt_buf;
1172 *pkt_buf = pktl->next;
1173 av_free_packet(&pktl->pkt);
1176 *pkt_buf_end = NULL;
1180 * Parse a packet, add all split parts to parse_queue
1182 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1184 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1186 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1187 AVStream *st = s->streams[stream_index];
1188 uint8_t *data = pkt ? pkt->data : NULL;
1189 int size = pkt ? pkt->size : 0;
1190 int ret = 0, got_output = 0;
1193 av_init_packet(&flush_pkt);
1196 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1197 // preserve 0-size sync packets
1198 compute_pkt_fields(s, st, st->parser, pkt);
1201 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1204 av_init_packet(&out_pkt);
1205 len = av_parser_parse2(st->parser, st->codec,
1206 &out_pkt.data, &out_pkt.size, data, size,
1207 pkt->pts, pkt->dts, pkt->pos);
1209 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1211 /* increment read pointer */
1215 got_output = !!out_pkt.size;
1220 if (pkt->side_data) {
1221 out_pkt.side_data = pkt->side_data;
1222 out_pkt.side_data_elems = pkt->side_data_elems;
1223 pkt->side_data = NULL;
1224 pkt->side_data_elems = 0;
1227 /* set the duration */
1228 out_pkt.duration = 0;
1229 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1230 if (st->codec->sample_rate > 0) {
1231 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1232 (AVRational){ 1, st->codec->sample_rate },
1236 } else if (st->codec->time_base.num != 0 &&
1237 st->codec->time_base.den != 0) {
1238 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1239 st->codec->time_base,
1244 out_pkt.stream_index = st->index;
1245 out_pkt.pts = st->parser->pts;
1246 out_pkt.dts = st->parser->dts;
1247 out_pkt.pos = st->parser->pos;
1249 if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1250 out_pkt.pos = st->parser->frame_offset;
1252 if (st->parser->key_frame == 1 ||
1253 (st->parser->key_frame == -1 &&
1254 st->parser->pict_type == AV_PICTURE_TYPE_I))
1255 out_pkt.flags |= AV_PKT_FLAG_KEY;
1257 if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1258 out_pkt.flags |= AV_PKT_FLAG_KEY;
1260 compute_pkt_fields(s, st, st->parser, &out_pkt);
1262 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1263 out_pkt.buf = pkt->buf;
1265 #if FF_API_DESTRUCT_PACKET
1266 FF_DISABLE_DEPRECATION_WARNINGS
1267 out_pkt.destruct = pkt->destruct;
1268 pkt->destruct = NULL;
1269 FF_ENABLE_DEPRECATION_WARNINGS
1272 if ((ret = av_dup_packet(&out_pkt)) < 0)
1275 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1276 av_free_packet(&out_pkt);
1277 ret = AVERROR(ENOMEM);
1283 /* end of the stream => close and free the parser */
1284 if (pkt == &flush_pkt) {
1285 av_parser_close(st->parser);
1290 av_free_packet(pkt);
1294 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1295 AVPacketList **pkt_buffer_end,
1299 av_assert0(*pkt_buffer);
1302 *pkt_buffer = pktl->next;
1304 *pkt_buffer_end = NULL;
1309 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1311 int ret = 0, i, got_packet = 0;
1313 av_init_packet(pkt);
1315 while (!got_packet && !s->parse_queue) {
1319 /* read next packet */
1320 ret = ff_read_packet(s, &cur_pkt);
1322 if (ret == AVERROR(EAGAIN))
1324 /* flush the parsers */
1325 for(i = 0; i < s->nb_streams; i++) {
1327 if (st->parser && st->need_parsing)
1328 parse_packet(s, NULL, st->index);
1330 /* all remaining packets are now in parse_queue =>
1331 * really terminate parsing */
1335 st = s->streams[cur_pkt.stream_index];
1337 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1338 cur_pkt.dts != AV_NOPTS_VALUE &&
1339 cur_pkt.pts < cur_pkt.dts) {
1340 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1341 cur_pkt.stream_index,
1342 av_ts2str(cur_pkt.pts),
1343 av_ts2str(cur_pkt.dts),
1346 if (s->debug & FF_FDEBUG_TS)
1347 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1348 cur_pkt.stream_index,
1349 av_ts2str(cur_pkt.pts),
1350 av_ts2str(cur_pkt.dts),
1355 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1356 st->parser = av_parser_init(st->codec->codec_id);
1358 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1359 "%s, packets or times may be invalid.\n",
1360 avcodec_get_name(st->codec->codec_id));
1361 /* no parser available: just output the raw packets */
1362 st->need_parsing = AVSTREAM_PARSE_NONE;
1363 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1364 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1365 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1366 st->parser->flags |= PARSER_FLAG_ONCE;
1367 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1368 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1372 if (!st->need_parsing || !st->parser) {
1373 /* no parsing needed: we just output the packet as is */
1375 compute_pkt_fields(s, st, NULL, pkt);
1376 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1377 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1378 ff_reduce_index(s, st->index);
1379 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1382 } else if (st->discard < AVDISCARD_ALL) {
1383 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1387 av_free_packet(&cur_pkt);
1389 if (pkt->flags & AV_PKT_FLAG_KEY)
1390 st->skip_to_keyframe = 0;
1391 if (st->skip_to_keyframe) {
1392 av_free_packet(&cur_pkt);
1400 if (!got_packet && s->parse_queue)
1401 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1404 AVStream *st = s->streams[pkt->stream_index];
1405 if (st->skip_samples) {
1406 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1408 AV_WL32(p, st->skip_samples);
1409 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1411 st->skip_samples = 0;
1415 if(ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1416 av_packet_merge_side_data(pkt);
1418 if(s->debug & FF_FDEBUG_TS)
1419 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1421 av_ts2str(pkt->pts),
1422 av_ts2str(pkt->dts),
1430 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1432 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1438 ret = s->packet_buffer ?
1439 read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1440 read_frame_internal(s, pkt);
1447 AVPacketList *pktl = s->packet_buffer;
1450 AVPacket *next_pkt = &pktl->pkt;
1452 if (next_pkt->dts != AV_NOPTS_VALUE) {
1453 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1454 // last dts seen for this stream. if any of packets following
1455 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1456 int64_t last_dts = next_pkt->dts;
1457 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1458 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1459 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1460 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1461 next_pkt->pts = pktl->pkt.dts;
1463 if (last_dts != AV_NOPTS_VALUE) {
1464 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1465 last_dts = pktl->pkt.dts;
1470 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1471 // Fixing the last reference frame had none pts issue (For MXF etc).
1472 // We only do this when
1474 // 2. we are not able to resolve a pts value for current packet.
1475 // 3. the packets for this stream at the end of the files had valid dts.
1476 next_pkt->pts = last_dts + next_pkt->duration;
1478 pktl = s->packet_buffer;
1481 /* read packet from packet buffer, if there is data */
1482 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1483 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1484 ret = read_from_packet_buffer(&s->packet_buffer,
1485 &s->packet_buffer_end, pkt);
1490 ret = read_frame_internal(s, pkt);
1492 if (pktl && ret != AVERROR(EAGAIN)) {
1499 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1500 &s->packet_buffer_end)) < 0)
1501 return AVERROR(ENOMEM);
1506 st = s->streams[pkt->stream_index];
1507 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1508 ff_reduce_index(s, st->index);
1509 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1512 if (is_relative(pkt->dts))
1513 pkt->dts -= RELATIVE_TS_BASE;
1514 if (is_relative(pkt->pts))
1515 pkt->pts -= RELATIVE_TS_BASE;
1520 /* XXX: suppress the packet queue */
1521 static void flush_packet_queue(AVFormatContext *s)
1523 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1524 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1525 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1527 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1530 /*******************************************************/
1533 int av_find_default_stream_index(AVFormatContext *s)
1535 int first_audio_index = -1;
1539 if (s->nb_streams <= 0)
1541 for(i = 0; i < s->nb_streams; i++) {
1543 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1544 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1547 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1548 first_audio_index = i;
1550 return first_audio_index >= 0 ? first_audio_index : 0;
1554 * Flush the frame reader.
1556 void ff_read_frame_flush(AVFormatContext *s)
1561 flush_packet_queue(s);
1563 /* for each stream, reset read state */
1564 for(i = 0; i < s->nb_streams; i++) {
1568 av_parser_close(st->parser);
1571 st->last_IP_pts = AV_NOPTS_VALUE;
1572 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1573 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1575 st->probe_packets = MAX_PROBE_PACKETS;
1577 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1578 st->pts_buffer[j]= AV_NOPTS_VALUE;
1582 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1586 for(i = 0; i < s->nb_streams; i++) {
1587 AVStream *st = s->streams[i];
1589 st->cur_dts = av_rescale(timestamp,
1590 st->time_base.den * (int64_t)ref_st->time_base.num,
1591 st->time_base.num * (int64_t)ref_st->time_base.den);
1595 void ff_reduce_index(AVFormatContext *s, int stream_index)
1597 AVStream *st= s->streams[stream_index];
1598 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1600 if((unsigned)st->nb_index_entries >= max_entries){
1602 for(i=0; 2*i<st->nb_index_entries; i++)
1603 st->index_entries[i]= st->index_entries[2*i];
1604 st->nb_index_entries= i;
1608 int ff_add_index_entry(AVIndexEntry **index_entries,
1609 int *nb_index_entries,
1610 unsigned int *index_entries_allocated_size,
1611 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1613 AVIndexEntry *entries, *ie;
1616 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1619 if(timestamp == AV_NOPTS_VALUE)
1620 return AVERROR(EINVAL);
1622 if (size < 0 || size > 0x3FFFFFFF)
1623 return AVERROR(EINVAL);
1625 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1626 timestamp -= RELATIVE_TS_BASE;
1628 entries = av_fast_realloc(*index_entries,
1629 index_entries_allocated_size,
1630 (*nb_index_entries + 1) *
1631 sizeof(AVIndexEntry));
1635 *index_entries= entries;
1637 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1640 index= (*nb_index_entries)++;
1641 ie= &entries[index];
1642 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1644 ie= &entries[index];
1645 if(ie->timestamp != timestamp){
1646 if(ie->timestamp <= timestamp)
1648 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1649 (*nb_index_entries)++;
1650 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1651 distance= ie->min_distance;
1655 ie->timestamp = timestamp;
1656 ie->min_distance= distance;
1663 int av_add_index_entry(AVStream *st,
1664 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1666 timestamp = wrap_timestamp(st, timestamp);
1667 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1668 &st->index_entries_allocated_size, pos,
1669 timestamp, size, distance, flags);
1672 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1673 int64_t wanted_timestamp, int flags)
1681 //optimize appending index entries at the end
1682 if(b && entries[b-1].timestamp < wanted_timestamp)
1687 timestamp = entries[m].timestamp;
1688 if(timestamp >= wanted_timestamp)
1690 if(timestamp <= wanted_timestamp)
1693 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1695 if(!(flags & AVSEEK_FLAG_ANY)){
1696 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1697 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1706 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1709 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1710 wanted_timestamp, flags);
1713 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1714 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1716 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1717 if (stream_index >= 0)
1718 ts = wrap_timestamp(s->streams[stream_index], ts);
1722 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1724 AVInputFormat *avif= s->iformat;
1725 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1726 int64_t ts_min, ts_max, ts;
1731 if (stream_index < 0)
1734 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1737 ts_min= AV_NOPTS_VALUE;
1738 pos_limit= -1; //gcc falsely says it may be uninitialized
1740 st= s->streams[stream_index];
1741 if(st->index_entries){
1744 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1745 index= FFMAX(index, 0);
1746 e= &st->index_entries[index];
1748 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1750 ts_min= e->timestamp;
1751 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1752 pos_min, av_ts2str(ts_min));
1754 av_assert1(index==0);
1757 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1758 av_assert0(index < st->nb_index_entries);
1760 e= &st->index_entries[index];
1761 av_assert1(e->timestamp >= target_ts);
1763 ts_max= e->timestamp;
1764 pos_limit= pos_max - e->min_distance;
1765 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1766 pos_max, pos_limit, av_ts2str(ts_max));
1770 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1775 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1778 ff_read_frame_flush(s);
1779 ff_update_cur_dts(s, st, ts);
1784 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1785 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1788 int64_t limit, ts_max;
1789 int64_t filesize = avio_size(s->pb);
1790 int64_t pos_max = filesize - 1;
1793 pos_max = FFMAX(0, (pos_max) - step);
1794 ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1796 }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1797 if (ts_max == AV_NOPTS_VALUE)
1801 int64_t tmp_pos = pos_max + 1;
1802 int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1803 if(tmp_ts == AV_NOPTS_VALUE)
1805 av_assert0(tmp_pos > pos_max);
1808 if(tmp_pos >= filesize)
1820 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1821 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1822 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1823 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1830 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1832 if(ts_min == AV_NOPTS_VALUE){
1833 pos_min = s->data_offset;
1834 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1835 if (ts_min == AV_NOPTS_VALUE)
1839 if(ts_min >= target_ts){
1844 if(ts_max == AV_NOPTS_VALUE){
1845 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1850 if(ts_max <= target_ts){
1855 if(ts_min > ts_max){
1857 }else if(ts_min == ts_max){
1862 while (pos_min < pos_limit) {
1863 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1864 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1865 assert(pos_limit <= pos_max);
1868 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1869 // interpolate position (better than dichotomy)
1870 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1871 + pos_min - approximate_keyframe_distance;
1872 }else if(no_change==1){
1873 // bisection, if interpolation failed to change min or max pos last time
1874 pos = (pos_min + pos_limit)>>1;
1876 /* linear search if bisection failed, can only happen if there
1877 are very few or no keyframes between min/max */
1882 else if(pos > pos_limit)
1886 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1891 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1892 pos_min, pos, pos_max,
1893 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1894 pos_limit, start_pos, no_change);
1895 if(ts == AV_NOPTS_VALUE){
1896 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1899 assert(ts != AV_NOPTS_VALUE);
1900 if (target_ts <= ts) {
1901 pos_limit = start_pos - 1;
1905 if (target_ts >= ts) {
1911 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1912 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1915 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1917 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1918 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1919 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1925 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1926 int64_t pos_min, pos_max;
1928 pos_min = s->data_offset;
1929 pos_max = avio_size(s->pb) - 1;
1931 if (pos < pos_min) pos= pos_min;
1932 else if(pos > pos_max) pos= pos_max;
1934 avio_seek(s->pb, pos, SEEK_SET);
1936 s->io_repositioned = 1;
1941 static int seek_frame_generic(AVFormatContext *s,
1942 int stream_index, int64_t timestamp, int flags)
1949 st = s->streams[stream_index];
1951 index = av_index_search_timestamp(st, timestamp, flags);
1953 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1956 if(index < 0 || index==st->nb_index_entries-1){
1960 if(st->nb_index_entries){
1961 av_assert0(st->index_entries);
1962 ie= &st->index_entries[st->nb_index_entries-1];
1963 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1965 ff_update_cur_dts(s, st, ie->timestamp);
1967 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1973 read_status = av_read_frame(s, &pkt);
1974 } while (read_status == AVERROR(EAGAIN));
1975 if (read_status < 0)
1977 av_free_packet(&pkt);
1978 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1979 if(pkt.flags & AV_PKT_FLAG_KEY)
1981 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1982 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);
1987 index = av_index_search_timestamp(st, timestamp, flags);
1992 ff_read_frame_flush(s);
1993 if (s->iformat->read_seek){
1994 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1997 ie = &st->index_entries[index];
1998 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2000 ff_update_cur_dts(s, st, ie->timestamp);
2005 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2006 int64_t timestamp, int flags)
2011 if (flags & AVSEEK_FLAG_BYTE) {
2012 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2014 ff_read_frame_flush(s);
2015 return seek_frame_byte(s, stream_index, timestamp, flags);
2018 if(stream_index < 0){
2019 stream_index= av_find_default_stream_index(s);
2020 if(stream_index < 0)
2023 st= s->streams[stream_index];
2024 /* timestamp for default must be expressed in AV_TIME_BASE units */
2025 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2028 /* first, we try the format specific seek */
2029 if (s->iformat->read_seek) {
2030 ff_read_frame_flush(s);
2031 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2038 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2039 ff_read_frame_flush(s);
2040 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2041 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2042 ff_read_frame_flush(s);
2043 return seek_frame_generic(s, stream_index, timestamp, flags);
2049 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2053 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2054 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2055 if ((flags & AVSEEK_FLAG_BACKWARD))
2059 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2060 flags & ~AVSEEK_FLAG_BACKWARD);
2063 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2066 ret = avformat_queue_attached_pictures(s);
2071 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2073 if(min_ts > ts || max_ts < ts)
2075 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2076 return AVERROR(EINVAL);
2079 flags |= AVSEEK_FLAG_ANY;
2080 flags &= ~AVSEEK_FLAG_BACKWARD;
2082 if (s->iformat->read_seek2) {
2084 ff_read_frame_flush(s);
2086 if (stream_index == -1 && s->nb_streams == 1) {
2087 AVRational time_base = s->streams[0]->time_base;
2088 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2089 min_ts = av_rescale_rnd(min_ts, time_base.den,
2090 time_base.num * (int64_t)AV_TIME_BASE,
2091 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2092 max_ts = av_rescale_rnd(max_ts, time_base.den,
2093 time_base.num * (int64_t)AV_TIME_BASE,
2094 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2097 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2100 ret = avformat_queue_attached_pictures(s);
2104 if(s->iformat->read_timestamp){
2105 //try to seek via read_timestamp()
2108 // Fall back on old API if new is not implemented but old is.
2109 // Note the old API has somewhat different semantics.
2110 if (s->iformat->read_seek || 1) {
2111 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2112 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2113 if (ret<0 && ts != min_ts && max_ts != ts) {
2114 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2116 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2121 // try some generic seek like seek_frame_generic() but with new ts semantics
2122 return -1; //unreachable
2125 /*******************************************************/
2128 * Return TRUE if the stream has accurate duration in any stream.
2130 * @return TRUE if the stream has accurate duration for at least one component.
2132 static int has_duration(AVFormatContext *ic)
2137 for(i = 0;i < ic->nb_streams; i++) {
2138 st = ic->streams[i];
2139 if (st->duration != AV_NOPTS_VALUE)
2142 if (ic->duration != AV_NOPTS_VALUE)
2148 * Estimate the stream timings from the one of each components.
2150 * Also computes the global bitrate if possible.
2152 static void update_stream_timings(AVFormatContext *ic)
2154 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2155 int64_t duration, duration1, filesize;
2160 start_time = INT64_MAX;
2161 start_time_text = INT64_MAX;
2162 end_time = INT64_MIN;
2163 duration = INT64_MIN;
2164 for(i = 0;i < ic->nb_streams; i++) {
2165 st = ic->streams[i];
2166 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2167 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2168 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2169 if (start_time1 < start_time_text)
2170 start_time_text = start_time1;
2172 start_time = FFMIN(start_time, start_time1);
2173 end_time1 = AV_NOPTS_VALUE;
2174 if (st->duration != AV_NOPTS_VALUE) {
2175 end_time1 = start_time1
2176 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2177 end_time = FFMAX(end_time, end_time1);
2179 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2180 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2181 p->start_time = start_time1;
2182 if(p->end_time < end_time1)
2183 p->end_time = end_time1;
2186 if (st->duration != AV_NOPTS_VALUE) {
2187 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2188 duration = FFMAX(duration, duration1);
2191 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2192 start_time = start_time_text;
2193 else if(start_time > start_time_text)
2194 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2196 if (start_time != INT64_MAX) {
2197 ic->start_time = start_time;
2198 if (end_time != INT64_MIN) {
2199 if (ic->nb_programs) {
2200 for (i=0; i<ic->nb_programs; i++) {
2201 p = ic->programs[i];
2202 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2203 duration = FFMAX(duration, p->end_time - p->start_time);
2206 duration = FFMAX(duration, end_time - start_time);
2209 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2210 ic->duration = duration;
2212 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2213 /* compute the bitrate */
2214 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2215 (double)ic->duration;
2216 if (bitrate >= 0 && bitrate <= INT_MAX)
2217 ic->bit_rate = bitrate;
2221 static void fill_all_stream_timings(AVFormatContext *ic)
2226 update_stream_timings(ic);
2227 for(i = 0;i < ic->nb_streams; i++) {
2228 st = ic->streams[i];
2229 if (st->start_time == AV_NOPTS_VALUE) {
2230 if(ic->start_time != AV_NOPTS_VALUE)
2231 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2232 if(ic->duration != AV_NOPTS_VALUE)
2233 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2238 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2240 int64_t filesize, duration;
2241 int i, show_warning = 0;
2244 /* if bit_rate is already set, we believe it */
2245 if (ic->bit_rate <= 0) {
2247 for(i=0;i<ic->nb_streams;i++) {
2248 st = ic->streams[i];
2249 if (st->codec->bit_rate > 0) {
2250 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2254 bit_rate += st->codec->bit_rate;
2257 ic->bit_rate = bit_rate;
2260 /* if duration is already set, we believe it */
2261 if (ic->duration == AV_NOPTS_VALUE &&
2262 ic->bit_rate != 0) {
2263 filesize = ic->pb ? avio_size(ic->pb) : 0;
2265 for(i = 0; i < ic->nb_streams; i++) {
2266 st = ic->streams[i];
2267 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2268 && st->duration == AV_NOPTS_VALUE) {
2269 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2270 st->duration = duration;
2277 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2280 #define DURATION_MAX_READ_SIZE 250000LL
2281 #define DURATION_MAX_RETRY 4
2283 /* only usable for MPEG-PS streams */
2284 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2286 AVPacket pkt1, *pkt = &pkt1;
2288 int read_size, i, ret;
2290 int64_t filesize, offset, duration;
2293 /* flush packet queue */
2294 flush_packet_queue(ic);
2296 for (i=0; i<ic->nb_streams; i++) {
2297 st = ic->streams[i];
2298 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2299 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2302 av_parser_close(st->parser);
2307 /* estimate the end time (duration) */
2308 /* XXX: may need to support wrapping */
2309 filesize = ic->pb ? avio_size(ic->pb) : 0;
2310 end_time = AV_NOPTS_VALUE;
2312 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2316 avio_seek(ic->pb, offset, SEEK_SET);
2319 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2323 ret = ff_read_packet(ic, pkt);
2324 } while(ret == AVERROR(EAGAIN));
2327 read_size += pkt->size;
2328 st = ic->streams[pkt->stream_index];
2329 if (pkt->pts != AV_NOPTS_VALUE &&
2330 (st->start_time != AV_NOPTS_VALUE ||
2331 st->first_dts != AV_NOPTS_VALUE)) {
2332 duration = end_time = pkt->pts;
2333 if (st->start_time != AV_NOPTS_VALUE)
2334 duration -= st->start_time;
2336 duration -= st->first_dts;
2338 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2339 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2340 st->duration = duration;
2341 st->info->last_duration = duration;
2344 av_free_packet(pkt);
2346 }while( end_time==AV_NOPTS_VALUE
2347 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2348 && ++retry <= DURATION_MAX_RETRY);
2350 fill_all_stream_timings(ic);
2352 avio_seek(ic->pb, old_offset, SEEK_SET);
2353 for (i=0; i<ic->nb_streams; i++) {
2355 st->cur_dts= st->first_dts;
2356 st->last_IP_pts = AV_NOPTS_VALUE;
2360 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2364 /* get the file size, if possible */
2365 if (ic->iformat->flags & AVFMT_NOFILE) {
2368 file_size = avio_size(ic->pb);
2369 file_size = FFMAX(0, file_size);
2372 if ((!strcmp(ic->iformat->name, "mpeg") ||
2373 !strcmp(ic->iformat->name, "mpegts")) &&
2374 file_size && ic->pb->seekable) {
2375 /* get accurate estimate from the PTSes */
2376 estimate_timings_from_pts(ic, old_offset);
2377 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2378 } else if (has_duration(ic)) {
2379 /* at least one component has timings - we use them for all
2381 fill_all_stream_timings(ic);
2382 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2384 /* less precise: use bitrate info */
2385 estimate_timings_from_bit_rate(ic);
2386 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2388 update_stream_timings(ic);
2392 AVStream av_unused *st;
2393 for(i = 0;i < ic->nb_streams; i++) {
2394 st = ic->streams[i];
2395 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2396 (double) st->start_time / AV_TIME_BASE,
2397 (double) st->duration / AV_TIME_BASE);
2399 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2400 (double) ic->start_time / AV_TIME_BASE,
2401 (double) ic->duration / AV_TIME_BASE,
2402 ic->bit_rate / 1000);
2406 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2408 AVCodecContext *avctx = st->codec;
2410 #define FAIL(errmsg) do { \
2412 *errmsg_ptr = errmsg; \
2416 switch (avctx->codec_type) {
2417 case AVMEDIA_TYPE_AUDIO:
2418 if (!avctx->frame_size && determinable_frame_size(avctx))
2419 FAIL("unspecified frame size");
2420 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2421 FAIL("unspecified sample format");
2422 if (!avctx->sample_rate)
2423 FAIL("unspecified sample rate");
2424 if (!avctx->channels)
2425 FAIL("unspecified number of channels");
2426 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2427 FAIL("no decodable DTS frames");
2429 case AVMEDIA_TYPE_VIDEO:
2431 FAIL("unspecified size");
2432 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2433 FAIL("unspecified pixel format");
2434 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2435 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2436 FAIL("no frame in rv30/40 and no sar");
2438 case AVMEDIA_TYPE_SUBTITLE:
2439 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2440 FAIL("unspecified size");
2442 case AVMEDIA_TYPE_DATA:
2443 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2446 if (avctx->codec_id == AV_CODEC_ID_NONE)
2447 FAIL("unknown codec");
2451 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2452 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2454 const AVCodec *codec;
2455 int got_picture = 1, ret = 0;
2456 AVFrame *frame = av_frame_alloc();
2457 AVSubtitle subtitle;
2458 AVPacket pkt = *avpkt;
2461 return AVERROR(ENOMEM);
2463 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2464 AVDictionary *thread_opt = NULL;
2466 codec = find_decoder(s, st, st->codec->codec_id);
2469 st->info->found_decoder = -1;
2474 /* force thread count to 1 since the h264 decoder will not extract SPS
2475 * and PPS to extradata during multi-threaded decoding */
2476 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2477 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2479 av_dict_free(&thread_opt);
2481 st->info->found_decoder = -1;
2484 st->info->found_decoder = 1;
2485 } else if (!st->info->found_decoder)
2486 st->info->found_decoder = 1;
2488 if (st->info->found_decoder < 0) {
2493 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2495 (!has_codec_parameters(st, NULL) ||
2496 !has_decode_delay_been_guessed(st) ||
2497 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2499 avcodec_get_frame_defaults(frame);
2500 switch(st->codec->codec_type) {
2501 case AVMEDIA_TYPE_VIDEO:
2502 ret = avcodec_decode_video2(st->codec, frame,
2503 &got_picture, &pkt);
2505 case AVMEDIA_TYPE_AUDIO:
2506 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2508 case AVMEDIA_TYPE_SUBTITLE:
2509 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2510 &got_picture, &pkt);
2518 st->nb_decoded_frames++;
2525 if(!pkt.data && !got_picture)
2529 avcodec_free_frame(&frame);
2533 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2535 while (tags->id != AV_CODEC_ID_NONE) {
2543 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2546 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2547 if(tag == tags[i].tag)
2550 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2551 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2554 return AV_CODEC_ID_NONE;
2557 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2561 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2562 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2563 default: return AV_CODEC_ID_NONE;
2568 if (sflags & (1 << (bps - 1))) {
2570 case 1: return AV_CODEC_ID_PCM_S8;
2571 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2572 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2573 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2574 default: return AV_CODEC_ID_NONE;
2578 case 1: return AV_CODEC_ID_PCM_U8;
2579 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2580 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2581 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2582 default: return AV_CODEC_ID_NONE;
2588 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2591 if (!av_codec_get_tag2(tags, id, &tag))
2596 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2600 for(i=0; tags && tags[i]; i++){
2601 const AVCodecTag *codec_tags = tags[i];
2602 while (codec_tags->id != AV_CODEC_ID_NONE) {
2603 if (codec_tags->id == id) {
2604 *tag = codec_tags->tag;
2613 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2616 for(i=0; tags && tags[i]; i++){
2617 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2618 if(id!=AV_CODEC_ID_NONE) return id;
2620 return AV_CODEC_ID_NONE;
2623 static void compute_chapters_end(AVFormatContext *s)
2626 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2628 for (i = 0; i < s->nb_chapters; i++)
2629 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2630 AVChapter *ch = s->chapters[i];
2631 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2634 for (j = 0; j < s->nb_chapters; j++) {
2635 AVChapter *ch1 = s->chapters[j];
2636 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2637 if (j != i && next_start > ch->start && next_start < end)
2640 ch->end = (end == INT64_MAX) ? ch->start : end;
2644 static int get_std_framerate(int i){
2645 if(i<60*12) return (i+1)*1001;
2646 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2650 * Is the time base unreliable.
2651 * This is a heuristic to balance between quick acceptance of the values in
2652 * the headers vs. some extra checks.
2653 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2654 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2655 * And there are "variable" fps files this needs to detect as well.
2657 static int tb_unreliable(AVCodecContext *c){
2658 if( c->time_base.den >= 101L*c->time_base.num
2659 || c->time_base.den < 5L*c->time_base.num
2660 /* || c->codec_tag == AV_RL32("DIVX")
2661 || c->codec_tag == AV_RL32("XVID")*/
2662 || c->codec_tag == AV_RL32("mp4v")
2663 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2664 || c->codec_id == AV_CODEC_ID_H264
2670 #if FF_API_FORMAT_PARAMETERS
2671 int av_find_stream_info(AVFormatContext *ic)
2673 return avformat_find_stream_info(ic, NULL);
2677 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2681 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2682 avctx->extradata_size = 0;
2683 return AVERROR(EINVAL);
2685 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2686 if (avctx->extradata) {
2687 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2688 avctx->extradata_size = size;
2691 avctx->extradata_size = 0;
2692 ret = AVERROR(ENOMEM);
2697 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2699 int i, count, ret = 0, j;
2702 AVPacket pkt1, *pkt;
2703 int64_t old_offset = avio_tell(ic->pb);
2704 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2705 int flush_codecs = ic->probesize > 0;
2708 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2710 for(i=0;i<ic->nb_streams;i++) {
2711 const AVCodec *codec;
2712 AVDictionary *thread_opt = NULL;
2713 st = ic->streams[i];
2715 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2716 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2717 /* if(!st->time_base.num)
2719 if(!st->codec->time_base.num)
2720 st->codec->time_base= st->time_base;
2722 //only for the split stuff
2723 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2724 st->parser = av_parser_init(st->codec->codec_id);
2726 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2727 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2728 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2729 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2731 } else if (st->need_parsing) {
2732 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2733 "%s, packets or times may be invalid.\n",
2734 avcodec_get_name(st->codec->codec_id));
2737 codec = find_decoder(ic, st, st->codec->codec_id);
2739 /* force thread count to 1 since the h264 decoder will not extract SPS
2740 * and PPS to extradata during multi-threaded decoding */
2741 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2743 /* Ensure that subtitle_header is properly set. */
2744 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2745 && codec && !st->codec->codec)
2746 avcodec_open2(st->codec, codec, options ? &options[i]
2749 //try to just open decoders, in case this is enough to get parameters
2750 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2751 if (codec && !st->codec->codec)
2752 avcodec_open2(st->codec, codec, options ? &options[i]
2756 av_dict_free(&thread_opt);
2759 for (i=0; i<ic->nb_streams; i++) {
2760 #if FF_API_R_FRAME_RATE
2761 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2763 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2764 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2770 if (ff_check_interrupt(&ic->interrupt_callback)){
2772 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2776 /* check if one codec still needs to be handled */
2777 for(i=0;i<ic->nb_streams;i++) {
2778 int fps_analyze_framecount = 20;
2780 st = ic->streams[i];
2781 if (!has_codec_parameters(st, NULL))
2783 /* if the timebase is coarse (like the usual millisecond precision
2784 of mkv), we need to analyze more frames to reliably arrive at
2786 if (av_q2d(st->time_base) > 0.0005)
2787 fps_analyze_framecount *= 2;
2788 if (ic->fps_probe_size >= 0)
2789 fps_analyze_framecount = ic->fps_probe_size;
2790 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2791 fps_analyze_framecount = 0;
2792 /* variable fps and no guess at the real fps */
2793 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2794 && st->info->duration_count < fps_analyze_framecount
2795 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2797 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2799 if (st->first_dts == AV_NOPTS_VALUE &&
2800 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2801 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2804 if (i == ic->nb_streams) {
2805 /* NOTE: if the format has no header, then we need to read
2806 some packets to get most of the streams, so we cannot
2808 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2809 /* if we found the info for all the codecs, we can stop */
2811 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2816 /* we did not get all the codec info, but we read too much data */
2817 if (read_size >= ic->probesize) {
2819 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2820 for (i = 0; i < ic->nb_streams; i++)
2821 if (!ic->streams[i]->r_frame_rate.num &&
2822 ic->streams[i]->info->duration_count <= 1 &&
2823 strcmp(ic->iformat->name, "image2"))
2824 av_log(ic, AV_LOG_WARNING,
2825 "Stream #%d: not enough frames to estimate rate; "
2826 "consider increasing probesize\n", i);
2830 /* NOTE: a new stream can be added there if no header in file
2831 (AVFMTCTX_NOHEADER) */
2832 ret = read_frame_internal(ic, &pkt1);
2833 if (ret == AVERROR(EAGAIN))
2841 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2842 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2844 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2845 &ic->packet_buffer_end);
2847 ret = AVERROR(ENOMEM);
2848 goto find_stream_info_err;
2850 if ((ret = av_dup_packet(pkt)) < 0)
2851 goto find_stream_info_err;
2854 st = ic->streams[pkt->stream_index];
2855 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2856 read_size += pkt->size;
2858 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2859 /* check for non-increasing dts */
2860 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2861 st->info->fps_last_dts >= pkt->dts) {
2862 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2863 "packet %d with DTS %"PRId64", packet %d with DTS "
2864 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2865 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2866 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2868 /* check for a discontinuity in dts - if the difference in dts
2869 * is more than 1000 times the average packet duration in the sequence,
2870 * we treat it as a discontinuity */
2871 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2872 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2873 (pkt->dts - st->info->fps_last_dts) / 1000 >
2874 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2875 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2876 "packet %d with DTS %"PRId64", packet %d with DTS "
2877 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2878 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2879 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2882 /* update stored dts values */
2883 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2884 st->info->fps_first_dts = pkt->dts;
2885 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2887 st->info->fps_last_dts = pkt->dts;
2888 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2890 if (st->codec_info_nb_frames>1) {
2892 if (st->time_base.den > 0)
2893 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2894 if (st->avg_frame_rate.num > 0)
2895 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2898 && st->codec_info_nb_frames>30
2899 && st->info->fps_first_dts != AV_NOPTS_VALUE
2900 && st->info->fps_last_dts != AV_NOPTS_VALUE)
2901 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
2903 if (t >= ic->max_analyze_duration) {
2904 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2907 if (pkt->duration) {
2908 st->info->codec_info_duration += pkt->duration;
2909 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2912 #if FF_API_R_FRAME_RATE
2914 int64_t last = st->info->last_dts;
2916 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2917 && pkt->dts - (uint64_t)last < INT64_MAX){
2918 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2919 int64_t duration= pkt->dts - last;
2921 if (!st->info->duration_error)
2922 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2923 if (!st->info->duration_error)
2924 return AVERROR(ENOMEM);
2926 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2927 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2928 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2929 int framerate= get_std_framerate(i);
2930 double sdts= dts*framerate/(1001*12);
2932 int64_t ticks= llrint(sdts+j*0.5);
2933 double error= sdts - ticks + j*0.5;
2934 st->info->duration_error[j][0][i] += error;
2935 st->info->duration_error[j][1][i] += error*error;
2938 st->info->duration_count++;
2939 // ignore the first 4 values, they might have some random jitter
2940 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2941 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2943 if (pkt->dts != AV_NOPTS_VALUE)
2944 st->info->last_dts = pkt->dts;
2947 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2948 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2949 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2950 if (ff_alloc_extradata(st->codec, i))
2951 return AVERROR(ENOMEM);
2952 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2956 /* if still no information, we try to open the codec and to
2957 decompress the frame. We try to avoid that in most cases as
2958 it takes longer and uses more memory. For MPEG-4, we need to
2959 decompress for QuickTime.
2961 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2962 least one frame of codec data, this makes sure the codec initializes
2963 the channel configuration and does not only trust the values from the container.
2965 try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2967 st->codec_info_nb_frames++;
2972 AVPacket empty_pkt = { 0 };
2974 av_init_packet(&empty_pkt);
2976 for(i=0;i<ic->nb_streams;i++) {
2978 st = ic->streams[i];
2980 /* flush the decoders */
2981 if (st->info->found_decoder == 1) {
2983 err = try_decode_frame(ic, st, &empty_pkt,
2984 (options && i < orig_nb_streams) ?
2985 &options[i] : NULL);
2986 } while (err > 0 && !has_codec_parameters(st, NULL));
2989 av_log(ic, AV_LOG_INFO,
2990 "decoding for stream %d failed\n", st->index);
2996 // close codecs which were opened in try_decode_frame()
2997 for(i=0;i<ic->nb_streams;i++) {
2998 st = ic->streams[i];
2999 avcodec_close(st->codec);
3001 for(i=0;i<ic->nb_streams;i++) {
3002 st = ic->streams[i];
3003 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3004 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3005 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3006 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3007 st->codec->codec_tag= tag;
3010 /* estimate average framerate if not set by demuxer */
3011 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3013 double best_error = 0.01;
3015 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3016 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3017 st->info->codec_info_duration < 0)
3019 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3020 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3021 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3023 /* round guessed framerate to a "standard" framerate if it's
3024 * within 1% of the original estimate*/
3025 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3026 AVRational std_fps = { get_std_framerate(j), 12*1001 };
3027 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3029 if (error < best_error) {
3031 best_fps = std_fps.num;
3035 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3036 best_fps, 12*1001, INT_MAX);
3039 // the check for tb_unreliable() is not completely correct, since this is not about handling
3040 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3041 // ipmovie.c produces.
3042 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)
3043 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);
3044 if (st->info->duration_count>1 && !st->r_frame_rate.num
3045 && tb_unreliable(st->codec)) {
3047 double best_error= 0.01;
3049 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3052 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3054 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3057 int n= st->info->duration_count;
3058 double a= st->info->duration_error[k][0][j] / n;
3059 double error= st->info->duration_error[k][1][j]/n - a*a;
3061 if(error < best_error && best_error> 0.000000001){
3063 num = get_std_framerate(j);
3066 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3069 // do not increase frame rate by more than 1 % in order to match a standard rate.
3070 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3071 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3074 if (!st->r_frame_rate.num){
3075 if( st->codec->time_base.den * (int64_t)st->time_base.num
3076 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3077 st->r_frame_rate.num = st->codec->time_base.den;
3078 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3080 st->r_frame_rate.num = st->time_base.den;
3081 st->r_frame_rate.den = st->time_base.num;
3084 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3085 if(!st->codec->bits_per_coded_sample)
3086 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3087 // set stream disposition based on audio service type
3088 switch (st->codec->audio_service_type) {
3089 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3090 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3091 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3092 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3093 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3094 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3095 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3096 st->disposition = AV_DISPOSITION_COMMENT; break;
3097 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3098 st->disposition = AV_DISPOSITION_KARAOKE; break;
3104 estimate_timings(ic, old_offset);
3106 if (ret >= 0 && ic->nb_streams)
3107 ret = -1; /* we could not have all the codec parameters before EOF */
3108 for(i=0;i<ic->nb_streams;i++) {
3110 st = ic->streams[i];
3111 if (!has_codec_parameters(st, &errmsg)) {
3113 avcodec_string(buf, sizeof(buf), st->codec, 0);
3114 av_log(ic, AV_LOG_WARNING,
3115 "Could not find codec parameters for stream %d (%s): %s\n"
3116 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3123 compute_chapters_end(ic);
3125 find_stream_info_err:
3126 for (i=0; i < ic->nb_streams; i++) {
3127 st = ic->streams[i];
3128 if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3129 ic->streams[i]->codec->thread_count = 0;
3131 av_freep(&st->info->duration_error);
3132 av_freep(&ic->streams[i]->info);
3135 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3139 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3143 for (i = 0; i < ic->nb_programs; i++) {
3144 if (ic->programs[i] == last) {
3148 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3149 if (ic->programs[i]->stream_index[j] == s)
3150 return ic->programs[i];
3156 int av_find_best_stream(AVFormatContext *ic,
3157 enum AVMediaType type,
3158 int wanted_stream_nb,
3160 AVCodec **decoder_ret,
3163 int i, nb_streams = ic->nb_streams;
3164 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3165 unsigned *program = NULL;
3166 AVCodec *decoder = NULL, *best_decoder = NULL;
3168 if (related_stream >= 0 && wanted_stream_nb < 0) {
3169 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3171 program = p->stream_index;
3172 nb_streams = p->nb_stream_indexes;
3175 for (i = 0; i < nb_streams; i++) {
3176 int real_stream_index = program ? program[i] : i;
3177 AVStream *st = ic->streams[real_stream_index];
3178 AVCodecContext *avctx = st->codec;
3179 if (avctx->codec_type != type)
3181 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3183 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3186 decoder = find_decoder(ic, st, st->codec->codec_id);
3189 ret = AVERROR_DECODER_NOT_FOUND;
3193 count = st->codec_info_nb_frames;
3194 bitrate = avctx->bit_rate;
3195 multiframe = FFMIN(5, count);
3196 if ((best_multiframe > multiframe) ||
3197 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3198 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3201 best_bitrate = bitrate;
3202 best_multiframe = multiframe;
3203 ret = real_stream_index;
3204 best_decoder = decoder;
3205 if (program && i == nb_streams - 1 && ret < 0) {
3207 nb_streams = ic->nb_streams;
3208 i = 0; /* no related stream found, try again with everything */
3212 *decoder_ret = best_decoder;
3216 /*******************************************************/
3218 int av_read_play(AVFormatContext *s)
3220 if (s->iformat->read_play)
3221 return s->iformat->read_play(s);
3223 return avio_pause(s->pb, 0);
3224 return AVERROR(ENOSYS);
3227 int av_read_pause(AVFormatContext *s)
3229 if (s->iformat->read_pause)
3230 return s->iformat->read_pause(s);
3232 return avio_pause(s->pb, 1);
3233 return AVERROR(ENOSYS);
3236 void ff_free_stream(AVFormatContext *s, AVStream *st){
3237 av_assert0(s->nb_streams>0);
3238 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3241 av_parser_close(st->parser);
3243 if (st->attached_pic.data)
3244 av_free_packet(&st->attached_pic);
3245 av_dict_free(&st->metadata);
3246 av_freep(&st->probe_data.buf);
3247 av_freep(&st->index_entries);
3248 av_freep(&st->codec->extradata);
3249 av_freep(&st->codec->subtitle_header);
3250 av_freep(&st->codec);
3251 av_freep(&st->priv_data);
3253 av_freep(&st->info->duration_error);
3254 av_freep(&st->info);
3255 av_freep(&s->streams[ --s->nb_streams ]);
3258 void avformat_free_context(AVFormatContext *s)
3266 if (s->iformat && s->iformat->priv_class && s->priv_data)
3267 av_opt_free(s->priv_data);
3269 for(i=s->nb_streams-1; i>=0; i--) {
3270 ff_free_stream(s, s->streams[i]);
3272 for(i=s->nb_programs-1; i>=0; i--) {
3273 av_dict_free(&s->programs[i]->metadata);
3274 av_freep(&s->programs[i]->stream_index);
3275 av_freep(&s->programs[i]);
3277 av_freep(&s->programs);
3278 av_freep(&s->priv_data);
3279 while(s->nb_chapters--) {
3280 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3281 av_freep(&s->chapters[s->nb_chapters]);
3283 av_freep(&s->chapters);
3284 av_dict_free(&s->metadata);
3285 av_freep(&s->streams);
3289 #if FF_API_CLOSE_INPUT_FILE
3290 void av_close_input_file(AVFormatContext *s)
3292 avformat_close_input(&s);
3296 void avformat_close_input(AVFormatContext **ps)
3307 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3308 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3311 flush_packet_queue(s);
3314 if (s->iformat->read_close)
3315 s->iformat->read_close(s);
3318 avformat_free_context(s);
3325 #if FF_API_NEW_STREAM
3326 AVStream *av_new_stream(AVFormatContext *s, int id)
3328 AVStream *st = avformat_new_stream(s, NULL);
3335 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3341 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3343 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3346 s->streams = streams;
3348 st = av_mallocz(sizeof(AVStream));
3351 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3355 st->info->last_dts = AV_NOPTS_VALUE;
3357 st->codec = avcodec_alloc_context3(c);
3359 /* no default bitrate if decoding */
3360 st->codec->bit_rate = 0;
3362 st->index = s->nb_streams;
3363 st->start_time = AV_NOPTS_VALUE;
3364 st->duration = AV_NOPTS_VALUE;
3365 /* we set the current DTS to 0 so that formats without any timestamps
3366 but durations get some timestamps, formats with some unknown
3367 timestamps have their first few packets buffered and the
3368 timestamps corrected before they are returned to the user */
3369 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3370 st->first_dts = AV_NOPTS_VALUE;
3371 st->probe_packets = MAX_PROBE_PACKETS;
3372 st->pts_wrap_reference = AV_NOPTS_VALUE;
3373 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3375 /* default pts setting is MPEG-like */
3376 avpriv_set_pts_info(st, 33, 1, 90000);
3377 st->last_IP_pts = AV_NOPTS_VALUE;
3378 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3379 st->pts_buffer[i]= AV_NOPTS_VALUE;
3381 st->sample_aspect_ratio = (AVRational){0,1};
3383 #if FF_API_R_FRAME_RATE
3384 st->info->last_dts = AV_NOPTS_VALUE;
3386 st->info->fps_first_dts = AV_NOPTS_VALUE;
3387 st->info->fps_last_dts = AV_NOPTS_VALUE;
3389 s->streams[s->nb_streams++] = st;
3393 AVProgram *av_new_program(AVFormatContext *ac, int id)
3395 AVProgram *program=NULL;
3398 av_dlog(ac, "new_program: id=0x%04x\n", id);
3400 for(i=0; i<ac->nb_programs; i++)
3401 if(ac->programs[i]->id == id)
3402 program = ac->programs[i];
3405 program = av_mallocz(sizeof(AVProgram));
3408 dynarray_add(&ac->programs, &ac->nb_programs, program);
3409 program->discard = AVDISCARD_NONE;
3412 program->pts_wrap_reference = AV_NOPTS_VALUE;
3413 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3415 program->start_time =
3416 program->end_time = AV_NOPTS_VALUE;
3421 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3423 AVChapter *chapter = NULL;
3426 for(i=0; i<s->nb_chapters; i++)
3427 if(s->chapters[i]->id == id)
3428 chapter = s->chapters[i];
3431 chapter= av_mallocz(sizeof(AVChapter));
3434 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3436 av_dict_set(&chapter->metadata, "title", title, 0);
3438 chapter->time_base= time_base;
3439 chapter->start = start;
3445 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3448 AVProgram *program=NULL;
3451 if (idx >= ac->nb_streams) {
3452 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3456 for(i=0; i<ac->nb_programs; i++){
3457 if(ac->programs[i]->id != progid)
3459 program = ac->programs[i];
3460 for(j=0; j<program->nb_stream_indexes; j++)
3461 if(program->stream_index[j] == idx)
3464 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3467 program->stream_index = tmp;
3468 program->stream_index[program->nb_stream_indexes++] = idx;
3473 static void print_fps(double d, const char *postfix){
3474 uint64_t v= lrintf(d*100);
3475 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3476 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3477 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3480 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3482 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3483 AVDictionaryEntry *tag=NULL;
3485 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3486 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3487 if(strcmp("language", tag->key)){
3488 const char *p = tag->value;
3489 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3492 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3493 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3494 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3496 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3497 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3500 av_log(ctx, AV_LOG_INFO, "\n");
3506 /* "user interface" functions */
3507 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3510 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3511 AVStream *st = ic->streams[i];
3512 int g = av_gcd(st->time_base.num, st->time_base.den);
3513 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3514 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3515 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3516 /* the pid is an important information, so we display it */
3517 /* XXX: add a generic system */
3518 if (flags & AVFMT_SHOW_IDS)
3519 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3521 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3522 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3523 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3524 if (st->sample_aspect_ratio.num && // default
3525 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3526 AVRational display_aspect_ratio;
3527 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3528 st->codec->width*st->sample_aspect_ratio.num,
3529 st->codec->height*st->sample_aspect_ratio.den,
3531 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3532 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3533 display_aspect_ratio.num, display_aspect_ratio.den);
3535 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3536 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3537 print_fps(av_q2d(st->avg_frame_rate), "fps");
3538 #if FF_API_R_FRAME_RATE
3539 if(st->r_frame_rate.den && st->r_frame_rate.num)
3540 print_fps(av_q2d(st->r_frame_rate), "tbr");
3542 if(st->time_base.den && st->time_base.num)
3543 print_fps(1/av_q2d(st->time_base), "tbn");
3544 if(st->codec->time_base.den && st->codec->time_base.num)
3545 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3547 if (st->disposition & AV_DISPOSITION_DEFAULT)
3548 av_log(NULL, AV_LOG_INFO, " (default)");
3549 if (st->disposition & AV_DISPOSITION_DUB)
3550 av_log(NULL, AV_LOG_INFO, " (dub)");
3551 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3552 av_log(NULL, AV_LOG_INFO, " (original)");
3553 if (st->disposition & AV_DISPOSITION_COMMENT)
3554 av_log(NULL, AV_LOG_INFO, " (comment)");
3555 if (st->disposition & AV_DISPOSITION_LYRICS)
3556 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3557 if (st->disposition & AV_DISPOSITION_KARAOKE)
3558 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3559 if (st->disposition & AV_DISPOSITION_FORCED)
3560 av_log(NULL, AV_LOG_INFO, " (forced)");
3561 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3562 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3563 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3564 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3565 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3566 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3567 av_log(NULL, AV_LOG_INFO, "\n");
3568 dump_metadata(NULL, st->metadata, " ");
3571 void av_dump_format(AVFormatContext *ic,
3577 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3578 if (ic->nb_streams && !printed)
3581 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3582 is_output ? "Output" : "Input",
3584 is_output ? ic->oformat->name : ic->iformat->name,
3585 is_output ? "to" : "from", url);
3586 dump_metadata(NULL, ic->metadata, " ");
3588 av_log(NULL, AV_LOG_INFO, " Duration: ");
3589 if (ic->duration != AV_NOPTS_VALUE) {
3590 int hours, mins, secs, us;
3591 int64_t duration = ic->duration + 5000;
3592 secs = duration / AV_TIME_BASE;
3593 us = duration % AV_TIME_BASE;
3598 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3599 (100 * us) / AV_TIME_BASE);
3601 av_log(NULL, AV_LOG_INFO, "N/A");
3603 if (ic->start_time != AV_NOPTS_VALUE) {
3605 av_log(NULL, AV_LOG_INFO, ", start: ");
3606 secs = ic->start_time / AV_TIME_BASE;
3607 us = abs(ic->start_time % AV_TIME_BASE);
3608 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3609 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3611 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3613 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3615 av_log(NULL, AV_LOG_INFO, "N/A");
3617 av_log(NULL, AV_LOG_INFO, "\n");
3619 for (i = 0; i < ic->nb_chapters; i++) {
3620 AVChapter *ch = ic->chapters[i];
3621 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3622 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3623 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3625 dump_metadata(NULL, ch->metadata, " ");
3627 if(ic->nb_programs) {
3628 int j, k, total = 0;
3629 for(j=0; j<ic->nb_programs; j++) {
3630 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3632 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3633 name ? name->value : "");
3634 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3635 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3636 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3637 printed[ic->programs[j]->stream_index[k]] = 1;
3639 total += ic->programs[j]->nb_stream_indexes;
3641 if (total < ic->nb_streams)
3642 av_log(NULL, AV_LOG_INFO, " No Program\n");
3644 for(i=0;i<ic->nb_streams;i++)
3646 dump_stream_format(ic, i, index, is_output);
3651 uint64_t ff_ntp_time(void)
3653 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3656 int av_get_frame_filename(char *buf, int buf_size,
3657 const char *path, int number)
3660 char *q, buf1[20], c;
3661 int nd, len, percentd_found;
3673 while (av_isdigit(*p)) {
3674 nd = nd * 10 + *p++ - '0';
3677 } while (av_isdigit(c));
3686 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3688 if ((q - buf + len) > buf_size - 1)
3690 memcpy(q, buf1, len);
3698 if ((q - buf) < buf_size - 1)
3702 if (!percentd_found)
3711 static void hex_dump_internal(void *avcl, FILE *f, int level,
3712 const uint8_t *buf, int size)
3715 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3717 for(i=0;i<size;i+=16) {
3724 PRINT(" %02x", buf[i+j]);
3729 for(j=0;j<len;j++) {
3731 if (c < ' ' || c > '~')
3740 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3742 hex_dump_internal(NULL, f, 0, buf, size);
3745 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3747 hex_dump_internal(avcl, NULL, level, buf, size);
3750 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3752 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3753 PRINT("stream #%d:\n", pkt->stream_index);
3754 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3755 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3756 /* DTS is _always_ valid after av_read_frame() */
3758 if (pkt->dts == AV_NOPTS_VALUE)
3761 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3762 /* PTS may not be known if B-frames are present. */
3764 if (pkt->pts == AV_NOPTS_VALUE)
3767 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3769 PRINT(" size=%d\n", pkt->size);
3772 av_hex_dump(f, pkt->data, pkt->size);
3775 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3777 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3780 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3783 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3786 void av_url_split(char *proto, int proto_size,
3787 char *authorization, int authorization_size,
3788 char *hostname, int hostname_size,
3790 char *path, int path_size,
3793 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3795 if (port_ptr) *port_ptr = -1;
3796 if (proto_size > 0) proto[0] = 0;
3797 if (authorization_size > 0) authorization[0] = 0;
3798 if (hostname_size > 0) hostname[0] = 0;
3799 if (path_size > 0) path[0] = 0;
3801 /* parse protocol */
3802 if ((p = strchr(url, ':'))) {
3803 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3808 /* no protocol means plain filename */
3809 av_strlcpy(path, url, path_size);
3813 /* separate path from hostname */
3814 ls = strchr(p, '/');
3815 ls2 = strchr(p, '?');
3819 ls = FFMIN(ls, ls2);
3821 av_strlcpy(path, ls, path_size);
3823 ls = &p[strlen(p)]; // XXX
3825 /* the rest is hostname, use that to parse auth/port */
3827 /* authorization (user[:pass]@hostname) */
3829 while ((at = strchr(p, '@')) && at < ls) {
3830 av_strlcpy(authorization, at2,
3831 FFMIN(authorization_size, at + 1 - at2));
3832 p = at + 1; /* skip '@' */
3835 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3837 av_strlcpy(hostname, p + 1,
3838 FFMIN(hostname_size, brk - p));
3839 if (brk[1] == ':' && port_ptr)
3840 *port_ptr = atoi(brk + 2);
3841 } else if ((col = strchr(p, ':')) && col < ls) {
3842 av_strlcpy(hostname, p,
3843 FFMIN(col + 1 - p, hostname_size));
3844 if (port_ptr) *port_ptr = atoi(col + 1);
3846 av_strlcpy(hostname, p,
3847 FFMIN(ls + 1 - p, hostname_size));
3851 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3854 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3857 'C', 'D', 'E', 'F' };
3858 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3861 'c', 'd', 'e', 'f' };
3862 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3864 for(i = 0; i < s; i++) {
3865 buff[i * 2] = hex_table[src[i] >> 4];
3866 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3872 int ff_hex_to_data(uint8_t *data, const char *p)
3879 p += strspn(p, SPACE_CHARS);
3882 c = av_toupper((unsigned char) *p++);
3883 if (c >= '0' && c <= '9')
3885 else if (c >= 'A' && c <= 'F')
3900 #if FF_API_SET_PTS_INFO
3901 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3902 unsigned int pts_num, unsigned int pts_den)
3904 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3908 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3909 unsigned int pts_num, unsigned int pts_den)
3912 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3913 if(new_tb.num != pts_num)
3914 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3916 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3918 if(new_tb.num <= 0 || new_tb.den <= 0) {
3919 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
3922 s->time_base = new_tb;
3923 av_codec_set_pkt_timebase(s->codec, new_tb);
3924 s->pts_wrap_bits = pts_wrap_bits;
3927 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3930 const char *ptr = str;
3932 /* Parse key=value pairs. */
3935 char *dest = NULL, *dest_end;
3936 int key_len, dest_len = 0;
3938 /* Skip whitespace and potential commas. */
3939 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3946 if (!(ptr = strchr(key, '=')))
3949 key_len = ptr - key;
3951 callback_get_buf(context, key, key_len, &dest, &dest_len);
3952 dest_end = dest + dest_len - 1;
3956 while (*ptr && *ptr != '\"') {
3960 if (dest && dest < dest_end)
3964 if (dest && dest < dest_end)
3972 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3973 if (dest && dest < dest_end)
3981 int ff_find_stream_index(AVFormatContext *s, int id)
3984 for (i = 0; i < s->nb_streams; i++) {
3985 if (s->streams[i]->id == id)
3991 int64_t ff_iso8601_to_unix_time(const char *datestr)
3993 struct tm time1 = {0}, time2 = {0};
3995 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
3996 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
3998 return av_timegm(&time2);
4000 return av_timegm(&time1);
4003 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4006 if (ofmt->query_codec)
4007 return ofmt->query_codec(codec_id, std_compliance);
4008 else if (ofmt->codec_tag)
4009 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4010 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4011 codec_id == ofmt->subtitle_codec)
4014 return AVERROR_PATCHWELCOME;
4017 int avformat_network_init(void)
4021 ff_network_inited_globally = 1;
4022 if ((ret = ff_network_init()) < 0)
4029 int avformat_network_deinit(void)
4038 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4039 uint64_t channel_layout, int32_t sample_rate,
4040 int32_t width, int32_t height)
4046 return AVERROR(EINVAL);
4049 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4051 if (channel_layout) {
4053 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4057 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4059 if (width || height) {
4061 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4063 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4065 return AVERROR(ENOMEM);
4066 bytestream_put_le32(&data, flags);
4068 bytestream_put_le32(&data, channels);
4070 bytestream_put_le64(&data, channel_layout);
4072 bytestream_put_le32(&data, sample_rate);
4073 if (width || height) {
4074 bytestream_put_le32(&data, width);
4075 bytestream_put_le32(&data, height);
4080 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4082 AVRational undef = {0, 1};
4083 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4084 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4085 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4087 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4088 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4089 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4090 stream_sample_aspect_ratio = undef;
4092 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4093 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4094 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4095 frame_sample_aspect_ratio = undef;
4097 if (stream_sample_aspect_ratio.num)
4098 return stream_sample_aspect_ratio;
4100 return frame_sample_aspect_ratio;
4103 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4105 AVRational fr = st->r_frame_rate;
4107 if (st->codec->ticks_per_frame > 1) {
4108 AVRational codec_fr = av_inv_q(st->codec->time_base);
4109 AVRational avg_fr = st->avg_frame_rate;
4110 codec_fr.den *= st->codec->ticks_per_frame;
4111 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4112 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4119 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4122 if (*spec <= '9' && *spec >= '0') /* opt:index */
4123 return strtol(spec, NULL, 0) == st->index;
4124 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4125 *spec == 't') { /* opt:[vasdt] */
4126 enum AVMediaType type;
4129 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4130 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4131 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4132 case 'd': type = AVMEDIA_TYPE_DATA; break;
4133 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4134 default: av_assert0(0);
4136 if (type != st->codec->codec_type)
4138 if (*spec++ == ':') { /* possibly followed by :index */
4139 int i, index = strtol(spec, NULL, 0);
4140 for (i = 0; i < s->nb_streams; i++)
4141 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4142 return i == st->index;
4146 } else if (*spec == 'p' && *(spec + 1) == ':') {
4150 prog_id = strtol(spec, &endptr, 0);
4151 for (i = 0; i < s->nb_programs; i++) {
4152 if (s->programs[i]->id != prog_id)
4155 if (*endptr++ == ':') {
4156 int stream_idx = strtol(endptr, NULL, 0);
4157 return stream_idx >= 0 &&
4158 stream_idx < s->programs[i]->nb_stream_indexes &&
4159 st->index == s->programs[i]->stream_index[stream_idx];
4162 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4163 if (st->index == s->programs[i]->stream_index[j])
4167 } else if (*spec == '#') {
4170 sid = strtol(spec + 1, &endptr, 0);
4172 return st->id == sid;
4173 } else if (!*spec) /* empty specifier, matches everything */
4176 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4177 return AVERROR(EINVAL);
4180 int ff_generate_avci_extradata(AVStream *st)
4182 static const uint8_t avci100_1080p_extradata[] = {
4184 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4185 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4186 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4187 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4188 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4189 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4190 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4191 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4192 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4194 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4197 static const uint8_t avci100_1080i_extradata[] = {
4199 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4200 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4201 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4202 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4203 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4204 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4205 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4206 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4207 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4208 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4209 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4211 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4214 static const uint8_t avci50_1080i_extradata[] = {
4216 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4217 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4218 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4219 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4220 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4221 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4222 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4223 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4224 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4225 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4226 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4228 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4231 static const uint8_t avci100_720p_extradata[] = {
4233 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4234 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4235 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4236 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4237 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4238 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4239 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4240 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4241 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4242 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4244 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4248 const uint8_t *data = NULL;
4251 if (st->codec->width == 1920) {
4252 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4253 data = avci100_1080p_extradata;
4254 size = sizeof(avci100_1080p_extradata);
4256 data = avci100_1080i_extradata;
4257 size = sizeof(avci100_1080i_extradata);
4259 } else if (st->codec->width == 1440) {
4260 data = avci50_1080i_extradata;
4261 size = sizeof(avci50_1080i_extradata);
4262 } else if (st->codec->width == 1280) {
4263 data = avci100_720p_extradata;
4264 size = sizeof(avci100_720p_extradata);
4270 av_freep(&st->codec->extradata);
4271 if (ff_alloc_extradata(st->codec, size))
4272 return AVERROR(ENOMEM);
4273 memcpy(st->codec->extradata, data, size);