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
23 #include "avio_internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/raw.h"
27 #include "libavcodec/bytestream.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/pixdesc.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/time.h"
39 #include "libavutil/timestamp.h"
41 #include "audiointerleave.h"
53 * various utility functions for use within FFmpeg
56 unsigned avformat_version(void)
58 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
59 return LIBAVFORMAT_VERSION_INT;
62 const char *avformat_configuration(void)
64 return FFMPEG_CONFIGURATION;
67 const char *avformat_license(void)
69 #define LICENSE_PREFIX "libavformat license: "
70 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
73 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
75 static int is_relative(int64_t ts) {
76 return ts > (RELATIVE_TS_BASE - (1LL<<48));
80 * Wrap a given time stamp, if there is an indication for an overflow
83 * @param timestamp the time stamp to wrap
84 * @return resulting time stamp
86 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
88 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
89 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
90 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
91 timestamp < st->pts_wrap_reference)
92 return timestamp + (1ULL<<st->pts_wrap_bits);
93 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
94 timestamp >= st->pts_wrap_reference)
95 return timestamp - (1ULL<<st->pts_wrap_bits);
100 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
101 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
102 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
105 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
107 if (st->codec->codec)
108 return st->codec->codec;
110 switch(st->codec->codec_type){
111 case AVMEDIA_TYPE_VIDEO:
112 if(s->video_codec) return s->video_codec;
114 case AVMEDIA_TYPE_AUDIO:
115 if(s->audio_codec) return s->audio_codec;
117 case AVMEDIA_TYPE_SUBTITLE:
118 if(s->subtitle_codec) return s->subtitle_codec;
122 return avcodec_find_decoder(codec_id);
125 int av_format_get_probe_score(const AVFormatContext *s)
127 return s->probe_score;
130 /* an arbitrarily chosen "sane" max packet size -- 50M */
131 #define SANE_CHUNK_SIZE (50000000)
133 int ffio_limit(AVIOContext *s, int size)
136 int64_t remaining= s->maxsize - avio_tell(s);
137 if(remaining < size){
138 int64_t newsize= avio_size(s);
139 if(!s->maxsize || s->maxsize<newsize)
140 s->maxsize= newsize - !newsize;
141 remaining= s->maxsize - avio_tell(s);
142 remaining= FFMAX(remaining, 0);
145 if(s->maxsize>=0 && remaining+1 < size){
146 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
154 * Read the data in sane-sized chunks and append to pkt.
155 * Return the number of bytes read or an error.
157 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
159 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
160 int orig_size = pkt->size;
164 int prev_size = pkt->size;
168 * When the caller requests a lot of data, limit it to the amount left
169 * in file or SANE_CHUNK_SIZE when it is not known
172 if (read_size > SANE_CHUNK_SIZE/10) {
173 read_size = ffio_limit(s, read_size);
174 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
176 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
179 ret = av_grow_packet(pkt, read_size);
183 ret = avio_read(s, pkt->data + prev_size, read_size);
184 if (ret != read_size) {
185 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
192 pkt->flags |= AV_PKT_FLAG_CORRUPT;
197 return pkt->size > orig_size ? pkt->size - orig_size : ret;
200 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
205 pkt->pos = avio_tell(s);
207 return append_packet_chunked(s, pkt, size);
210 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
213 return av_get_packet(s, pkt, size);
214 return append_packet_chunked(s, pkt, size);
218 int av_filename_number_test(const char *filename)
221 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
224 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
226 AVProbeData lpd = *pd;
227 AVInputFormat *fmt1 = NULL, *fmt;
228 int score, nodat = 0, score_max=0;
229 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
232 lpd.buf = zerobuffer;
234 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
235 int id3len = ff_id3v2_tag_len(lpd.buf);
236 if (lpd.buf_size > id3len + 16) {
238 lpd.buf_size -= id3len;
244 while ((fmt1 = av_iformat_next(fmt1))) {
245 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
248 if (fmt1->read_probe) {
249 score = fmt1->read_probe(&lpd);
250 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
251 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
252 } else if (fmt1->extensions) {
253 if (av_match_ext(lpd.filename, fmt1->extensions)) {
254 score = AVPROBE_SCORE_EXTENSION;
257 if (score > score_max) {
260 }else if (score == score_max)
264 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
265 *score_ret= score_max;
270 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
273 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
274 if(score_ret > *score_max){
275 *score_max= score_ret;
281 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
283 return av_probe_input_format2(pd, is_opened, &score);
286 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
288 static const struct {
289 const char *name; enum AVCodecID id; enum AVMediaType type;
291 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
292 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
293 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
294 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
295 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
296 { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
297 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
298 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
299 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
303 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
305 if (fmt && st->request_probe <= score) {
307 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
308 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
309 for (i = 0; fmt_id_type[i].name; i++) {
310 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
311 st->codec->codec_id = fmt_id_type[i].id;
312 st->codec->codec_type = fmt_id_type[i].type;
320 /************************************************************/
321 /* input media file */
323 int av_demuxer_open(AVFormatContext *ic){
326 if (ic->iformat->read_header) {
327 err = ic->iformat->read_header(ic);
332 if (ic->pb && !ic->data_offset)
333 ic->data_offset = avio_tell(ic->pb);
339 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
340 const char *filename, void *logctx,
341 unsigned int offset, unsigned int max_probe_size)
343 AVProbeData pd = { filename ? filename : "", NULL, -offset };
344 unsigned char *buf = NULL;
346 int ret = 0, probe_size, buf_offset = 0;
349 if (!max_probe_size) {
350 max_probe_size = PROBE_BUF_MAX;
351 } else if (max_probe_size > PROBE_BUF_MAX) {
352 max_probe_size = PROBE_BUF_MAX;
353 } else if (max_probe_size < PROBE_BUF_MIN) {
354 av_log(logctx, AV_LOG_ERROR,
355 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
356 return AVERROR(EINVAL);
359 if (offset >= max_probe_size) {
360 return AVERROR(EINVAL);
363 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
364 if (!av_strcasecmp(mime_type, "audio/aacp")) {
365 *fmt = av_find_input_format("aac");
367 av_freep(&mime_type);
370 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
371 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
373 if (probe_size < offset) {
376 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
378 /* read probe data */
379 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
381 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
382 /* fail if error was not end of file, otherwise, lower score */
383 if (ret != AVERROR_EOF) {
388 ret = 0; /* error was end of file, nothing read */
390 pd.buf_size = buf_offset += ret;
391 pd.buf = &buf[offset];
393 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
395 /* guess file format */
396 *fmt = av_probe_input_format2(&pd, 1, &score);
398 if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
399 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
401 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
407 return AVERROR_INVALIDDATA;
410 /* rewind. reuse probe buffer to avoid seeking */
411 ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
413 return ret < 0 ? ret : score;
416 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
417 const char *filename, void *logctx,
418 unsigned int offset, unsigned int max_probe_size)
420 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
421 return ret < 0 ? ret : 0;
425 /* open input file and probe the format if necessary */
426 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
429 AVProbeData pd = {filename, NULL, 0};
430 int score = AVPROBE_SCORE_RETRY;
433 s->flags |= AVFMT_FLAG_CUSTOM_IO;
435 return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
436 else if (s->iformat->flags & AVFMT_NOFILE)
437 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
438 "will be ignored with AVFMT_NOFILE format.\n");
442 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
443 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
446 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
447 &s->interrupt_callback, options)) < 0)
451 return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
454 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
455 AVPacketList **plast_pktl){
456 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
461 (*plast_pktl)->next = pktl;
463 *packet_buffer = pktl;
465 /* add the packet in the buffered packet list */
471 int avformat_queue_attached_pictures(AVFormatContext *s)
474 for (i = 0; i < s->nb_streams; i++)
475 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
476 s->streams[i]->discard < AVDISCARD_ALL) {
477 AVPacket copy = s->streams[i]->attached_pic;
478 copy.buf = av_buffer_ref(copy.buf);
480 return AVERROR(ENOMEM);
482 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
487 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
489 AVFormatContext *s = *ps;
491 AVDictionary *tmp = NULL;
492 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
494 if (!s && !(s = avformat_alloc_context()))
495 return AVERROR(ENOMEM);
497 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
498 return AVERROR(EINVAL);
504 av_dict_copy(&tmp, *options, 0);
506 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
509 if ((ret = init_input(s, filename, &tmp)) < 0)
511 s->probe_score = ret;
512 avio_skip(s->pb, s->skip_initial_bytes);
514 /* check filename in case an image number is expected */
515 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
516 if (!av_filename_number_test(filename)) {
517 ret = AVERROR(EINVAL);
522 s->duration = s->start_time = AV_NOPTS_VALUE;
523 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
525 /* allocate private data */
526 if (s->iformat->priv_data_size > 0) {
527 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
528 ret = AVERROR(ENOMEM);
531 if (s->iformat->priv_class) {
532 *(const AVClass**)s->priv_data = s->iformat->priv_class;
533 av_opt_set_defaults(s->priv_data);
534 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
539 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
541 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
543 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
544 if ((ret = s->iformat->read_header(s)) < 0)
547 if (id3v2_extra_meta) {
548 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
549 !strcmp(s->iformat->name, "tta")) {
550 if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
553 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
555 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
557 if ((ret = avformat_queue_attached_pictures(s)) < 0)
560 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
561 s->data_offset = avio_tell(s->pb);
563 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
566 av_dict_free(options);
573 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
575 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
577 avformat_free_context(s);
582 /*******************************************************/
584 static void force_codec_ids(AVFormatContext *s, AVStream *st)
586 switch(st->codec->codec_type){
587 case AVMEDIA_TYPE_VIDEO:
588 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
590 case AVMEDIA_TYPE_AUDIO:
591 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
593 case AVMEDIA_TYPE_SUBTITLE:
594 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
599 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
601 if(st->request_probe>0){
602 AVProbeData *pd = &st->probe_data;
604 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
608 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
610 av_log(s, AV_LOG_WARNING,
611 "Failed to reallocate probe buffer for stream %d\n",
616 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
617 pd->buf_size += pkt->size;
618 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
621 st->probe_packets = 0;
623 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
628 end= s->raw_packet_buffer_remaining_size <= 0
629 || st->probe_packets<=0;
631 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
632 int score= set_codec_from_probe_data(s, st, pd);
633 if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
637 st->request_probe= -1;
638 if(st->codec->codec_id != AV_CODEC_ID_NONE){
639 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
641 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
643 force_codec_ids(s, st);
649 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
655 AVPacketList *pktl = s->raw_packet_buffer;
659 st = s->streams[pkt->stream_index];
660 if (s->raw_packet_buffer_remaining_size <= 0) {
661 if ((err = probe_codec(s, st, NULL)) < 0)
664 if(st->request_probe <= 0){
665 s->raw_packet_buffer = pktl->next;
666 s->raw_packet_buffer_remaining_size += pkt->size;
675 ret= s->iformat->read_packet(s, pkt);
677 if (!pktl || ret == AVERROR(EAGAIN))
679 for (i = 0; i < s->nb_streams; i++) {
681 if (st->probe_packets) {
682 if ((err = probe_codec(s, st, NULL)) < 0)
685 av_assert0(st->request_probe <= 0);
690 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
691 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
692 av_log(s, AV_LOG_WARNING,
693 "Dropped corrupted packet (stream = %d)\n",
699 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
700 av_packet_merge_side_data(pkt);
702 if(pkt->stream_index >= (unsigned)s->nb_streams){
703 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
707 st= s->streams[pkt->stream_index];
708 pkt->dts = wrap_timestamp(st, pkt->dts);
709 pkt->pts = wrap_timestamp(st, pkt->pts);
711 force_codec_ids(s, st);
713 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
714 if (s->use_wallclock_as_timestamps)
715 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
717 if(!pktl && st->request_probe <= 0)
720 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
721 s->raw_packet_buffer_remaining_size -= pkt->size;
723 if ((err = probe_codec(s, st, pkt)) < 0)
728 #if FF_API_READ_PACKET
729 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
731 return ff_read_packet(s, pkt);
736 /**********************************************************/
738 static int determinable_frame_size(AVCodecContext *avctx)
740 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
741 avctx->codec_id == AV_CODEC_ID_MP1 ||
742 avctx->codec_id == AV_CODEC_ID_MP2 ||
743 avctx->codec_id == AV_CODEC_ID_MP3/* ||
744 avctx->codec_id == AV_CODEC_ID_CELT*/)
750 * Get the number of samples of an audio frame. Return -1 on error.
752 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
756 /* give frame_size priority if demuxing */
757 if (!mux && enc->frame_size > 1)
758 return enc->frame_size;
760 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
763 /* Fall back on using frame_size if muxing. */
764 if (enc->frame_size > 1)
765 return enc->frame_size;
767 //For WMA we currently have no other means to calculate duration thus we
768 //do it here by assuming CBR, which is true for all known cases.
769 if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
770 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
771 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
779 * Return the frame duration in seconds. Return 0 if not available.
781 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
782 AVCodecParserContext *pc, AVPacket *pkt)
788 switch(st->codec->codec_type) {
789 case AVMEDIA_TYPE_VIDEO:
790 if (st->r_frame_rate.num && !pc) {
791 *pnum = st->r_frame_rate.den;
792 *pden = st->r_frame_rate.num;
793 } else if(st->time_base.num*1000LL > st->time_base.den) {
794 *pnum = st->time_base.num;
795 *pden = st->time_base.den;
796 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
797 *pnum = st->codec->time_base.num;
798 *pden = st->codec->time_base.den;
799 if (pc && pc->repeat_pict) {
800 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
801 *pden /= 1 + pc->repeat_pict;
803 *pnum *= 1 + pc->repeat_pict;
805 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
806 //Thus if we have no parser in such case leave duration undefined.
807 if(st->codec->ticks_per_frame>1 && !pc){
812 case AVMEDIA_TYPE_AUDIO:
813 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
814 if (frame_size <= 0 || st->codec->sample_rate <= 0)
817 *pden = st->codec->sample_rate;
824 static int is_intra_only(AVCodecContext *enc){
825 const AVCodecDescriptor *desc;
827 if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
830 desc = av_codec_get_codec_descriptor(enc);
832 desc = avcodec_descriptor_get(enc->codec_id);
833 av_codec_set_codec_descriptor(enc, desc);
836 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
840 static int has_decode_delay_been_guessed(AVStream *st)
842 if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
843 if(!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
845 #if CONFIG_H264_DECODER
846 if(st->codec->has_b_frames &&
847 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
850 if(st->codec->has_b_frames<3)
851 return st->nb_decoded_frames >= 7;
852 else if(st->codec->has_b_frames<4)
853 return st->nb_decoded_frames >= 18;
855 return st->nb_decoded_frames >= 20;
858 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
862 if (pktl == s->parse_queue_end)
863 return s->packet_buffer;
867 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
869 if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
870 st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
873 // reference time stamp should be 60 s before first time stamp
874 int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
875 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
876 int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
877 (st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
878 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
880 AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
882 if (!first_program) {
883 int default_stream_index = av_find_default_stream_index(s);
884 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
885 for (i=0; i<s->nb_streams; i++) {
886 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
887 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
891 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
892 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
896 AVProgram *program = first_program;
898 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
899 pts_wrap_reference = program->pts_wrap_reference;
900 pts_wrap_behavior = program->pts_wrap_behavior;
903 program = av_find_program_from_stream(s, program, stream_index);
906 // update every program with differing pts_wrap_reference
907 program = first_program;
909 if (program->pts_wrap_reference != pts_wrap_reference) {
910 for (i=0; i<program->nb_stream_indexes; i++) {
911 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
912 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
915 program->pts_wrap_reference = pts_wrap_reference;
916 program->pts_wrap_behavior = pts_wrap_behavior;
918 program = av_find_program_from_stream(s, program, stream_index);
926 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
927 int64_t dts, int64_t pts, AVPacket *pkt)
929 AVStream *st= s->streams[stream_index];
930 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
931 int64_t pts_buffer[MAX_REORDER_DELAY+1];
935 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
938 delay = st->codec->has_b_frames;
939 st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
941 shift = st->first_dts - RELATIVE_TS_BASE;
943 for (i=0; i<MAX_REORDER_DELAY+1; i++)
944 pts_buffer[i] = AV_NOPTS_VALUE;
946 if (is_relative(pts))
949 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
950 if(pktl->pkt.stream_index != stream_index)
952 if(is_relative(pktl->pkt.pts))
953 pktl->pkt.pts += shift;
955 if(is_relative(pktl->pkt.dts))
956 pktl->pkt.dts += shift;
958 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
959 st->start_time= pktl->pkt.pts;
961 if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
962 pts_buffer[0]= pktl->pkt.pts;
963 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
964 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
965 if(pktl->pkt.dts == AV_NOPTS_VALUE)
966 pktl->pkt.dts= pts_buffer[0];
970 if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
971 // correct first time stamps to negative values
972 st->first_dts = wrap_timestamp(st, st->first_dts);
973 st->cur_dts = wrap_timestamp(st, st->cur_dts);
974 pkt->dts = wrap_timestamp(st, pkt->dts);
975 pkt->pts = wrap_timestamp(st, pkt->pts);
976 pts = wrap_timestamp(st, pts);
979 if (st->start_time == AV_NOPTS_VALUE)
980 st->start_time = pts;
983 static void update_initial_durations(AVFormatContext *s, AVStream *st,
984 int stream_index, int duration)
986 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
987 int64_t cur_dts= RELATIVE_TS_BASE;
989 if(st->first_dts != AV_NOPTS_VALUE){
990 cur_dts= st->first_dts;
991 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
992 if(pktl->pkt.stream_index == stream_index){
993 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
998 if(pktl && pktl->pkt.dts != st->first_dts) {
999 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in the queue\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
1003 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1006 pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1007 st->first_dts = cur_dts;
1008 }else if(st->cur_dts != RELATIVE_TS_BASE)
1011 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1012 if(pktl->pkt.stream_index != stream_index)
1014 if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1015 && !pktl->pkt.duration){
1016 pktl->pkt.dts= cur_dts;
1017 if(!st->codec->has_b_frames)
1018 pktl->pkt.pts= cur_dts;
1019 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1020 pktl->pkt.duration = duration;
1023 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1026 st->cur_dts= cur_dts;
1029 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1030 AVCodecParserContext *pc, AVPacket *pkt)
1032 int num, den, presentation_delayed, delay, i;
1035 if (s->flags & AVFMT_FLAG_NOFILLIN)
1038 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1039 pkt->dts= AV_NOPTS_VALUE;
1041 if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1042 //FIXME Set low_delay = 0 when has_b_frames = 1
1043 st->codec->has_b_frames = 1;
1045 /* do we have a video B-frame ? */
1046 delay= st->codec->has_b_frames;
1047 presentation_delayed = 0;
1049 /* XXX: need has_b_frame, but cannot get it if the codec is
1052 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1053 presentation_delayed = 1;
1055 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1056 st->pts_wrap_bits < 63 &&
1057 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1058 if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1059 pkt->dts -= 1LL<<st->pts_wrap_bits;
1061 pkt->pts += 1LL<<st->pts_wrap_bits;
1064 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1065 // we take the conservative approach and discard both
1066 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1067 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1068 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1069 if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1070 pkt->dts= AV_NOPTS_VALUE;
1073 if (pkt->duration == 0) {
1074 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1076 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1079 if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1080 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1082 /* correct timestamps with byte offset if demuxers only have timestamps
1083 on packet boundaries */
1084 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1085 /* this will estimate bitrate based on this frame's duration and size */
1086 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1087 if(pkt->pts != AV_NOPTS_VALUE)
1089 if(pkt->dts != AV_NOPTS_VALUE)
1093 if (pc && pc->dts_sync_point >= 0) {
1094 // we have synchronization info from the parser
1095 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1097 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1098 if (pkt->dts != AV_NOPTS_VALUE) {
1099 // got DTS from the stream, update reference timestamp
1100 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1101 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1102 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1103 // compute DTS based on reference timestamp
1104 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1105 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1107 if (pc->dts_sync_point > 0)
1108 st->reference_dts = pkt->dts; // new reference
1112 /* This may be redundant, but it should not hurt. */
1113 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1114 presentation_delayed = 1;
1116 av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1117 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1118 /* interpolate PTS and DTS if they are not present */
1119 //We skip H264 currently because delay and has_b_frames are not reliably set
1120 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1121 if (presentation_delayed) {
1122 /* DTS = decompression timestamp */
1123 /* PTS = presentation timestamp */
1124 if (pkt->dts == AV_NOPTS_VALUE)
1125 pkt->dts = st->last_IP_pts;
1126 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1127 if (pkt->dts == AV_NOPTS_VALUE)
1128 pkt->dts = st->cur_dts;
1130 /* this is tricky: the dts must be incremented by the duration
1131 of the frame we are displaying, i.e. the last I- or P-frame */
1132 if (st->last_IP_duration == 0)
1133 st->last_IP_duration = pkt->duration;
1134 if(pkt->dts != AV_NOPTS_VALUE)
1135 st->cur_dts = pkt->dts + st->last_IP_duration;
1136 st->last_IP_duration = pkt->duration;
1137 st->last_IP_pts= pkt->pts;
1138 /* cannot compute PTS if not present (we can compute it only
1139 by knowing the future */
1140 } else if (pkt->pts != AV_NOPTS_VALUE ||
1141 pkt->dts != AV_NOPTS_VALUE ||
1143 int duration = pkt->duration;
1145 /* presentation is not delayed : PTS and DTS are the same */
1146 if (pkt->pts == AV_NOPTS_VALUE)
1147 pkt->pts = pkt->dts;
1148 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1150 if (pkt->pts == AV_NOPTS_VALUE)
1151 pkt->pts = st->cur_dts;
1152 pkt->dts = pkt->pts;
1153 if (pkt->pts != AV_NOPTS_VALUE)
1154 st->cur_dts = pkt->pts + duration;
1158 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1159 st->pts_buffer[0]= pkt->pts;
1160 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1161 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1162 if(pkt->dts == AV_NOPTS_VALUE)
1163 pkt->dts= st->pts_buffer[0];
1165 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1166 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1168 if(pkt->dts > st->cur_dts)
1169 st->cur_dts = pkt->dts;
1171 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1172 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1175 if (is_intra_only(st->codec))
1176 pkt->flags |= AV_PKT_FLAG_KEY;
1178 pkt->convergence_duration = pc->convergence_duration;
1181 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1184 AVPacketList *pktl = *pkt_buf;
1185 *pkt_buf = pktl->next;
1186 av_free_packet(&pktl->pkt);
1189 *pkt_buf_end = NULL;
1193 * Parse a packet, add all split parts to parse_queue
1195 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1197 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1199 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1200 AVStream *st = s->streams[stream_index];
1201 uint8_t *data = pkt ? pkt->data : NULL;
1202 int size = pkt ? pkt->size : 0;
1203 int ret = 0, got_output = 0;
1206 av_init_packet(&flush_pkt);
1209 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1210 // preserve 0-size sync packets
1211 compute_pkt_fields(s, st, st->parser, pkt);
1214 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1217 av_init_packet(&out_pkt);
1218 len = av_parser_parse2(st->parser, st->codec,
1219 &out_pkt.data, &out_pkt.size, data, size,
1220 pkt->pts, pkt->dts, pkt->pos);
1222 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1224 /* increment read pointer */
1228 got_output = !!out_pkt.size;
1233 if (pkt->side_data) {
1234 out_pkt.side_data = pkt->side_data;
1235 out_pkt.side_data_elems = pkt->side_data_elems;
1236 pkt->side_data = NULL;
1237 pkt->side_data_elems = 0;
1240 /* set the duration */
1241 out_pkt.duration = 0;
1242 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1243 if (st->codec->sample_rate > 0) {
1244 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1245 (AVRational){ 1, st->codec->sample_rate },
1249 } else if (st->codec->time_base.num != 0 &&
1250 st->codec->time_base.den != 0) {
1251 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1252 st->codec->time_base,
1257 out_pkt.stream_index = st->index;
1258 out_pkt.pts = st->parser->pts;
1259 out_pkt.dts = st->parser->dts;
1260 out_pkt.pos = st->parser->pos;
1262 if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1263 out_pkt.pos = st->parser->frame_offset;
1265 if (st->parser->key_frame == 1 ||
1266 (st->parser->key_frame == -1 &&
1267 st->parser->pict_type == AV_PICTURE_TYPE_I))
1268 out_pkt.flags |= AV_PKT_FLAG_KEY;
1270 if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1271 out_pkt.flags |= AV_PKT_FLAG_KEY;
1273 compute_pkt_fields(s, st, st->parser, &out_pkt);
1275 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1276 out_pkt.buf = pkt->buf;
1278 #if FF_API_DESTRUCT_PACKET
1279 FF_DISABLE_DEPRECATION_WARNINGS
1280 out_pkt.destruct = pkt->destruct;
1281 pkt->destruct = NULL;
1282 FF_ENABLE_DEPRECATION_WARNINGS
1285 if ((ret = av_dup_packet(&out_pkt)) < 0)
1288 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1289 av_free_packet(&out_pkt);
1290 ret = AVERROR(ENOMEM);
1296 /* end of the stream => close and free the parser */
1297 if (pkt == &flush_pkt) {
1298 av_parser_close(st->parser);
1303 av_free_packet(pkt);
1307 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1308 AVPacketList **pkt_buffer_end,
1312 av_assert0(*pkt_buffer);
1315 *pkt_buffer = pktl->next;
1317 *pkt_buffer_end = NULL;
1322 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1324 int ret = 0, i, got_packet = 0;
1326 av_init_packet(pkt);
1328 while (!got_packet && !s->parse_queue) {
1332 /* read next packet */
1333 ret = ff_read_packet(s, &cur_pkt);
1335 if (ret == AVERROR(EAGAIN))
1337 /* flush the parsers */
1338 for(i = 0; i < s->nb_streams; i++) {
1340 if (st->parser && st->need_parsing)
1341 parse_packet(s, NULL, st->index);
1343 /* all remaining packets are now in parse_queue =>
1344 * really terminate parsing */
1348 st = s->streams[cur_pkt.stream_index];
1350 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1351 cur_pkt.dts != AV_NOPTS_VALUE &&
1352 cur_pkt.pts < cur_pkt.dts) {
1353 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1354 cur_pkt.stream_index,
1355 av_ts2str(cur_pkt.pts),
1356 av_ts2str(cur_pkt.dts),
1359 if (s->debug & FF_FDEBUG_TS)
1360 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1361 cur_pkt.stream_index,
1362 av_ts2str(cur_pkt.pts),
1363 av_ts2str(cur_pkt.dts),
1368 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1369 st->parser = av_parser_init(st->codec->codec_id);
1371 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1372 "%s, packets or times may be invalid.\n",
1373 avcodec_get_name(st->codec->codec_id));
1374 /* no parser available: just output the raw packets */
1375 st->need_parsing = AVSTREAM_PARSE_NONE;
1376 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1377 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1378 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1379 st->parser->flags |= PARSER_FLAG_ONCE;
1380 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1381 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1385 if (!st->need_parsing || !st->parser) {
1386 /* no parsing needed: we just output the packet as is */
1388 compute_pkt_fields(s, st, NULL, pkt);
1389 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1390 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1391 ff_reduce_index(s, st->index);
1392 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1395 } else if (st->discard < AVDISCARD_ALL) {
1396 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1400 av_free_packet(&cur_pkt);
1402 if (pkt->flags & AV_PKT_FLAG_KEY)
1403 st->skip_to_keyframe = 0;
1404 if (st->skip_to_keyframe) {
1405 av_free_packet(&cur_pkt);
1413 if (!got_packet && s->parse_queue)
1414 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1416 if(s->debug & FF_FDEBUG_TS)
1417 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1419 av_ts2str(pkt->pts),
1420 av_ts2str(pkt->dts),
1428 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1430 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1436 ret = s->packet_buffer ?
1437 read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1438 read_frame_internal(s, pkt);
1445 AVPacketList *pktl = s->packet_buffer;
1448 AVPacket *next_pkt = &pktl->pkt;
1450 if (next_pkt->dts != AV_NOPTS_VALUE) {
1451 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1452 // last dts seen for this stream. if any of packets following
1453 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1454 int64_t last_dts = next_pkt->dts;
1455 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1456 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1457 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1458 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1459 next_pkt->pts = pktl->pkt.dts;
1461 if (last_dts != AV_NOPTS_VALUE) {
1462 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1463 last_dts = pktl->pkt.dts;
1468 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1469 // Fixing the last reference frame had none pts issue (For MXF etc).
1470 // We only do this when
1472 // 2. we are not able to resolve a pts value for current packet.
1473 // 3. the packets for this stream at the end of the files had valid dts.
1474 next_pkt->pts = last_dts + next_pkt->duration;
1476 pktl = s->packet_buffer;
1479 /* read packet from packet buffer, if there is data */
1480 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1481 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1482 ret = read_from_packet_buffer(&s->packet_buffer,
1483 &s->packet_buffer_end, pkt);
1488 ret = read_frame_internal(s, pkt);
1490 if (pktl && ret != AVERROR(EAGAIN)) {
1497 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1498 &s->packet_buffer_end)) < 0)
1499 return AVERROR(ENOMEM);
1504 st = s->streams[pkt->stream_index];
1505 if (st->skip_samples) {
1506 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1507 AV_WL32(p, st->skip_samples);
1508 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1509 st->skip_samples = 0;
1512 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1513 ff_reduce_index(s, st->index);
1514 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1517 if (is_relative(pkt->dts))
1518 pkt->dts -= RELATIVE_TS_BASE;
1519 if (is_relative(pkt->pts))
1520 pkt->pts -= RELATIVE_TS_BASE;
1525 /* XXX: suppress the packet queue */
1526 static void flush_packet_queue(AVFormatContext *s)
1528 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1529 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1530 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1532 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1535 /*******************************************************/
1538 int av_find_default_stream_index(AVFormatContext *s)
1540 int first_audio_index = -1;
1544 if (s->nb_streams <= 0)
1546 for(i = 0; i < s->nb_streams; i++) {
1548 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1549 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1552 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1553 first_audio_index = i;
1555 return first_audio_index >= 0 ? first_audio_index : 0;
1559 * Flush the frame reader.
1561 void ff_read_frame_flush(AVFormatContext *s)
1566 flush_packet_queue(s);
1568 /* for each stream, reset read state */
1569 for(i = 0; i < s->nb_streams; i++) {
1573 av_parser_close(st->parser);
1576 st->last_IP_pts = AV_NOPTS_VALUE;
1577 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1578 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1579 st->reference_dts = AV_NOPTS_VALUE;
1581 st->probe_packets = MAX_PROBE_PACKETS;
1583 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1584 st->pts_buffer[j]= AV_NOPTS_VALUE;
1588 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1592 for(i = 0; i < s->nb_streams; i++) {
1593 AVStream *st = s->streams[i];
1595 st->cur_dts = av_rescale(timestamp,
1596 st->time_base.den * (int64_t)ref_st->time_base.num,
1597 st->time_base.num * (int64_t)ref_st->time_base.den);
1601 void ff_reduce_index(AVFormatContext *s, int stream_index)
1603 AVStream *st= s->streams[stream_index];
1604 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1606 if((unsigned)st->nb_index_entries >= max_entries){
1608 for(i=0; 2*i<st->nb_index_entries; i++)
1609 st->index_entries[i]= st->index_entries[2*i];
1610 st->nb_index_entries= i;
1614 int ff_add_index_entry(AVIndexEntry **index_entries,
1615 int *nb_index_entries,
1616 unsigned int *index_entries_allocated_size,
1617 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1619 AVIndexEntry *entries, *ie;
1622 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1625 if(timestamp == AV_NOPTS_VALUE)
1626 return AVERROR(EINVAL);
1628 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1629 timestamp -= RELATIVE_TS_BASE;
1631 entries = av_fast_realloc(*index_entries,
1632 index_entries_allocated_size,
1633 (*nb_index_entries + 1) *
1634 sizeof(AVIndexEntry));
1638 *index_entries= entries;
1640 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1643 index= (*nb_index_entries)++;
1644 ie= &entries[index];
1645 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1647 ie= &entries[index];
1648 if(ie->timestamp != timestamp){
1649 if(ie->timestamp <= timestamp)
1651 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1652 (*nb_index_entries)++;
1653 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1654 distance= ie->min_distance;
1658 ie->timestamp = timestamp;
1659 ie->min_distance= distance;
1666 int av_add_index_entry(AVStream *st,
1667 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1669 timestamp = wrap_timestamp(st, timestamp);
1670 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1671 &st->index_entries_allocated_size, pos,
1672 timestamp, size, distance, flags);
1675 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1676 int64_t wanted_timestamp, int flags)
1684 //optimize appending index entries at the end
1685 if(b && entries[b-1].timestamp < wanted_timestamp)
1690 timestamp = entries[m].timestamp;
1691 if(timestamp >= wanted_timestamp)
1693 if(timestamp <= wanted_timestamp)
1696 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1698 if(!(flags & AVSEEK_FLAG_ANY)){
1699 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1700 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1709 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1712 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1713 wanted_timestamp, flags);
1716 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1717 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1719 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1720 if (stream_index >= 0)
1721 ts = wrap_timestamp(s->streams[stream_index], ts);
1725 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1727 AVInputFormat *avif= s->iformat;
1728 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1729 int64_t ts_min, ts_max, ts;
1734 if (stream_index < 0)
1737 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1740 ts_min= AV_NOPTS_VALUE;
1741 pos_limit= -1; //gcc falsely says it may be uninitialized
1743 st= s->streams[stream_index];
1744 if(st->index_entries){
1747 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()
1748 index= FFMAX(index, 0);
1749 e= &st->index_entries[index];
1751 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1753 ts_min= e->timestamp;
1754 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1755 pos_min, av_ts2str(ts_min));
1757 av_assert1(index==0);
1760 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1761 av_assert0(index < st->nb_index_entries);
1763 e= &st->index_entries[index];
1764 av_assert1(e->timestamp >= target_ts);
1766 ts_max= e->timestamp;
1767 pos_limit= pos_max - e->min_distance;
1768 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1769 pos_max, pos_limit, av_ts2str(ts_max));
1773 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1778 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1781 ff_read_frame_flush(s);
1782 ff_update_cur_dts(s, st, ts);
1787 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1788 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1791 int64_t limit, ts_max;
1792 int64_t filesize = avio_size(s->pb);
1793 int64_t pos_max = filesize - 1;
1796 pos_max = FFMAX(0, (pos_max) - step);
1797 ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1799 }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1800 if (ts_max == AV_NOPTS_VALUE)
1804 int64_t tmp_pos = pos_max + 1;
1805 int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1806 if(tmp_ts == AV_NOPTS_VALUE)
1808 av_assert0(tmp_pos > pos_max);
1811 if(tmp_pos >= filesize)
1823 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1824 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1825 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1826 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1833 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1835 if(ts_min == AV_NOPTS_VALUE){
1836 pos_min = s->data_offset;
1837 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1838 if (ts_min == AV_NOPTS_VALUE)
1842 if(ts_min >= target_ts){
1847 if(ts_max == AV_NOPTS_VALUE){
1848 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1853 if(ts_max <= target_ts){
1858 if(ts_min > ts_max){
1860 }else if(ts_min == ts_max){
1865 while (pos_min < pos_limit) {
1866 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1867 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1868 assert(pos_limit <= pos_max);
1871 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1872 // interpolate position (better than dichotomy)
1873 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1874 + pos_min - approximate_keyframe_distance;
1875 }else if(no_change==1){
1876 // bisection, if interpolation failed to change min or max pos last time
1877 pos = (pos_min + pos_limit)>>1;
1879 /* linear search if bisection failed, can only happen if there
1880 are very few or no keyframes between min/max */
1885 else if(pos > pos_limit)
1889 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1894 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1895 pos_min, pos, pos_max,
1896 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1897 pos_limit, start_pos, no_change);
1898 if(ts == AV_NOPTS_VALUE){
1899 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1902 assert(ts != AV_NOPTS_VALUE);
1903 if (target_ts <= ts) {
1904 pos_limit = start_pos - 1;
1908 if (target_ts >= ts) {
1914 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1915 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1918 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1920 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1921 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1922 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1928 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1929 int64_t pos_min, pos_max;
1931 pos_min = s->data_offset;
1932 pos_max = avio_size(s->pb) - 1;
1934 if (pos < pos_min) pos= pos_min;
1935 else if(pos > pos_max) pos= pos_max;
1937 avio_seek(s->pb, pos, SEEK_SET);
1939 s->io_repositioned = 1;
1944 static int seek_frame_generic(AVFormatContext *s,
1945 int stream_index, int64_t timestamp, int flags)
1952 st = s->streams[stream_index];
1954 index = av_index_search_timestamp(st, timestamp, flags);
1956 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1959 if(index < 0 || index==st->nb_index_entries-1){
1963 if(st->nb_index_entries){
1964 av_assert0(st->index_entries);
1965 ie= &st->index_entries[st->nb_index_entries-1];
1966 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1968 ff_update_cur_dts(s, st, ie->timestamp);
1970 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1976 read_status = av_read_frame(s, &pkt);
1977 } while (read_status == AVERROR(EAGAIN));
1978 if (read_status < 0)
1980 av_free_packet(&pkt);
1981 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1982 if(pkt.flags & AV_PKT_FLAG_KEY)
1984 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1985 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);
1990 index = av_index_search_timestamp(st, timestamp, flags);
1995 ff_read_frame_flush(s);
1996 if (s->iformat->read_seek){
1997 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2000 ie = &st->index_entries[index];
2001 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2003 ff_update_cur_dts(s, st, ie->timestamp);
2008 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2009 int64_t timestamp, int flags)
2014 if (flags & AVSEEK_FLAG_BYTE) {
2015 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2017 ff_read_frame_flush(s);
2018 return seek_frame_byte(s, stream_index, timestamp, flags);
2021 if(stream_index < 0){
2022 stream_index= av_find_default_stream_index(s);
2023 if(stream_index < 0)
2026 st= s->streams[stream_index];
2027 /* timestamp for default must be expressed in AV_TIME_BASE units */
2028 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2031 /* first, we try the format specific seek */
2032 if (s->iformat->read_seek) {
2033 ff_read_frame_flush(s);
2034 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2041 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2042 ff_read_frame_flush(s);
2043 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2044 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2045 ff_read_frame_flush(s);
2046 return seek_frame_generic(s, stream_index, timestamp, flags);
2052 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2056 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2057 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2058 if ((flags & AVSEEK_FLAG_BACKWARD))
2062 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2063 flags & ~AVSEEK_FLAG_BACKWARD);
2066 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2069 ret = avformat_queue_attached_pictures(s);
2074 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2076 if(min_ts > ts || max_ts < ts)
2078 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2079 return AVERROR(EINVAL);
2082 flags |= AVSEEK_FLAG_ANY;
2083 flags &= ~AVSEEK_FLAG_BACKWARD;
2085 if (s->iformat->read_seek2) {
2087 ff_read_frame_flush(s);
2089 if (stream_index == -1 && s->nb_streams == 1) {
2090 AVRational time_base = s->streams[0]->time_base;
2091 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2092 min_ts = av_rescale_rnd(min_ts, time_base.den,
2093 time_base.num * (int64_t)AV_TIME_BASE,
2094 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2095 max_ts = av_rescale_rnd(max_ts, time_base.den,
2096 time_base.num * (int64_t)AV_TIME_BASE,
2097 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2100 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2103 ret = avformat_queue_attached_pictures(s);
2107 if(s->iformat->read_timestamp){
2108 //try to seek via read_timestamp()
2111 // Fall back on old API if new is not implemented but old is.
2112 // Note the old API has somewhat different semantics.
2113 if (s->iformat->read_seek || 1) {
2114 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2115 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2116 if (ret<0 && ts != min_ts && max_ts != ts) {
2117 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2119 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2124 // try some generic seek like seek_frame_generic() but with new ts semantics
2125 return -1; //unreachable
2128 /*******************************************************/
2131 * Return TRUE if the stream has accurate duration in any stream.
2133 * @return TRUE if the stream has accurate duration for at least one component.
2135 static int has_duration(AVFormatContext *ic)
2140 for(i = 0;i < ic->nb_streams; i++) {
2141 st = ic->streams[i];
2142 if (st->duration != AV_NOPTS_VALUE)
2145 if (ic->duration != AV_NOPTS_VALUE)
2151 * Estimate the stream timings from the one of each components.
2153 * Also computes the global bitrate if possible.
2155 static void update_stream_timings(AVFormatContext *ic)
2157 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2158 int64_t duration, duration1, filesize;
2163 start_time = INT64_MAX;
2164 start_time_text = INT64_MAX;
2165 end_time = INT64_MIN;
2166 duration = INT64_MIN;
2167 for(i = 0;i < ic->nb_streams; i++) {
2168 st = ic->streams[i];
2169 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2170 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2171 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2172 if (start_time1 < start_time_text)
2173 start_time_text = start_time1;
2175 start_time = FFMIN(start_time, start_time1);
2176 end_time1 = AV_NOPTS_VALUE;
2177 if (st->duration != AV_NOPTS_VALUE) {
2178 end_time1 = start_time1
2179 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2180 end_time = FFMAX(end_time, end_time1);
2182 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2183 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2184 p->start_time = start_time1;
2185 if(p->end_time < end_time1)
2186 p->end_time = end_time1;
2189 if (st->duration != AV_NOPTS_VALUE) {
2190 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2191 duration = FFMAX(duration, duration1);
2194 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2195 start_time = start_time_text;
2196 else if(start_time > start_time_text)
2197 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2199 if (start_time != INT64_MAX) {
2200 ic->start_time = start_time;
2201 if (end_time != INT64_MIN) {
2202 if (ic->nb_programs) {
2203 for (i=0; i<ic->nb_programs; i++) {
2204 p = ic->programs[i];
2205 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2206 duration = FFMAX(duration, p->end_time - p->start_time);
2209 duration = FFMAX(duration, end_time - start_time);
2212 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2213 ic->duration = duration;
2215 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2216 /* compute the bitrate */
2217 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2218 (double)ic->duration;
2219 if (bitrate >= 0 && bitrate <= INT_MAX)
2220 ic->bit_rate = bitrate;
2224 static void fill_all_stream_timings(AVFormatContext *ic)
2229 update_stream_timings(ic);
2230 for(i = 0;i < ic->nb_streams; i++) {
2231 st = ic->streams[i];
2232 if (st->start_time == AV_NOPTS_VALUE) {
2233 if(ic->start_time != AV_NOPTS_VALUE)
2234 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2235 if(ic->duration != AV_NOPTS_VALUE)
2236 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2241 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2243 int64_t filesize, duration;
2244 int i, show_warning = 0;
2247 /* if bit_rate is already set, we believe it */
2248 if (ic->bit_rate <= 0) {
2250 for(i=0;i<ic->nb_streams;i++) {
2251 st = ic->streams[i];
2252 if (st->codec->bit_rate > 0) {
2253 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2257 bit_rate += st->codec->bit_rate;
2260 ic->bit_rate = bit_rate;
2263 /* if duration is already set, we believe it */
2264 if (ic->duration == AV_NOPTS_VALUE &&
2265 ic->bit_rate != 0) {
2266 filesize = ic->pb ? avio_size(ic->pb) : 0;
2268 for(i = 0; i < ic->nb_streams; i++) {
2269 st = ic->streams[i];
2270 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2271 && st->duration == AV_NOPTS_VALUE) {
2272 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2273 st->duration = duration;
2280 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2283 #define DURATION_MAX_READ_SIZE 250000LL
2284 #define DURATION_MAX_RETRY 4
2286 /* only usable for MPEG-PS streams */
2287 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2289 AVPacket pkt1, *pkt = &pkt1;
2291 int read_size, i, ret;
2293 int64_t filesize, offset, duration;
2296 /* flush packet queue */
2297 flush_packet_queue(ic);
2299 for (i=0; i<ic->nb_streams; i++) {
2300 st = ic->streams[i];
2301 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2302 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2305 av_parser_close(st->parser);
2310 /* estimate the end time (duration) */
2311 /* XXX: may need to support wrapping */
2312 filesize = ic->pb ? avio_size(ic->pb) : 0;
2313 end_time = AV_NOPTS_VALUE;
2315 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2319 avio_seek(ic->pb, offset, SEEK_SET);
2322 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2326 ret = ff_read_packet(ic, pkt);
2327 } while(ret == AVERROR(EAGAIN));
2330 read_size += pkt->size;
2331 st = ic->streams[pkt->stream_index];
2332 if (pkt->pts != AV_NOPTS_VALUE &&
2333 (st->start_time != AV_NOPTS_VALUE ||
2334 st->first_dts != AV_NOPTS_VALUE)) {
2335 duration = end_time = pkt->pts;
2336 if (st->start_time != AV_NOPTS_VALUE)
2337 duration -= st->start_time;
2339 duration -= st->first_dts;
2341 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2342 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2343 st->duration = duration;
2344 st->info->last_duration = duration;
2347 av_free_packet(pkt);
2349 }while( end_time==AV_NOPTS_VALUE
2350 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2351 && ++retry <= DURATION_MAX_RETRY);
2353 fill_all_stream_timings(ic);
2355 avio_seek(ic->pb, old_offset, SEEK_SET);
2356 for (i=0; i<ic->nb_streams; i++) {
2358 st->cur_dts= st->first_dts;
2359 st->last_IP_pts = AV_NOPTS_VALUE;
2360 st->reference_dts = AV_NOPTS_VALUE;
2364 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2368 /* get the file size, if possible */
2369 if (ic->iformat->flags & AVFMT_NOFILE) {
2372 file_size = avio_size(ic->pb);
2373 file_size = FFMAX(0, file_size);
2376 if ((!strcmp(ic->iformat->name, "mpeg") ||
2377 !strcmp(ic->iformat->name, "mpegts")) &&
2378 file_size && ic->pb->seekable) {
2379 /* get accurate estimate from the PTSes */
2380 estimate_timings_from_pts(ic, old_offset);
2381 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2382 } else if (has_duration(ic)) {
2383 /* at least one component has timings - we use them for all
2385 fill_all_stream_timings(ic);
2386 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2388 /* less precise: use bitrate info */
2389 estimate_timings_from_bit_rate(ic);
2390 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2392 update_stream_timings(ic);
2396 AVStream av_unused *st;
2397 for(i = 0;i < ic->nb_streams; i++) {
2398 st = ic->streams[i];
2399 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2400 (double) st->start_time / AV_TIME_BASE,
2401 (double) st->duration / AV_TIME_BASE);
2403 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2404 (double) ic->start_time / AV_TIME_BASE,
2405 (double) ic->duration / AV_TIME_BASE,
2406 ic->bit_rate / 1000);
2410 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2412 AVCodecContext *avctx = st->codec;
2414 #define FAIL(errmsg) do { \
2416 *errmsg_ptr = errmsg; \
2420 switch (avctx->codec_type) {
2421 case AVMEDIA_TYPE_AUDIO:
2422 if (!avctx->frame_size && determinable_frame_size(avctx))
2423 FAIL("unspecified frame size");
2424 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2425 FAIL("unspecified sample format");
2426 if (!avctx->sample_rate)
2427 FAIL("unspecified sample rate");
2428 if (!avctx->channels)
2429 FAIL("unspecified number of channels");
2430 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2431 FAIL("no decodable DTS frames");
2433 case AVMEDIA_TYPE_VIDEO:
2435 FAIL("unspecified size");
2436 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2437 FAIL("unspecified pixel format");
2438 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2439 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2440 FAIL("no frame in rv30/40 and no sar");
2442 case AVMEDIA_TYPE_SUBTITLE:
2443 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2444 FAIL("unspecified size");
2446 case AVMEDIA_TYPE_DATA:
2447 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2450 if (avctx->codec_id == AV_CODEC_ID_NONE)
2451 FAIL("unknown codec");
2455 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2456 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2458 const AVCodec *codec;
2459 int got_picture = 1, ret = 0;
2460 AVFrame *frame = avcodec_alloc_frame();
2461 AVSubtitle subtitle;
2462 AVPacket pkt = *avpkt;
2465 return AVERROR(ENOMEM);
2467 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2468 AVDictionary *thread_opt = NULL;
2470 codec = find_decoder(s, st, st->codec->codec_id);
2473 st->info->found_decoder = -1;
2478 /* force thread count to 1 since the h264 decoder will not extract SPS
2479 * and PPS to extradata during multi-threaded decoding */
2480 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2481 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2483 av_dict_free(&thread_opt);
2485 st->info->found_decoder = -1;
2488 st->info->found_decoder = 1;
2489 } else if (!st->info->found_decoder)
2490 st->info->found_decoder = 1;
2492 if (st->info->found_decoder < 0) {
2497 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2499 (!has_codec_parameters(st, NULL) ||
2500 !has_decode_delay_been_guessed(st) ||
2501 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2503 avcodec_get_frame_defaults(frame);
2504 switch(st->codec->codec_type) {
2505 case AVMEDIA_TYPE_VIDEO:
2506 ret = avcodec_decode_video2(st->codec, frame,
2507 &got_picture, &pkt);
2509 case AVMEDIA_TYPE_AUDIO:
2510 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2512 case AVMEDIA_TYPE_SUBTITLE:
2513 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2514 &got_picture, &pkt);
2522 st->nb_decoded_frames++;
2529 if(!pkt.data && !got_picture)
2533 avcodec_free_frame(&frame);
2537 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2539 while (tags->id != AV_CODEC_ID_NONE) {
2547 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2550 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2551 if(tag == tags[i].tag)
2554 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2555 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2558 return AV_CODEC_ID_NONE;
2561 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2565 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2566 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2567 default: return AV_CODEC_ID_NONE;
2572 if (sflags & (1 << (bps - 1))) {
2574 case 1: return AV_CODEC_ID_PCM_S8;
2575 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2576 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2577 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2578 default: return AV_CODEC_ID_NONE;
2582 case 1: return AV_CODEC_ID_PCM_U8;
2583 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2584 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2585 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2586 default: return AV_CODEC_ID_NONE;
2592 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2595 if (!av_codec_get_tag2(tags, id, &tag))
2600 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2604 for(i=0; tags && tags[i]; i++){
2605 const AVCodecTag *codec_tags = tags[i];
2606 while (codec_tags->id != AV_CODEC_ID_NONE) {
2607 if (codec_tags->id == id) {
2608 *tag = codec_tags->tag;
2617 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2620 for(i=0; tags && tags[i]; i++){
2621 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2622 if(id!=AV_CODEC_ID_NONE) return id;
2624 return AV_CODEC_ID_NONE;
2627 static void compute_chapters_end(AVFormatContext *s)
2630 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2632 for (i = 0; i < s->nb_chapters; i++)
2633 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2634 AVChapter *ch = s->chapters[i];
2635 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2638 for (j = 0; j < s->nb_chapters; j++) {
2639 AVChapter *ch1 = s->chapters[j];
2640 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2641 if (j != i && next_start > ch->start && next_start < end)
2644 ch->end = (end == INT64_MAX) ? ch->start : end;
2648 static int get_std_framerate(int i){
2649 if(i<60*12) return (i+1)*1001;
2650 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2654 * Is the time base unreliable.
2655 * This is a heuristic to balance between quick acceptance of the values in
2656 * the headers vs. some extra checks.
2657 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2658 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2659 * And there are "variable" fps files this needs to detect as well.
2661 static int tb_unreliable(AVCodecContext *c){
2662 if( c->time_base.den >= 101L*c->time_base.num
2663 || c->time_base.den < 5L*c->time_base.num
2664 /* || c->codec_tag == AV_RL32("DIVX")
2665 || c->codec_tag == AV_RL32("XVID")*/
2666 || c->codec_tag == AV_RL32("mp4v")
2667 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2668 || c->codec_id == AV_CODEC_ID_H264
2674 #if FF_API_FORMAT_PARAMETERS
2675 int av_find_stream_info(AVFormatContext *ic)
2677 return avformat_find_stream_info(ic, NULL);
2681 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2685 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2686 avctx->extradata_size = 0;
2687 return AVERROR(EINVAL);
2689 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2690 if (avctx->extradata) {
2691 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2692 avctx->extradata_size = size;
2695 avctx->extradata_size = 0;
2696 ret = AVERROR(ENOMEM);
2701 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2703 int i, count, ret = 0, j;
2706 AVPacket pkt1, *pkt;
2707 int64_t old_offset = avio_tell(ic->pb);
2708 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2709 int flush_codecs = ic->probesize > 0;
2712 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2714 for(i=0;i<ic->nb_streams;i++) {
2715 const AVCodec *codec;
2716 AVDictionary *thread_opt = NULL;
2717 st = ic->streams[i];
2719 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2720 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2721 /* if(!st->time_base.num)
2723 if(!st->codec->time_base.num)
2724 st->codec->time_base= st->time_base;
2726 //only for the split stuff
2727 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2728 st->parser = av_parser_init(st->codec->codec_id);
2730 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2731 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2732 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2733 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2735 } else if (st->need_parsing) {
2736 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2737 "%s, packets or times may be invalid.\n",
2738 avcodec_get_name(st->codec->codec_id));
2741 codec = find_decoder(ic, st, st->codec->codec_id);
2743 /* force thread count to 1 since the h264 decoder will not extract SPS
2744 * and PPS to extradata during multi-threaded decoding */
2745 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2747 /* Ensure that subtitle_header is properly set. */
2748 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2749 && codec && !st->codec->codec)
2750 avcodec_open2(st->codec, codec, options ? &options[i]
2753 //try to just open decoders, in case this is enough to get parameters
2754 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2755 if (codec && !st->codec->codec)
2756 avcodec_open2(st->codec, codec, options ? &options[i]
2760 av_dict_free(&thread_opt);
2763 for (i=0; i<ic->nb_streams; i++) {
2764 #if FF_API_R_FRAME_RATE
2765 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2767 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2768 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2774 if (ff_check_interrupt(&ic->interrupt_callback)){
2776 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2780 /* check if one codec still needs to be handled */
2781 for(i=0;i<ic->nb_streams;i++) {
2782 int fps_analyze_framecount = 20;
2784 st = ic->streams[i];
2785 if (!has_codec_parameters(st, NULL))
2787 /* if the timebase is coarse (like the usual millisecond precision
2788 of mkv), we need to analyze more frames to reliably arrive at
2790 if (av_q2d(st->time_base) > 0.0005)
2791 fps_analyze_framecount *= 2;
2792 if (ic->fps_probe_size >= 0)
2793 fps_analyze_framecount = ic->fps_probe_size;
2794 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2795 fps_analyze_framecount = 0;
2796 /* variable fps and no guess at the real fps */
2797 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2798 && st->info->duration_count < fps_analyze_framecount
2799 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2801 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2803 if (st->first_dts == AV_NOPTS_VALUE &&
2804 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2805 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2808 if (i == ic->nb_streams) {
2809 /* NOTE: if the format has no header, then we need to read
2810 some packets to get most of the streams, so we cannot
2812 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2813 /* if we found the info for all the codecs, we can stop */
2815 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2820 /* we did not get all the codec info, but we read too much data */
2821 if (read_size >= ic->probesize) {
2823 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2824 for (i = 0; i < ic->nb_streams; i++)
2825 if (!ic->streams[i]->r_frame_rate.num &&
2826 ic->streams[i]->info->duration_count <= 1 &&
2827 strcmp(ic->iformat->name, "image2"))
2828 av_log(ic, AV_LOG_WARNING,
2829 "Stream #%d: not enough frames to estimate rate; "
2830 "consider increasing probesize\n", i);
2834 /* NOTE: a new stream can be added there if no header in file
2835 (AVFMTCTX_NOHEADER) */
2836 ret = read_frame_internal(ic, &pkt1);
2837 if (ret == AVERROR(EAGAIN))
2845 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2846 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2848 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2849 &ic->packet_buffer_end);
2851 ret = AVERROR(ENOMEM);
2852 goto find_stream_info_err;
2854 if ((ret = av_dup_packet(pkt)) < 0)
2855 goto find_stream_info_err;
2858 read_size += pkt->size;
2860 st = ic->streams[pkt->stream_index];
2861 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2862 /* check for non-increasing dts */
2863 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2864 st->info->fps_last_dts >= pkt->dts) {
2865 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2866 "packet %d with DTS %"PRId64", packet %d with DTS "
2867 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2868 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2869 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2871 /* check for a discontinuity in dts - if the difference in dts
2872 * is more than 1000 times the average packet duration in the sequence,
2873 * we treat it as a discontinuity */
2874 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2875 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2876 (pkt->dts - st->info->fps_last_dts) / 1000 >
2877 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2878 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2879 "packet %d with DTS %"PRId64", packet %d with DTS "
2880 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2881 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2882 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2885 /* update stored dts values */
2886 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2887 st->info->fps_first_dts = pkt->dts;
2888 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2890 st->info->fps_last_dts = pkt->dts;
2891 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2893 if (st->codec_info_nb_frames>1) {
2895 if (st->time_base.den > 0)
2896 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2897 if (st->avg_frame_rate.num > 0)
2898 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2901 && st->codec_info_nb_frames>30
2902 && st->info->fps_first_dts != AV_NOPTS_VALUE
2903 && st->info->fps_last_dts != AV_NOPTS_VALUE)
2904 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
2906 if (t >= ic->max_analyze_duration) {
2907 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2910 if (pkt->duration) {
2911 st->info->codec_info_duration += pkt->duration;
2912 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2915 #if FF_API_R_FRAME_RATE
2917 int64_t last = st->info->last_dts;
2919 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2920 && pkt->dts - (uint64_t)last < INT64_MAX){
2921 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2922 int64_t duration= pkt->dts - last;
2924 if (!st->info->duration_error)
2925 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2926 if (!st->info->duration_error)
2927 return AVERROR(ENOMEM);
2929 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2930 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2931 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2932 int framerate= get_std_framerate(i);
2933 double sdts= dts*framerate/(1001*12);
2935 int64_t ticks= llrint(sdts+j*0.5);
2936 double error= sdts - ticks + j*0.5;
2937 st->info->duration_error[j][0][i] += error;
2938 st->info->duration_error[j][1][i] += error*error;
2941 st->info->duration_count++;
2942 // ignore the first 4 values, they might have some random jitter
2943 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2944 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2946 if (pkt->dts != AV_NOPTS_VALUE)
2947 st->info->last_dts = pkt->dts;
2950 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2951 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2952 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2953 if (ff_alloc_extradata(st->codec, i))
2954 return AVERROR(ENOMEM);
2955 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2959 /* if still no information, we try to open the codec and to
2960 decompress the frame. We try to avoid that in most cases as
2961 it takes longer and uses more memory. For MPEG-4, we need to
2962 decompress for QuickTime.
2964 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2965 least one frame of codec data, this makes sure the codec initializes
2966 the channel configuration and does not only trust the values from the container.
2968 try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2970 st->codec_info_nb_frames++;
2975 AVPacket empty_pkt = { 0 };
2977 av_init_packet(&empty_pkt);
2979 for(i=0;i<ic->nb_streams;i++) {
2981 st = ic->streams[i];
2983 /* flush the decoders */
2984 if (st->info->found_decoder == 1) {
2986 err = try_decode_frame(ic, st, &empty_pkt,
2987 (options && i < orig_nb_streams) ?
2988 &options[i] : NULL);
2989 } while (err > 0 && !has_codec_parameters(st, NULL));
2992 av_log(ic, AV_LOG_INFO,
2993 "decoding for stream %d failed\n", st->index);
2999 // close codecs which were opened in try_decode_frame()
3000 for(i=0;i<ic->nb_streams;i++) {
3001 st = ic->streams[i];
3002 avcodec_close(st->codec);
3004 for(i=0;i<ic->nb_streams;i++) {
3005 st = ic->streams[i];
3006 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3007 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3008 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3009 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3010 st->codec->codec_tag= tag;
3013 /* estimate average framerate if not set by demuxer */
3014 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3016 double best_error = 0.01;
3018 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3019 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3020 st->info->codec_info_duration < 0)
3022 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3023 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3024 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3026 /* round guessed framerate to a "standard" framerate if it's
3027 * within 1% of the original estimate*/
3028 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3029 AVRational std_fps = { get_std_framerate(j), 12*1001 };
3030 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3032 if (error < best_error) {
3034 best_fps = std_fps.num;
3038 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3039 best_fps, 12*1001, INT_MAX);
3042 // the check for tb_unreliable() is not completely correct, since this is not about handling
3043 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3044 // ipmovie.c produces.
3045 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)
3046 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);
3047 if (st->info->duration_count>1 && !st->r_frame_rate.num
3048 && tb_unreliable(st->codec)) {
3050 double best_error= 0.01;
3052 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3055 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3057 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3060 int n= st->info->duration_count;
3061 double a= st->info->duration_error[k][0][j] / n;
3062 double error= st->info->duration_error[k][1][j]/n - a*a;
3064 if(error < best_error && best_error> 0.000000001){
3066 num = get_std_framerate(j);
3069 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3072 // do not increase frame rate by more than 1 % in order to match a standard rate.
3073 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3074 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3077 if (!st->r_frame_rate.num){
3078 if( st->codec->time_base.den * (int64_t)st->time_base.num
3079 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3080 st->r_frame_rate.num = st->codec->time_base.den;
3081 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3083 st->r_frame_rate.num = st->time_base.den;
3084 st->r_frame_rate.den = st->time_base.num;
3087 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3088 if(!st->codec->bits_per_coded_sample)
3089 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3090 // set stream disposition based on audio service type
3091 switch (st->codec->audio_service_type) {
3092 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3093 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3094 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3095 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3096 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3097 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3098 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3099 st->disposition = AV_DISPOSITION_COMMENT; break;
3100 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3101 st->disposition = AV_DISPOSITION_KARAOKE; break;
3107 estimate_timings(ic, old_offset);
3109 if (ret >= 0 && ic->nb_streams)
3110 ret = -1; /* we could not have all the codec parameters before EOF */
3111 for(i=0;i<ic->nb_streams;i++) {
3113 st = ic->streams[i];
3114 if (!has_codec_parameters(st, &errmsg)) {
3116 avcodec_string(buf, sizeof(buf), st->codec, 0);
3117 av_log(ic, AV_LOG_WARNING,
3118 "Could not find codec parameters for stream %d (%s): %s\n"
3119 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3126 compute_chapters_end(ic);
3128 find_stream_info_err:
3129 for (i=0; i < ic->nb_streams; i++) {
3130 st = ic->streams[i];
3131 if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3132 ic->streams[i]->codec->thread_count = 0;
3134 av_freep(&st->info->duration_error);
3135 av_freep(&ic->streams[i]->info);
3138 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3142 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3146 for (i = 0; i < ic->nb_programs; i++) {
3147 if (ic->programs[i] == last) {
3151 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3152 if (ic->programs[i]->stream_index[j] == s)
3153 return ic->programs[i];
3159 int av_find_best_stream(AVFormatContext *ic,
3160 enum AVMediaType type,
3161 int wanted_stream_nb,
3163 AVCodec **decoder_ret,
3166 int i, nb_streams = ic->nb_streams;
3167 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3168 unsigned *program = NULL;
3169 AVCodec *decoder = NULL, *best_decoder = NULL;
3171 if (related_stream >= 0 && wanted_stream_nb < 0) {
3172 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3174 program = p->stream_index;
3175 nb_streams = p->nb_stream_indexes;
3178 for (i = 0; i < nb_streams; i++) {
3179 int real_stream_index = program ? program[i] : i;
3180 AVStream *st = ic->streams[real_stream_index];
3181 AVCodecContext *avctx = st->codec;
3182 if (avctx->codec_type != type)
3184 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3186 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3189 decoder = find_decoder(ic, st, st->codec->codec_id);
3192 ret = AVERROR_DECODER_NOT_FOUND;
3196 count = st->codec_info_nb_frames;
3197 bitrate = avctx->bit_rate;
3198 multiframe = FFMIN(5, count);
3199 if ((best_multiframe > multiframe) ||
3200 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3201 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3204 best_bitrate = bitrate;
3205 best_multiframe = multiframe;
3206 ret = real_stream_index;
3207 best_decoder = decoder;
3208 if (program && i == nb_streams - 1 && ret < 0) {
3210 nb_streams = ic->nb_streams;
3211 i = 0; /* no related stream found, try again with everything */
3215 *decoder_ret = best_decoder;
3219 /*******************************************************/
3221 int av_read_play(AVFormatContext *s)
3223 if (s->iformat->read_play)
3224 return s->iformat->read_play(s);
3226 return avio_pause(s->pb, 0);
3227 return AVERROR(ENOSYS);
3230 int av_read_pause(AVFormatContext *s)
3232 if (s->iformat->read_pause)
3233 return s->iformat->read_pause(s);
3235 return avio_pause(s->pb, 1);
3236 return AVERROR(ENOSYS);
3239 void ff_free_stream(AVFormatContext *s, AVStream *st){
3240 av_assert0(s->nb_streams>0);
3241 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3244 av_parser_close(st->parser);
3246 if (st->attached_pic.data)
3247 av_free_packet(&st->attached_pic);
3248 av_dict_free(&st->metadata);
3249 av_freep(&st->probe_data.buf);
3250 av_freep(&st->index_entries);
3251 av_freep(&st->codec->extradata);
3252 av_freep(&st->codec->subtitle_header);
3253 av_freep(&st->codec);
3254 av_freep(&st->priv_data);
3256 av_freep(&st->info->duration_error);
3257 av_freep(&st->info);
3258 av_freep(&s->streams[ --s->nb_streams ]);
3261 void avformat_free_context(AVFormatContext *s)
3269 if (s->iformat && s->iformat->priv_class && s->priv_data)
3270 av_opt_free(s->priv_data);
3272 for(i=s->nb_streams-1; i>=0; i--) {
3273 ff_free_stream(s, s->streams[i]);
3275 for(i=s->nb_programs-1; i>=0; i--) {
3276 av_dict_free(&s->programs[i]->metadata);
3277 av_freep(&s->programs[i]->stream_index);
3278 av_freep(&s->programs[i]);
3280 av_freep(&s->programs);
3281 av_freep(&s->priv_data);
3282 while(s->nb_chapters--) {
3283 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3284 av_freep(&s->chapters[s->nb_chapters]);
3286 av_freep(&s->chapters);
3287 av_dict_free(&s->metadata);
3288 av_freep(&s->streams);
3292 #if FF_API_CLOSE_INPUT_FILE
3293 void av_close_input_file(AVFormatContext *s)
3295 avformat_close_input(&s);
3299 void avformat_close_input(AVFormatContext **ps)
3310 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3311 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3314 flush_packet_queue(s);
3317 if (s->iformat->read_close)
3318 s->iformat->read_close(s);
3321 avformat_free_context(s);
3328 #if FF_API_NEW_STREAM
3329 AVStream *av_new_stream(AVFormatContext *s, int id)
3331 AVStream *st = avformat_new_stream(s, NULL);
3338 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3344 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3346 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3349 s->streams = streams;
3351 st = av_mallocz(sizeof(AVStream));
3354 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3358 st->info->last_dts = AV_NOPTS_VALUE;
3360 st->codec = avcodec_alloc_context3(c);
3362 /* no default bitrate if decoding */
3363 st->codec->bit_rate = 0;
3365 st->index = s->nb_streams;
3366 st->start_time = AV_NOPTS_VALUE;
3367 st->duration = AV_NOPTS_VALUE;
3368 /* we set the current DTS to 0 so that formats without any timestamps
3369 but durations get some timestamps, formats with some unknown
3370 timestamps have their first few packets buffered and the
3371 timestamps corrected before they are returned to the user */
3372 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3373 st->first_dts = AV_NOPTS_VALUE;
3374 st->probe_packets = MAX_PROBE_PACKETS;
3375 st->pts_wrap_reference = AV_NOPTS_VALUE;
3376 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3378 /* default pts setting is MPEG-like */
3379 avpriv_set_pts_info(st, 33, 1, 90000);
3380 st->last_IP_pts = AV_NOPTS_VALUE;
3381 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3382 st->pts_buffer[i]= AV_NOPTS_VALUE;
3383 st->reference_dts = AV_NOPTS_VALUE;
3385 st->sample_aspect_ratio = (AVRational){0,1};
3387 #if FF_API_R_FRAME_RATE
3388 st->info->last_dts = AV_NOPTS_VALUE;
3390 st->info->fps_first_dts = AV_NOPTS_VALUE;
3391 st->info->fps_last_dts = AV_NOPTS_VALUE;
3393 s->streams[s->nb_streams++] = st;
3397 AVProgram *av_new_program(AVFormatContext *ac, int id)
3399 AVProgram *program=NULL;
3402 av_dlog(ac, "new_program: id=0x%04x\n", id);
3404 for(i=0; i<ac->nb_programs; i++)
3405 if(ac->programs[i]->id == id)
3406 program = ac->programs[i];
3409 program = av_mallocz(sizeof(AVProgram));
3412 dynarray_add(&ac->programs, &ac->nb_programs, program);
3413 program->discard = AVDISCARD_NONE;
3416 program->pts_wrap_reference = AV_NOPTS_VALUE;
3417 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3419 program->start_time =
3420 program->end_time = AV_NOPTS_VALUE;
3425 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3427 AVChapter *chapter = NULL;
3430 for(i=0; i<s->nb_chapters; i++)
3431 if(s->chapters[i]->id == id)
3432 chapter = s->chapters[i];
3435 chapter= av_mallocz(sizeof(AVChapter));
3438 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3440 av_dict_set(&chapter->metadata, "title", title, 0);
3442 chapter->time_base= time_base;
3443 chapter->start = start;
3449 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3452 AVProgram *program=NULL;
3455 if (idx >= ac->nb_streams) {
3456 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3460 for(i=0; i<ac->nb_programs; i++){
3461 if(ac->programs[i]->id != progid)
3463 program = ac->programs[i];
3464 for(j=0; j<program->nb_stream_indexes; j++)
3465 if(program->stream_index[j] == idx)
3468 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3471 program->stream_index = tmp;
3472 program->stream_index[program->nb_stream_indexes++] = idx;
3477 static void print_fps(double d, const char *postfix){
3478 uint64_t v= lrintf(d*100);
3479 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3480 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3481 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3484 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3486 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3487 AVDictionaryEntry *tag=NULL;
3489 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3490 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3491 if(strcmp("language", tag->key)){
3492 const char *p = tag->value;
3493 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3496 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3497 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3498 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3500 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3501 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3504 av_log(ctx, AV_LOG_INFO, "\n");
3510 /* "user interface" functions */
3511 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3514 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3515 AVStream *st = ic->streams[i];
3516 int g = av_gcd(st->time_base.num, st->time_base.den);
3517 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3518 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3519 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3520 /* the pid is an important information, so we display it */
3521 /* XXX: add a generic system */
3522 if (flags & AVFMT_SHOW_IDS)
3523 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3525 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3526 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3527 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3528 if (st->sample_aspect_ratio.num && // default
3529 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3530 AVRational display_aspect_ratio;
3531 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3532 st->codec->width*st->sample_aspect_ratio.num,
3533 st->codec->height*st->sample_aspect_ratio.den,
3535 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3536 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3537 display_aspect_ratio.num, display_aspect_ratio.den);
3539 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3540 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3541 print_fps(av_q2d(st->avg_frame_rate), "fps");
3542 #if FF_API_R_FRAME_RATE
3543 if(st->r_frame_rate.den && st->r_frame_rate.num)
3544 print_fps(av_q2d(st->r_frame_rate), "tbr");
3546 if(st->time_base.den && st->time_base.num)
3547 print_fps(1/av_q2d(st->time_base), "tbn");
3548 if(st->codec->time_base.den && st->codec->time_base.num)
3549 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3551 if (st->disposition & AV_DISPOSITION_DEFAULT)
3552 av_log(NULL, AV_LOG_INFO, " (default)");
3553 if (st->disposition & AV_DISPOSITION_DUB)
3554 av_log(NULL, AV_LOG_INFO, " (dub)");
3555 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3556 av_log(NULL, AV_LOG_INFO, " (original)");
3557 if (st->disposition & AV_DISPOSITION_COMMENT)
3558 av_log(NULL, AV_LOG_INFO, " (comment)");
3559 if (st->disposition & AV_DISPOSITION_LYRICS)
3560 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3561 if (st->disposition & AV_DISPOSITION_KARAOKE)
3562 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3563 if (st->disposition & AV_DISPOSITION_FORCED)
3564 av_log(NULL, AV_LOG_INFO, " (forced)");
3565 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3566 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3567 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3568 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3569 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3570 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3571 av_log(NULL, AV_LOG_INFO, "\n");
3572 dump_metadata(NULL, st->metadata, " ");
3575 void av_dump_format(AVFormatContext *ic,
3581 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3582 if (ic->nb_streams && !printed)
3585 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3586 is_output ? "Output" : "Input",
3588 is_output ? ic->oformat->name : ic->iformat->name,
3589 is_output ? "to" : "from", url);
3590 dump_metadata(NULL, ic->metadata, " ");
3592 av_log(NULL, AV_LOG_INFO, " Duration: ");
3593 if (ic->duration != AV_NOPTS_VALUE) {
3594 int hours, mins, secs, us;
3595 int64_t duration = ic->duration + 5000;
3596 secs = duration / AV_TIME_BASE;
3597 us = duration % AV_TIME_BASE;
3602 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3603 (100 * us) / AV_TIME_BASE);
3605 av_log(NULL, AV_LOG_INFO, "N/A");
3607 if (ic->start_time != AV_NOPTS_VALUE) {
3609 av_log(NULL, AV_LOG_INFO, ", start: ");
3610 secs = ic->start_time / AV_TIME_BASE;
3611 us = abs(ic->start_time % AV_TIME_BASE);
3612 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3613 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3615 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3617 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3619 av_log(NULL, AV_LOG_INFO, "N/A");
3621 av_log(NULL, AV_LOG_INFO, "\n");
3623 for (i = 0; i < ic->nb_chapters; i++) {
3624 AVChapter *ch = ic->chapters[i];
3625 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3626 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3627 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3629 dump_metadata(NULL, ch->metadata, " ");
3631 if(ic->nb_programs) {
3632 int j, k, total = 0;
3633 for(j=0; j<ic->nb_programs; j++) {
3634 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3636 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3637 name ? name->value : "");
3638 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3639 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3640 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3641 printed[ic->programs[j]->stream_index[k]] = 1;
3643 total += ic->programs[j]->nb_stream_indexes;
3645 if (total < ic->nb_streams)
3646 av_log(NULL, AV_LOG_INFO, " No Program\n");
3648 for(i=0;i<ic->nb_streams;i++)
3650 dump_stream_format(ic, i, index, is_output);
3655 uint64_t ff_ntp_time(void)
3657 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3660 int av_get_frame_filename(char *buf, int buf_size,
3661 const char *path, int number)
3664 char *q, buf1[20], c;
3665 int nd, len, percentd_found;
3677 while (av_isdigit(*p)) {
3678 nd = nd * 10 + *p++ - '0';
3681 } while (av_isdigit(c));
3690 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3692 if ((q - buf + len) > buf_size - 1)
3694 memcpy(q, buf1, len);
3702 if ((q - buf) < buf_size - 1)
3706 if (!percentd_found)
3715 static void hex_dump_internal(void *avcl, FILE *f, int level,
3716 const uint8_t *buf, int size)
3719 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3721 for(i=0;i<size;i+=16) {
3728 PRINT(" %02x", buf[i+j]);
3733 for(j=0;j<len;j++) {
3735 if (c < ' ' || c > '~')
3744 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3746 hex_dump_internal(NULL, f, 0, buf, size);
3749 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3751 hex_dump_internal(avcl, NULL, level, buf, size);
3754 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3756 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3757 PRINT("stream #%d:\n", pkt->stream_index);
3758 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3759 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3760 /* DTS is _always_ valid after av_read_frame() */
3762 if (pkt->dts == AV_NOPTS_VALUE)
3765 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3766 /* PTS may not be known if B-frames are present. */
3768 if (pkt->pts == AV_NOPTS_VALUE)
3771 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3773 PRINT(" size=%d\n", pkt->size);
3776 av_hex_dump(f, pkt->data, pkt->size);
3779 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3781 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3784 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3787 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3790 void av_url_split(char *proto, int proto_size,
3791 char *authorization, int authorization_size,
3792 char *hostname, int hostname_size,
3794 char *path, int path_size,
3797 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3799 if (port_ptr) *port_ptr = -1;
3800 if (proto_size > 0) proto[0] = 0;
3801 if (authorization_size > 0) authorization[0] = 0;
3802 if (hostname_size > 0) hostname[0] = 0;
3803 if (path_size > 0) path[0] = 0;
3805 /* parse protocol */
3806 if ((p = strchr(url, ':'))) {
3807 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3812 /* no protocol means plain filename */
3813 av_strlcpy(path, url, path_size);
3817 /* separate path from hostname */
3818 ls = strchr(p, '/');
3819 ls2 = strchr(p, '?');
3823 ls = FFMIN(ls, ls2);
3825 av_strlcpy(path, ls, path_size);
3827 ls = &p[strlen(p)]; // XXX
3829 /* the rest is hostname, use that to parse auth/port */
3831 /* authorization (user[:pass]@hostname) */
3833 while ((at = strchr(p, '@')) && at < ls) {
3834 av_strlcpy(authorization, at2,
3835 FFMIN(authorization_size, at + 1 - at2));
3836 p = at + 1; /* skip '@' */
3839 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3841 av_strlcpy(hostname, p + 1,
3842 FFMIN(hostname_size, brk - p));
3843 if (brk[1] == ':' && port_ptr)
3844 *port_ptr = atoi(brk + 2);
3845 } else if ((col = strchr(p, ':')) && col < ls) {
3846 av_strlcpy(hostname, p,
3847 FFMIN(col + 1 - p, hostname_size));
3848 if (port_ptr) *port_ptr = atoi(col + 1);
3850 av_strlcpy(hostname, p,
3851 FFMIN(ls + 1 - p, hostname_size));
3855 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3858 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3861 'C', 'D', 'E', 'F' };
3862 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3865 'c', 'd', 'e', 'f' };
3866 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3868 for(i = 0; i < s; i++) {
3869 buff[i * 2] = hex_table[src[i] >> 4];
3870 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3876 int ff_hex_to_data(uint8_t *data, const char *p)
3883 p += strspn(p, SPACE_CHARS);
3886 c = av_toupper((unsigned char) *p++);
3887 if (c >= '0' && c <= '9')
3889 else if (c >= 'A' && c <= 'F')
3904 #if FF_API_SET_PTS_INFO
3905 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3906 unsigned int pts_num, unsigned int pts_den)
3908 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3912 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3913 unsigned int pts_num, unsigned int pts_den)
3916 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3917 if(new_tb.num != pts_num)
3918 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3920 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3922 if(new_tb.num <= 0 || new_tb.den <= 0) {
3923 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);
3926 s->time_base = new_tb;
3927 av_codec_set_pkt_timebase(s->codec, new_tb);
3928 s->pts_wrap_bits = pts_wrap_bits;
3931 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3934 const char *ptr = str;
3936 /* Parse key=value pairs. */
3939 char *dest = NULL, *dest_end;
3940 int key_len, dest_len = 0;
3942 /* Skip whitespace and potential commas. */
3943 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3950 if (!(ptr = strchr(key, '=')))
3953 key_len = ptr - key;
3955 callback_get_buf(context, key, key_len, &dest, &dest_len);
3956 dest_end = dest + dest_len - 1;
3960 while (*ptr && *ptr != '\"') {
3964 if (dest && dest < dest_end)
3968 if (dest && dest < dest_end)
3976 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3977 if (dest && dest < dest_end)
3985 int ff_find_stream_index(AVFormatContext *s, int id)
3988 for (i = 0; i < s->nb_streams; i++) {
3989 if (s->streams[i]->id == id)
3995 int64_t ff_iso8601_to_unix_time(const char *datestr)
3997 struct tm time1 = {0}, time2 = {0};
3999 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4000 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4002 return av_timegm(&time2);
4004 return av_timegm(&time1);
4007 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4010 if (ofmt->query_codec)
4011 return ofmt->query_codec(codec_id, std_compliance);
4012 else if (ofmt->codec_tag)
4013 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4014 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4015 codec_id == ofmt->subtitle_codec)
4018 return AVERROR_PATCHWELCOME;
4021 int avformat_network_init(void)
4025 ff_network_inited_globally = 1;
4026 if ((ret = ff_network_init()) < 0)
4033 int avformat_network_deinit(void)
4042 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4043 uint64_t channel_layout, int32_t sample_rate,
4044 int32_t width, int32_t height)
4050 return AVERROR(EINVAL);
4053 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4055 if (channel_layout) {
4057 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4061 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4063 if (width || height) {
4065 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4067 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4069 return AVERROR(ENOMEM);
4070 bytestream_put_le32(&data, flags);
4072 bytestream_put_le32(&data, channels);
4074 bytestream_put_le64(&data, channel_layout);
4076 bytestream_put_le32(&data, sample_rate);
4077 if (width || height) {
4078 bytestream_put_le32(&data, width);
4079 bytestream_put_le32(&data, height);
4084 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4086 AVRational undef = {0, 1};
4087 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4088 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4089 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4091 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4092 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4093 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4094 stream_sample_aspect_ratio = undef;
4096 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4097 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4098 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4099 frame_sample_aspect_ratio = undef;
4101 if (stream_sample_aspect_ratio.num)
4102 return stream_sample_aspect_ratio;
4104 return frame_sample_aspect_ratio;
4107 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4109 AVRational fr = st->r_frame_rate;
4111 if (st->codec->ticks_per_frame > 1) {
4112 AVRational codec_fr = av_inv_q(st->codec->time_base);
4113 AVRational avg_fr = st->avg_frame_rate;
4114 codec_fr.den *= st->codec->ticks_per_frame;
4115 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4116 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4123 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4126 if (*spec <= '9' && *spec >= '0') /* opt:index */
4127 return strtol(spec, NULL, 0) == st->index;
4128 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4129 *spec == 't') { /* opt:[vasdt] */
4130 enum AVMediaType type;
4133 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4134 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4135 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4136 case 'd': type = AVMEDIA_TYPE_DATA; break;
4137 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4138 default: av_assert0(0);
4140 if (type != st->codec->codec_type)
4142 if (*spec++ == ':') { /* possibly followed by :index */
4143 int i, index = strtol(spec, NULL, 0);
4144 for (i = 0; i < s->nb_streams; i++)
4145 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4146 return i == st->index;
4150 } else if (*spec == 'p' && *(spec + 1) == ':') {
4154 prog_id = strtol(spec, &endptr, 0);
4155 for (i = 0; i < s->nb_programs; i++) {
4156 if (s->programs[i]->id != prog_id)
4159 if (*endptr++ == ':') {
4160 int stream_idx = strtol(endptr, NULL, 0);
4161 return stream_idx >= 0 &&
4162 stream_idx < s->programs[i]->nb_stream_indexes &&
4163 st->index == s->programs[i]->stream_index[stream_idx];
4166 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4167 if (st->index == s->programs[i]->stream_index[j])
4171 } else if (*spec == '#') {
4174 sid = strtol(spec + 1, &endptr, 0);
4176 return st->id == sid;
4177 } else if (!*spec) /* empty specifier, matches everything */
4180 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4181 return AVERROR(EINVAL);
4184 void ff_generate_avci_extradata(AVStream *st)
4186 static const uint8_t avci100_1080p_extradata[] = {
4188 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4189 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4190 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4191 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4192 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4193 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4194 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4195 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4196 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4198 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4201 static const uint8_t avci100_1080i_extradata[] = {
4203 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4204 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4205 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4206 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4207 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4208 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4209 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4210 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4211 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4212 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4213 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4215 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4218 static const uint8_t avci50_1080i_extradata[] = {
4220 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4221 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4222 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4223 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4224 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4225 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4226 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4227 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4228 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4229 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4230 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4232 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4235 static const uint8_t avci100_720p_extradata[] = {
4237 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4238 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4239 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4240 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4241 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4242 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4243 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4244 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4245 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4246 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4248 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4252 const uint8_t *data = 0;
4253 if (st->codec->width == 1920) {
4254 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4255 data = avci100_1080p_extradata;
4256 size = sizeof(avci100_1080p_extradata);
4258 data = avci100_1080i_extradata;
4259 size = sizeof(avci100_1080i_extradata);
4261 } else if (st->codec->width == 1440) {
4262 data = avci50_1080i_extradata;
4263 size = sizeof(avci50_1080i_extradata);
4264 } else if (st->codec->width == 1280) {
4265 data = avci100_720p_extradata;
4266 size = sizeof(avci100_720p_extradata);
4270 av_freep(&st->codec->extradata);
4271 if (ff_alloc_extradata(st->codec, size))
4273 memcpy(st->codec->extradata, data, size);