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
32 * @file libavformat/utils.c
33 * various utility functions for use within FFmpeg
36 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37 static void av_frac_add(AVFrac *f, int64_t incr);
39 /** head of registered input format linked list */
40 AVInputFormat *first_iformat = NULL;
41 /** head of registered output format linked list */
42 AVOutputFormat *first_oformat = NULL;
44 AVInputFormat *av_iformat_next(AVInputFormat *f)
47 else return first_iformat;
50 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
53 else return first_oformat;
56 void av_register_input_format(AVInputFormat *format)
60 while (*p != NULL) p = &(*p)->next;
65 void av_register_output_format(AVOutputFormat *format)
69 while (*p != NULL) p = &(*p)->next;
74 int match_ext(const char *filename, const char *extensions)
82 ext = strrchr(filename, '.');
88 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
91 if (!strcasecmp(ext1, ext))
101 AVOutputFormat *guess_format(const char *short_name, const char *filename,
102 const char *mime_type)
104 AVOutputFormat *fmt, *fmt_found;
105 int score_max, score;
107 /* specific test for image sequences */
108 #ifdef CONFIG_IMAGE2_MUXER
109 if (!short_name && filename &&
110 av_filename_number_test(filename) &&
111 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112 return guess_format("image2", NULL, NULL);
115 /* Find the proper file type. */
119 while (fmt != NULL) {
121 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
123 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
125 if (filename && fmt->extensions &&
126 match_ext(filename, fmt->extensions)) {
129 if (score > score_max) {
138 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
139 const char *mime_type)
141 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
144 AVOutputFormat *stream_fmt;
145 char stream_format_name[64];
147 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148 stream_fmt = guess_format(stream_format_name, NULL, NULL);
157 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
158 const char *filename, const char *mime_type, enum CodecType type){
159 if(type == CODEC_TYPE_VIDEO){
160 enum CodecID codec_id= CODEC_ID_NONE;
162 #ifdef CONFIG_IMAGE2_MUXER
163 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
164 codec_id= av_guess_image2_codec(filename);
167 if(codec_id == CODEC_ID_NONE)
168 codec_id= fmt->video_codec;
170 }else if(type == CODEC_TYPE_AUDIO)
171 return fmt->audio_codec;
173 return CODEC_ID_NONE;
176 AVInputFormat *av_find_input_format(const char *short_name)
179 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180 if (!strcmp(fmt->name, short_name))
186 /* memory handling */
188 void av_destruct_packet(AVPacket *pkt)
191 pkt->data = NULL; pkt->size = 0;
194 void av_init_packet(AVPacket *pkt)
196 pkt->pts = AV_NOPTS_VALUE;
197 pkt->dts = AV_NOPTS_VALUE;
201 pkt->stream_index = 0;
202 pkt->destruct= av_destruct_packet_nofree;
205 int av_new_packet(AVPacket *pkt, int size)
208 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
209 return AVERROR(ENOMEM);
210 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
212 return AVERROR(ENOMEM);
213 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
218 pkt->destruct = av_destruct_packet;
222 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
224 int ret= av_new_packet(pkt, size);
229 pkt->pos= url_ftell(s);
231 ret= get_buffer(s, pkt->data, size);
240 int av_dup_packet(AVPacket *pkt)
242 if (pkt->destruct != av_destruct_packet) {
244 /* We duplicate the packet and don't forget to add the padding again. */
245 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246 return AVERROR(ENOMEM);
247 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
249 return AVERROR(ENOMEM);
251 memcpy(data, pkt->data, pkt->size);
252 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
254 pkt->destruct = av_destruct_packet;
259 int av_filename_number_test(const char *filename)
262 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
265 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
267 AVInputFormat *fmt1, *fmt;
271 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
272 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
275 if (fmt1->read_probe) {
276 score = fmt1->read_probe(pd);
277 } else if (fmt1->extensions) {
278 if (match_ext(pd->filename, fmt1->extensions)) {
282 if (score > *score_max) {
290 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
292 return av_probe_input_format2(pd, is_opened, &score);
295 /************************************************************/
296 /* input media file */
299 * Open a media file from an IO stream. 'fmt' must be specified.
301 static const char* format_to_name(void* ptr)
303 AVFormatContext* fc = (AVFormatContext*) ptr;
304 if(fc->iformat) return fc->iformat->name;
305 else if(fc->oformat) return fc->oformat->name;
309 #define OFFSET(x) offsetof(AVFormatContext,x)
310 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
311 //these names are too long to be readable
312 #define E AV_OPT_FLAG_ENCODING_PARAM
313 #define D AV_OPT_FLAG_DECODING_PARAM
315 static const AVOption options[]={
316 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
317 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
318 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
320 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
321 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
322 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
323 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
324 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
325 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
326 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, INT_MAX, 0, INT_MAX, D},
334 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
336 static void avformat_get_context_defaults(AVFormatContext *s)
338 memset(s, 0, sizeof(AVFormatContext));
340 s->av_class = &av_format_context_class;
342 av_opt_set_defaults(s);
345 AVFormatContext *av_alloc_format_context(void)
348 ic = av_malloc(sizeof(AVFormatContext));
350 avformat_get_context_defaults(ic);
351 ic->av_class = &av_format_context_class;
355 int av_open_input_stream(AVFormatContext **ic_ptr,
356 ByteIOContext *pb, const char *filename,
357 AVInputFormat *fmt, AVFormatParameters *ap)
361 AVFormatParameters default_ap;
365 memset(ap, 0, sizeof(default_ap));
368 if(!ap->prealloced_context)
369 ic = av_alloc_format_context();
373 err = AVERROR(ENOMEM);
378 ic->duration = AV_NOPTS_VALUE;
379 ic->start_time = AV_NOPTS_VALUE;
380 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
382 /* allocate private data */
383 if (fmt->priv_data_size > 0) {
384 ic->priv_data = av_mallocz(fmt->priv_data_size);
385 if (!ic->priv_data) {
386 err = AVERROR(ENOMEM);
390 ic->priv_data = NULL;
393 err = ic->iformat->read_header(ic, ap);
397 if (pb && !ic->data_offset)
398 ic->data_offset = url_ftell(ic->pb);
404 av_freep(&ic->priv_data);
411 /** size of probe buffer, for guessing file type from file contents */
412 #define PROBE_BUF_MIN 2048
413 #define PROBE_BUF_MAX (1<<20)
415 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
418 AVFormatParameters *ap)
421 AVProbeData probe_data, *pd = &probe_data;
422 ByteIOContext *pb = NULL;
426 pd->filename = filename;
431 /* guess format if no file can be opened */
432 fmt = av_probe_input_format(pd, 0);
435 /* Do not open file if the format does not need it. XXX: specific
436 hack needed to handle RTSP/TCP */
437 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
438 /* if no file needed do not try to open one */
439 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
443 url_setbufsize(pb, buf_size);
446 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
447 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
448 /* read probe data */
449 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
450 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
451 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
452 if (url_fseek(pb, 0, SEEK_SET) < 0) {
454 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
460 /* guess file format */
461 fmt = av_probe_input_format2(pd, 1, &score);
466 /* if still no format found, error */
472 /* check filename in case an image number is expected */
473 if (fmt->flags & AVFMT_NEEDNUMBER) {
474 if (!av_filename_number_test(filename)) {
475 err = AVERROR_NUMEXPECTED;
479 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
492 /*******************************************************/
494 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
499 ret= s->iformat->read_packet(s, pkt);
502 st= s->streams[pkt->stream_index];
504 switch(st->codec->codec_type){
505 case CODEC_TYPE_VIDEO:
506 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
508 case CODEC_TYPE_AUDIO:
509 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
511 case CODEC_TYPE_SUBTITLE:
512 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
519 /**********************************************************/
522 * Get the number of samples of an audio frame. Return -1 on error.
524 static int get_audio_frame_size(AVCodecContext *enc, int size)
528 if (enc->frame_size <= 1) {
529 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
531 if (bits_per_sample) {
532 if (enc->channels == 0)
534 frame_size = (size << 3) / (bits_per_sample * enc->channels);
536 /* used for example by ADPCM codecs */
537 if (enc->bit_rate == 0)
539 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
542 frame_size = enc->frame_size;
549 * Return the frame duration in seconds. Return 0 if not available.
551 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
552 AVCodecParserContext *pc, AVPacket *pkt)
558 switch(st->codec->codec_type) {
559 case CODEC_TYPE_VIDEO:
560 if(st->time_base.num*1000LL > st->time_base.den){
561 *pnum = st->time_base.num;
562 *pden = st->time_base.den;
563 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
564 *pnum = st->codec->time_base.num;
565 *pden = st->codec->time_base.den;
566 if (pc && pc->repeat_pict) {
568 *pnum = (*pnum) * (2 + pc->repeat_pict);
572 case CODEC_TYPE_AUDIO:
573 frame_size = get_audio_frame_size(st->codec, pkt->size);
577 *pden = st->codec->sample_rate;
584 static int is_intra_only(AVCodecContext *enc){
585 if(enc->codec_type == CODEC_TYPE_AUDIO){
587 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
588 switch(enc->codec_id){
590 case CODEC_ID_MJPEGB:
592 case CODEC_ID_RAWVIDEO:
593 case CODEC_ID_DVVIDEO:
594 case CODEC_ID_HUFFYUV:
595 case CODEC_ID_FFVHUFF:
606 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
607 int64_t dts, int64_t pts)
609 AVStream *st= s->streams[stream_index];
610 AVPacketList *pktl= s->packet_buffer;
612 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
615 st->first_dts= dts - st->cur_dts;
618 for(; pktl; pktl= pktl->next){
619 if(pktl->pkt.stream_index != stream_index)
621 //FIXME think more about this check
622 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
623 pktl->pkt.pts += st->first_dts;
625 if(pktl->pkt.dts != AV_NOPTS_VALUE)
626 pktl->pkt.dts += st->first_dts;
628 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
629 st->start_time= pktl->pkt.pts;
631 if (st->start_time == AV_NOPTS_VALUE)
632 st->start_time = pts;
635 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
637 AVPacketList *pktl= s->packet_buffer;
639 assert(pkt->duration && !st->cur_dts);
641 for(; pktl; pktl= pktl->next){
642 if(pktl->pkt.stream_index != pkt->stream_index)
644 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE){
645 pktl->pkt.pts= pktl->pkt.dts= st->cur_dts;
646 st->cur_dts += pkt->duration;
647 pktl->pkt.duration= pkt->duration;
653 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
654 AVCodecParserContext *pc, AVPacket *pkt)
656 int num, den, presentation_delayed, delay, i;
659 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
660 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
661 pkt->dts -= 1LL<<st->pts_wrap_bits;
664 if (pkt->duration == 0) {
665 compute_frame_duration(&num, &den, st, pc, pkt);
667 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
669 if(pkt->dts == AV_NOPTS_VALUE && pkt->pts == AV_NOPTS_VALUE && st->cur_dts == 0)
670 update_initial_durations(s, st, pkt);
674 /* correct timestamps with byte offset if demuxers only have timestamps
675 on packet boundaries */
676 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
677 /* this will estimate bitrate based on this frame's duration and size */
678 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
679 if(pkt->pts != AV_NOPTS_VALUE)
681 if(pkt->dts != AV_NOPTS_VALUE)
685 /* do we have a video B-frame ? */
686 delay= st->codec->has_b_frames;
687 presentation_delayed = 0;
688 /* XXX: need has_b_frame, but cannot get it if the codec is
691 pc && pc->pict_type != FF_B_TYPE)
692 presentation_delayed = 1;
693 /* This may be redundant, but it should not hurt. */
694 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
695 presentation_delayed = 1;
697 if(st->cur_dts == AV_NOPTS_VALUE){
698 st->cur_dts = 0; //FIXME maybe set it to 0 during init
701 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
702 /* interpolate PTS and DTS if they are not present */
704 if (presentation_delayed) {
705 int fields= 2 + (pc ? pc->repeat_pict : 0);
706 int field_duration= pkt->duration / fields;
707 int parity= pc ? pc->parity : 0;
708 /* DTS = decompression timestamp */
709 /* PTS = presentation timestamp */
710 if (pkt->dts == AV_NOPTS_VALUE)
711 pkt->dts = st->last_IP_pts[parity];
712 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
713 if (pkt->dts == AV_NOPTS_VALUE)
714 pkt->dts = st->cur_dts;
716 /* this is tricky: the dts must be incremented by the duration
717 of the frame we are displaying, i.e. the last I- or P-frame */
718 st->cur_dts = pkt->dts;
719 for(i=0; i<fields; i++){
720 int p= (parity + i)&1;
721 if(!st->last_IP_duration[p])
722 st->last_IP_duration[p]= field_duration;
723 st->cur_dts += st->last_IP_duration[p];
724 st->last_IP_pts[p]= pkt->pts;
725 if(pkt->pts != AV_NOPTS_VALUE)
726 st->last_IP_pts[p] += i*field_duration;
727 st->last_IP_duration[p]= field_duration;
729 /* cannot compute PTS if not present (we can compute it only
730 by knowing the future */
731 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
732 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
733 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
734 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
735 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
736 pkt->pts += pkt->duration;
737 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
741 /* presentation is not delayed : PTS and DTS are the same */
742 if(pkt->pts == AV_NOPTS_VALUE)
744 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
745 if(pkt->pts == AV_NOPTS_VALUE)
746 pkt->pts = st->cur_dts;
748 st->cur_dts = pkt->pts + pkt->duration;
752 if(pkt->pts != AV_NOPTS_VALUE){
753 st->pts_buffer[0]= pkt->pts;
754 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
755 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
756 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
757 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
758 if(pkt->dts == AV_NOPTS_VALUE)
759 pkt->dts= st->pts_buffer[0];
761 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
763 if(pkt->dts > st->cur_dts)
764 st->cur_dts = pkt->dts;
767 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
770 if(is_intra_only(st->codec))
771 pkt->flags |= PKT_FLAG_KEY;
774 /* keyframe computation */
775 if (pc->pict_type == FF_I_TYPE)
776 pkt->flags |= PKT_FLAG_KEY;
780 void av_destruct_packet_nofree(AVPacket *pkt)
782 pkt->data = NULL; pkt->size = 0;
785 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
793 /* select current input stream component */
796 if (!st->need_parsing || !st->parser) {
797 /* no parsing needed: we just output the packet as is */
798 /* raw data support */
800 compute_pkt_fields(s, st, NULL, pkt);
803 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
804 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
805 s->cur_ptr, s->cur_len,
806 s->cur_pkt.pts, s->cur_pkt.dts);
807 s->cur_pkt.pts = AV_NOPTS_VALUE;
808 s->cur_pkt.dts = AV_NOPTS_VALUE;
809 /* increment read pointer */
813 /* return packet if any */
816 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
818 pkt->stream_index = st->index;
819 pkt->pts = st->parser->pts;
820 pkt->dts = st->parser->dts;
821 pkt->destruct = av_destruct_packet_nofree;
822 compute_pkt_fields(s, st, st->parser, pkt);
824 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
825 ff_reduce_index(s, st->index);
826 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
827 0, 0, AVINDEX_KEYFRAME);
834 av_free_packet(&s->cur_pkt);
838 /* read next packet */
839 ret = av_read_packet(s, &s->cur_pkt);
841 if (ret == AVERROR(EAGAIN))
843 /* return the last frames, if any */
844 for(i = 0; i < s->nb_streams; i++) {
846 if (st->parser && st->need_parsing) {
847 av_parser_parse(st->parser, st->codec,
848 &pkt->data, &pkt->size,
850 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
855 /* no more packets: really terminate parsing */
859 st = s->streams[s->cur_pkt.stream_index];
860 if(st->codec->debug & FF_DEBUG_PTS)
861 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
862 s->cur_pkt.stream_index,
868 s->cur_ptr = s->cur_pkt.data;
869 s->cur_len = s->cur_pkt.size;
870 if (st->need_parsing && !st->parser) {
871 st->parser = av_parser_init(st->codec->codec_id);
873 /* no parser available: just output the raw packets */
874 st->need_parsing = AVSTREAM_PARSE_NONE;
875 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
876 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
878 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
879 st->parser->last_frame_offset=
880 st->parser->cur_offset= s->cur_pkt.pos;
885 if(st->codec->debug & FF_DEBUG_PTS)
886 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
895 static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
896 AVPacketList *pktl= s->packet_buffer;
897 AVPacketList **plast_pktl= &s->packet_buffer;
899 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
901 pktl = av_mallocz(sizeof(AVPacketList));
905 /* add the packet in the buffered packet list */
911 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
915 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
918 pktl = s->packet_buffer;
920 AVPacket *next_pkt= &pktl->pkt;
922 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
923 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
924 if( pktl->pkt.stream_index == next_pkt->stream_index
925 && next_pkt->dts < pktl->pkt.dts
926 && pktl->pkt.pts != pktl->pkt.dts //not b frame
927 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
928 next_pkt->pts= pktl->pkt.dts;
932 pktl = s->packet_buffer;
935 if( next_pkt->pts != AV_NOPTS_VALUE
936 || next_pkt->dts == AV_NOPTS_VALUE
938 /* read packet from packet buffer, if there is data */
940 s->packet_buffer = pktl->next;
946 int ret= av_read_frame_internal(s, pkt);
948 if(pktl && ret != AVERROR(EAGAIN)){
955 if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
956 return AVERROR(ENOMEM);
958 assert(!s->packet_buffer);
959 return av_read_frame_internal(s, pkt);
964 /* XXX: suppress the packet queue */
965 static void flush_packet_queue(AVFormatContext *s)
970 pktl = s->packet_buffer;
973 s->packet_buffer = pktl->next;
974 av_free_packet(&pktl->pkt);
979 /*******************************************************/
982 int av_find_default_stream_index(AVFormatContext *s)
987 if (s->nb_streams <= 0)
989 for(i = 0; i < s->nb_streams; i++) {
991 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
999 * Flush the frame reader.
1001 static void av_read_frame_flush(AVFormatContext *s)
1006 flush_packet_queue(s);
1008 /* free previous packet */
1010 if (s->cur_st->parser)
1011 av_free_packet(&s->cur_pkt);
1018 /* for each stream, reset read state */
1019 for(i = 0; i < s->nb_streams; i++) {
1023 av_parser_close(st->parser);
1026 st->last_IP_pts[0] =
1027 st->last_IP_pts[1] = AV_NOPTS_VALUE;
1028 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1032 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1035 for(i = 0; i < s->nb_streams; i++) {
1036 AVStream *st = s->streams[i];
1038 st->cur_dts = av_rescale(timestamp,
1039 st->time_base.den * (int64_t)ref_st->time_base.num,
1040 st->time_base.num * (int64_t)ref_st->time_base.den);
1044 void ff_reduce_index(AVFormatContext *s, int stream_index)
1046 AVStream *st= s->streams[stream_index];
1047 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1049 if((unsigned)st->nb_index_entries >= max_entries){
1051 for(i=0; 2*i<st->nb_index_entries; i++)
1052 st->index_entries[i]= st->index_entries[2*i];
1053 st->nb_index_entries= i;
1057 int av_add_index_entry(AVStream *st,
1058 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1060 AVIndexEntry *entries, *ie;
1063 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1066 entries = av_fast_realloc(st->index_entries,
1067 &st->index_entries_allocated_size,
1068 (st->nb_index_entries + 1) *
1069 sizeof(AVIndexEntry));
1073 st->index_entries= entries;
1075 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1078 index= st->nb_index_entries++;
1079 ie= &entries[index];
1080 assert(index==0 || ie[-1].timestamp < timestamp);
1082 ie= &entries[index];
1083 if(ie->timestamp != timestamp){
1084 if(ie->timestamp <= timestamp)
1086 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1087 st->nb_index_entries++;
1088 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1089 distance= ie->min_distance;
1093 ie->timestamp = timestamp;
1094 ie->min_distance= distance;
1101 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1104 AVIndexEntry *entries= st->index_entries;
1105 int nb_entries= st->nb_index_entries;
1114 timestamp = entries[m].timestamp;
1115 if(timestamp >= wanted_timestamp)
1117 if(timestamp <= wanted_timestamp)
1120 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1122 if(!(flags & AVSEEK_FLAG_ANY)){
1123 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1124 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1135 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1136 AVInputFormat *avif= s->iformat;
1137 int64_t pos_min, pos_max, pos, pos_limit;
1138 int64_t ts_min, ts_max, ts;
1142 if (stream_index < 0)
1146 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1150 ts_min= AV_NOPTS_VALUE;
1151 pos_limit= -1; //gcc falsely says it may be uninitialized
1153 st= s->streams[stream_index];
1154 if(st->index_entries){
1157 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()
1158 index= FFMAX(index, 0);
1159 e= &st->index_entries[index];
1161 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1163 ts_min= e->timestamp;
1165 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1172 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1173 assert(index < st->nb_index_entries);
1175 e= &st->index_entries[index];
1176 assert(e->timestamp >= target_ts);
1178 ts_max= e->timestamp;
1179 pos_limit= pos_max - e->min_distance;
1181 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1182 pos_max,pos_limit, ts_max);
1187 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1192 url_fseek(s->pb, pos, SEEK_SET);
1194 av_update_cur_dts(s, st, ts);
1199 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1201 int64_t start_pos, filesize;
1205 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1208 if(ts_min == AV_NOPTS_VALUE){
1209 pos_min = s->data_offset;
1210 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1211 if (ts_min == AV_NOPTS_VALUE)
1215 if(ts_max == AV_NOPTS_VALUE){
1217 filesize = url_fsize(s->pb);
1218 pos_max = filesize - 1;
1221 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1223 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1224 if (ts_max == AV_NOPTS_VALUE)
1228 int64_t tmp_pos= pos_max + 1;
1229 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1230 if(tmp_ts == AV_NOPTS_VALUE)
1234 if(tmp_pos >= filesize)
1240 if(ts_min > ts_max){
1242 }else if(ts_min == ts_max){
1247 while (pos_min < pos_limit) {
1249 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1253 assert(pos_limit <= pos_max);
1256 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1257 // interpolate position (better than dichotomy)
1258 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1259 + pos_min - approximate_keyframe_distance;
1260 }else if(no_change==1){
1261 // bisection, if interpolation failed to change min or max pos last time
1262 pos = (pos_min + pos_limit)>>1;
1264 /* linear search if bisection failed, can only happen if there
1265 are very few or no keyframes between min/max */
1270 else if(pos > pos_limit)
1274 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1280 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1282 if(ts == AV_NOPTS_VALUE){
1283 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1286 assert(ts != AV_NOPTS_VALUE);
1287 if (target_ts <= ts) {
1288 pos_limit = start_pos - 1;
1292 if (target_ts >= ts) {
1298 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1299 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1302 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1304 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1305 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1306 pos, ts_min, target_ts, ts_max);
1312 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1313 int64_t pos_min, pos_max;
1317 if (stream_index < 0)
1320 st= s->streams[stream_index];
1323 pos_min = s->data_offset;
1324 pos_max = url_fsize(s->pb) - 1;
1326 if (pos < pos_min) pos= pos_min;
1327 else if(pos > pos_max) pos= pos_max;
1329 url_fseek(s->pb, pos, SEEK_SET);
1332 av_update_cur_dts(s, st, ts);
1337 static int av_seek_frame_generic(AVFormatContext *s,
1338 int stream_index, int64_t timestamp, int flags)
1344 st = s->streams[stream_index];
1346 index = av_index_search_timestamp(st, timestamp, flags);
1348 if(index < 0 || index==st->nb_index_entries-1){
1352 if(st->index_entries && st->nb_index_entries){
1353 ie= &st->index_entries[st->nb_index_entries-1];
1354 url_fseek(s->pb, ie->pos, SEEK_SET);
1355 av_update_cur_dts(s, st, ie->timestamp);
1357 url_fseek(s->pb, 0, SEEK_SET);
1360 int ret = av_read_frame(s, &pkt);
1363 av_free_packet(&pkt);
1364 if(stream_index == pkt.stream_index){
1365 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1369 index = av_index_search_timestamp(st, timestamp, flags);
1374 av_read_frame_flush(s);
1375 if (s->iformat->read_seek){
1376 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1379 ie = &st->index_entries[index];
1380 url_fseek(s->pb, ie->pos, SEEK_SET);
1382 av_update_cur_dts(s, st, ie->timestamp);
1387 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1392 av_read_frame_flush(s);
1394 if(flags & AVSEEK_FLAG_BYTE)
1395 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1397 if(stream_index < 0){
1398 stream_index= av_find_default_stream_index(s);
1399 if(stream_index < 0)
1402 st= s->streams[stream_index];
1403 /* timestamp for default must be expressed in AV_TIME_BASE units */
1404 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1406 st= s->streams[stream_index];
1408 /* first, we try the format specific seek */
1409 if (s->iformat->read_seek)
1410 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1417 if(s->iformat->read_timestamp)
1418 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1420 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1423 /*******************************************************/
1426 * Returns TRUE if the stream has accurate duration in any stream.
1428 * @return TRUE if the stream has accurate duration for at least one component.
1430 static int av_has_duration(AVFormatContext *ic)
1435 for(i = 0;i < ic->nb_streams; i++) {
1436 st = ic->streams[i];
1437 if (st->duration != AV_NOPTS_VALUE)
1444 * Estimate the stream timings from the one of each components.
1446 * Also computes the global bitrate if possible.
1448 static void av_update_stream_timings(AVFormatContext *ic)
1450 int64_t start_time, start_time1, end_time, end_time1;
1451 int64_t duration, duration1;
1455 start_time = INT64_MAX;
1456 end_time = INT64_MIN;
1457 duration = INT64_MIN;
1458 for(i = 0;i < ic->nb_streams; i++) {
1459 st = ic->streams[i];
1460 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1461 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1462 if (start_time1 < start_time)
1463 start_time = start_time1;
1464 if (st->duration != AV_NOPTS_VALUE) {
1465 end_time1 = start_time1
1466 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1467 if (end_time1 > end_time)
1468 end_time = end_time1;
1471 if (st->duration != AV_NOPTS_VALUE) {
1472 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1473 if (duration1 > duration)
1474 duration = duration1;
1477 if (start_time != INT64_MAX) {
1478 ic->start_time = start_time;
1479 if (end_time != INT64_MIN) {
1480 if (end_time - start_time > duration)
1481 duration = end_time - start_time;
1484 if (duration != INT64_MIN) {
1485 ic->duration = duration;
1486 if (ic->file_size > 0) {
1487 /* compute the bitrate */
1488 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1489 (double)ic->duration;
1494 static void fill_all_stream_timings(AVFormatContext *ic)
1499 av_update_stream_timings(ic);
1500 for(i = 0;i < ic->nb_streams; i++) {
1501 st = ic->streams[i];
1502 if (st->start_time == AV_NOPTS_VALUE) {
1503 if(ic->start_time != AV_NOPTS_VALUE)
1504 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1505 if(ic->duration != AV_NOPTS_VALUE)
1506 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1511 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1513 int64_t filesize, duration;
1517 /* if bit_rate is already set, we believe it */
1518 if (ic->bit_rate == 0) {
1520 for(i=0;i<ic->nb_streams;i++) {
1521 st = ic->streams[i];
1522 bit_rate += st->codec->bit_rate;
1524 ic->bit_rate = bit_rate;
1527 /* if duration is already set, we believe it */
1528 if (ic->duration == AV_NOPTS_VALUE &&
1529 ic->bit_rate != 0 &&
1530 ic->file_size != 0) {
1531 filesize = ic->file_size;
1533 for(i = 0; i < ic->nb_streams; i++) {
1534 st = ic->streams[i];
1535 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1536 if (st->duration == AV_NOPTS_VALUE)
1537 st->duration = duration;
1543 #define DURATION_MAX_READ_SIZE 250000
1545 /* only usable for MPEG-PS streams */
1546 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1548 AVPacket pkt1, *pkt = &pkt1;
1550 int read_size, i, ret;
1552 int64_t filesize, offset, duration;
1554 /* free previous packet */
1555 if (ic->cur_st && ic->cur_st->parser)
1556 av_free_packet(&ic->cur_pkt);
1559 /* flush packet queue */
1560 flush_packet_queue(ic);
1562 for(i=0;i<ic->nb_streams;i++) {
1563 st = ic->streams[i];
1565 av_parser_close(st->parser);
1570 /* we read the first packets to get the first PTS (not fully
1571 accurate, but it is enough now) */
1572 url_fseek(ic->pb, 0, SEEK_SET);
1575 if (read_size >= DURATION_MAX_READ_SIZE)
1577 /* if all info is available, we can stop */
1578 for(i = 0;i < ic->nb_streams; i++) {
1579 st = ic->streams[i];
1580 if (st->start_time == AV_NOPTS_VALUE)
1583 if (i == ic->nb_streams)
1586 ret = av_read_packet(ic, pkt);
1589 read_size += pkt->size;
1590 st = ic->streams[pkt->stream_index];
1591 if (pkt->pts != AV_NOPTS_VALUE) {
1592 if (st->start_time == AV_NOPTS_VALUE)
1593 st->start_time = pkt->pts;
1595 av_free_packet(pkt);
1598 /* estimate the end time (duration) */
1599 /* XXX: may need to support wrapping */
1600 filesize = ic->file_size;
1601 offset = filesize - DURATION_MAX_READ_SIZE;
1605 url_fseek(ic->pb, offset, SEEK_SET);
1608 if (read_size >= DURATION_MAX_READ_SIZE)
1611 ret = av_read_packet(ic, pkt);
1614 read_size += pkt->size;
1615 st = ic->streams[pkt->stream_index];
1616 if (pkt->pts != AV_NOPTS_VALUE &&
1617 st->start_time != AV_NOPTS_VALUE) {
1618 end_time = pkt->pts;
1619 duration = end_time - st->start_time;
1621 if (st->duration == AV_NOPTS_VALUE ||
1622 st->duration < duration)
1623 st->duration = duration;
1626 av_free_packet(pkt);
1629 fill_all_stream_timings(ic);
1631 url_fseek(ic->pb, old_offset, SEEK_SET);
1632 for(i=0; i<ic->nb_streams; i++){
1634 st->cur_dts= st->first_dts;
1635 st->last_IP_pts[0] =
1636 st->last_IP_pts[1] = AV_NOPTS_VALUE;
1640 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1644 /* get the file size, if possible */
1645 if (ic->iformat->flags & AVFMT_NOFILE) {
1648 file_size = url_fsize(ic->pb);
1652 ic->file_size = file_size;
1654 if ((!strcmp(ic->iformat->name, "mpeg") ||
1655 !strcmp(ic->iformat->name, "mpegts")) &&
1656 file_size && !url_is_streamed(ic->pb)) {
1657 /* get accurate estimate from the PTSes */
1658 av_estimate_timings_from_pts(ic, old_offset);
1659 } else if (av_has_duration(ic)) {
1660 /* at least one component has timings - we use them for all
1662 fill_all_stream_timings(ic);
1664 /* less precise: use bitrate info */
1665 av_estimate_timings_from_bit_rate(ic);
1667 av_update_stream_timings(ic);
1673 for(i = 0;i < ic->nb_streams; i++) {
1674 st = ic->streams[i];
1675 printf("%d: start_time: %0.3f duration: %0.3f\n",
1676 i, (double)st->start_time / AV_TIME_BASE,
1677 (double)st->duration / AV_TIME_BASE);
1679 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1680 (double)ic->start_time / AV_TIME_BASE,
1681 (double)ic->duration / AV_TIME_BASE,
1682 ic->bit_rate / 1000);
1687 static int has_codec_parameters(AVCodecContext *enc)
1690 switch(enc->codec_type) {
1691 case CODEC_TYPE_AUDIO:
1692 val = enc->sample_rate;
1694 case CODEC_TYPE_VIDEO:
1695 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1701 return (enc->codec_id != CODEC_ID_NONE && val != 0);
1704 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1708 int got_picture, data_size, ret=0;
1711 if(!st->codec->codec){
1712 codec = avcodec_find_decoder(st->codec->codec_id);
1715 ret = avcodec_open(st->codec, codec);
1720 if(!has_codec_parameters(st->codec)){
1721 switch(st->codec->codec_type) {
1722 case CODEC_TYPE_VIDEO:
1723 ret = avcodec_decode_video(st->codec, &picture,
1724 &got_picture, data, size);
1726 case CODEC_TYPE_AUDIO:
1727 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1728 samples = av_malloc(data_size);
1731 ret = avcodec_decode_audio2(st->codec, samples,
1732 &data_size, data, size);
1743 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1746 fmt = av_probe_input_format2(pd, 1, &score);
1749 if (strncmp(fmt->name, "mp3", 3) == 0)
1750 st->codec->codec_id = CODEC_ID_MP3;
1751 else if (strncmp(fmt->name, "ac3", 3) == 0)
1752 st->codec->codec_id = CODEC_ID_AC3;
1757 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1759 while (tags->id != CODEC_ID_NONE) {
1767 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1770 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1771 if(tag == tags[i].tag)
1774 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1775 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1776 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1777 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1778 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1781 return CODEC_ID_NONE;
1784 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1787 for(i=0; tags && tags[i]; i++){
1788 int tag= codec_get_tag(tags[i], id);
1794 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1797 for(i=0; tags && tags[i]; i++){
1798 enum CodecID id= codec_get_id(tags[i], tag);
1799 if(id!=CODEC_ID_NONE) return id;
1801 return CODEC_ID_NONE;
1804 /* absolute maximum size we read until we abort */
1805 #define MAX_READ_SIZE 5000000
1807 #define MAX_STD_TIMEBASES (60*12+5)
1808 static int get_std_framerate(int i){
1809 if(i<60*12) return i*1001;
1810 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1814 * Is the time base unreliable.
1815 * This is a heuristic to balance between quick acceptance of the values in
1816 * the headers vs. some extra checks.
1817 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1818 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1819 * And there are "variable" fps files this needs to detect as well.
1821 static int tb_unreliable(AVCodecContext *c){
1822 if( c->time_base.den >= 101L*c->time_base.num
1823 || c->time_base.den < 5L*c->time_base.num
1824 /* || c->codec_tag == ff_get_fourcc("DIVX")
1825 || c->codec_tag == ff_get_fourcc("XVID")*/
1826 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1831 int av_find_stream_info(AVFormatContext *ic)
1833 int i, count, ret, read_size, j;
1835 AVPacket pkt1, *pkt;
1836 int64_t last_dts[MAX_STREAMS];
1837 int duration_count[MAX_STREAMS]={0};
1838 double (*duration_error)[MAX_STD_TIMEBASES];
1839 offset_t old_offset = url_ftell(ic->pb);
1840 int64_t codec_info_duration[MAX_STREAMS]={0};
1841 int codec_info_nb_frames[MAX_STREAMS]={0};
1842 AVProbeData probe_data[MAX_STREAMS];
1843 int codec_identified[MAX_STREAMS]={0};
1845 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1846 if (!duration_error) return AVERROR(ENOMEM);
1848 for(i=0;i<ic->nb_streams;i++) {
1849 st = ic->streams[i];
1850 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1851 /* if(!st->time_base.num)
1853 if(!st->codec->time_base.num)
1854 st->codec->time_base= st->time_base;
1856 //only for the split stuff
1858 st->parser = av_parser_init(st->codec->codec_id);
1859 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1860 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1865 for(i=0;i<MAX_STREAMS;i++){
1866 last_dts[i]= AV_NOPTS_VALUE;
1869 memset(probe_data, 0, sizeof(probe_data));
1873 /* check if one codec still needs to be handled */
1874 for(i=0;i<ic->nb_streams;i++) {
1875 st = ic->streams[i];
1876 if (!has_codec_parameters(st->codec))
1878 /* variable fps and no guess at the real fps */
1879 if( tb_unreliable(st->codec)
1880 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1882 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1884 if(st->first_dts == AV_NOPTS_VALUE)
1887 if (i == ic->nb_streams) {
1888 /* NOTE: if the format has no header, then we need to read
1889 some packets to get most of the streams, so we cannot
1891 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1892 /* if we found the info for all the codecs, we can stop */
1897 /* we did not get all the codec info, but we read too much data */
1898 if (read_size >= MAX_READ_SIZE) {
1903 /* NOTE: a new stream can be added there if no header in file
1904 (AVFMTCTX_NOHEADER) */
1905 ret = av_read_frame_internal(ic, &pkt1);
1908 ret = -1; /* we could not have all the codec parameters before EOF */
1909 for(i=0;i<ic->nb_streams;i++) {
1910 st = ic->streams[i];
1911 if (!has_codec_parameters(st->codec)){
1913 avcodec_string(buf, sizeof(buf), st->codec, 0);
1914 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1922 pkt= add_to_pktbuf(ic, &pkt1);
1923 if(av_dup_packet(pkt) < 0)
1924 return AVERROR(ENOMEM);
1926 read_size += pkt->size;
1928 st = ic->streams[pkt->stream_index];
1929 if(codec_info_nb_frames[st->index]>1)
1930 codec_info_duration[st->index] += pkt->duration;
1931 if (pkt->duration != 0)
1932 codec_info_nb_frames[st->index]++;
1935 int index= pkt->stream_index;
1936 int64_t last= last_dts[index];
1937 int64_t duration= pkt->dts - last;
1939 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1940 double dur= duration * av_q2d(st->time_base);
1942 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1943 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1944 if(duration_count[index] < 2)
1945 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1946 for(i=1; i<MAX_STD_TIMEBASES; i++){
1947 int framerate= get_std_framerate(i);
1948 int ticks= lrintf(dur*framerate/(1001*12));
1949 double error= dur - ticks*1001*12/(double)framerate;
1950 duration_error[index][i] += error*error;
1952 duration_count[index]++;
1954 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1955 last_dts[pkt->stream_index]= pkt->dts;
1957 if (st->codec->codec_id == CODEC_ID_NONE) {
1958 AVProbeData *pd = &(probe_data[st->index]);
1959 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1960 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1961 pd->buf_size += pkt->size;
1962 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1965 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1966 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1968 st->codec->extradata_size= i;
1969 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1970 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1971 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1975 /* if still no information, we try to open the codec and to
1976 decompress the frame. We try to avoid that in most cases as
1977 it takes longer and uses more memory. For MPEG-4, we need to
1978 decompress for QuickTime. */
1979 if (!has_codec_parameters(st->codec) /*&&
1980 (st->codec->codec_id == CODEC_ID_FLV1 ||
1981 st->codec->codec_id == CODEC_ID_H264 ||
1982 st->codec->codec_id == CODEC_ID_H263 ||
1983 st->codec->codec_id == CODEC_ID_H261 ||
1984 st->codec->codec_id == CODEC_ID_VORBIS ||
1985 st->codec->codec_id == CODEC_ID_MJPEG ||
1986 st->codec->codec_id == CODEC_ID_PNG ||
1987 st->codec->codec_id == CODEC_ID_PAM ||
1988 st->codec->codec_id == CODEC_ID_PGM ||
1989 st->codec->codec_id == CODEC_ID_PGMYUV ||
1990 st->codec->codec_id == CODEC_ID_PBM ||
1991 st->codec->codec_id == CODEC_ID_PPM ||
1992 st->codec->codec_id == CODEC_ID_SHORTEN ||
1993 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1994 try_decode_frame(st, pkt->data, pkt->size);
1996 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2002 // close codecs which where opened in try_decode_frame()
2003 for(i=0;i<ic->nb_streams;i++) {
2004 st = ic->streams[i];
2005 if(st->codec->codec)
2006 avcodec_close(st->codec);
2008 for(i=0;i<ic->nb_streams;i++) {
2009 st = ic->streams[i];
2010 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2011 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2012 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2014 if(duration_count[i]
2015 && tb_unreliable(st->codec) /*&&
2016 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2017 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2018 double best_error= 2*av_q2d(st->time_base);
2019 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2021 for(j=1; j<MAX_STD_TIMEBASES; j++){
2022 double error= duration_error[i][j] * get_std_framerate(j);
2023 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2024 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2025 if(error < best_error){
2027 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2032 if (!st->r_frame_rate.num){
2033 if( st->codec->time_base.den * (int64_t)st->time_base.num
2034 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2035 st->r_frame_rate.num = st->codec->time_base.den;
2036 st->r_frame_rate.den = st->codec->time_base.num;
2038 st->r_frame_rate.num = st->time_base.den;
2039 st->r_frame_rate.den = st->time_base.num;
2042 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2043 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2044 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2045 if (codec_identified[st->index]) {
2046 st->need_parsing = AVSTREAM_PARSE_FULL;
2049 if(!st->codec->bits_per_sample)
2050 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2054 av_estimate_timings(ic, old_offset);
2056 for(i=0;i<ic->nb_streams;i++) {
2057 st = ic->streams[i];
2058 if (codec_identified[st->index])
2061 //FIXME this is a mess
2062 if(i!=ic->nb_streams){
2063 av_read_frame_flush(ic);
2064 for(i=0;i<ic->nb_streams;i++) {
2065 st = ic->streams[i];
2066 if (codec_identified[st->index]) {
2067 av_seek_frame(ic, st->index, 0.0, 0);
2069 st->cur_dts= st->first_dts;
2071 url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2075 /* correct DTS for B-frame streams with no timestamps */
2076 for(i=0;i<ic->nb_streams;i++) {
2077 st = ic->streams[i];
2078 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2080 ppktl = &ic->packet_buffer;
2082 if(ppkt1->stream_index != i)
2084 if(ppkt1->pkt->dts < 0)
2086 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2088 ppkt1->pkt->dts -= delta;
2093 st->cur_dts -= delta;
2099 av_free(duration_error);
2100 for(i=0;i<MAX_STREAMS;i++){
2101 av_freep(&(probe_data[i].buf));
2107 /*******************************************************/
2109 int av_read_play(AVFormatContext *s)
2111 if (s->iformat->read_play)
2112 return s->iformat->read_play(s);
2114 return av_url_read_fpause(s->pb, 0);
2115 return AVERROR(ENOSYS);
2118 int av_read_pause(AVFormatContext *s)
2120 if (s->iformat->read_pause)
2121 return s->iformat->read_pause(s);
2123 return av_url_read_fpause(s->pb, 1);
2124 return AVERROR(ENOSYS);
2127 void av_close_input_stream(AVFormatContext *s)
2132 /* free previous packet */
2133 if (s->cur_st && s->cur_st->parser)
2134 av_free_packet(&s->cur_pkt);
2136 if (s->iformat->read_close)
2137 s->iformat->read_close(s);
2138 for(i=0;i<s->nb_streams;i++) {
2139 /* free all data in a stream component */
2142 av_parser_close(st->parser);
2144 av_free(st->index_entries);
2145 av_free(st->codec->extradata);
2147 av_free(st->filename);
2150 for(i=s->nb_programs-1; i>=0; i--) {
2151 av_freep(&s->programs[i]->provider_name);
2152 av_freep(&s->programs[i]->name);
2153 av_freep(&s->programs[i]->stream_index);
2154 av_freep(&s->programs[i]);
2156 flush_packet_queue(s);
2157 av_freep(&s->priv_data);
2161 void av_close_input_file(AVFormatContext *s)
2163 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2164 av_close_input_stream(s);
2169 AVStream *av_new_stream(AVFormatContext *s, int id)
2174 if (s->nb_streams >= MAX_STREAMS)
2177 st = av_mallocz(sizeof(AVStream));
2181 st->codec= avcodec_alloc_context();
2183 /* no default bitrate if decoding */
2184 st->codec->bit_rate = 0;
2186 st->index = s->nb_streams;
2188 st->start_time = AV_NOPTS_VALUE;
2189 st->duration = AV_NOPTS_VALUE;
2190 st->cur_dts = AV_NOPTS_VALUE;
2191 st->first_dts = AV_NOPTS_VALUE;
2193 /* default pts setting is MPEG-like */
2194 av_set_pts_info(st, 33, 1, 90000);
2195 st->last_IP_pts[0] =
2196 st->last_IP_pts[1] = AV_NOPTS_VALUE;
2197 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2198 st->pts_buffer[i]= AV_NOPTS_VALUE;
2200 s->streams[s->nb_streams++] = st;
2204 AVProgram *av_new_program(AVFormatContext *ac, int id)
2206 AVProgram *program=NULL;
2210 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2213 for(i=0; i<ac->nb_programs; i++)
2214 if(ac->programs[i]->id == id)
2215 program = ac->programs[i];
2218 program = av_mallocz(sizeof(AVProgram));
2221 dynarray_add(&ac->programs, &ac->nb_programs, program);
2222 program->discard = AVDISCARD_NONE;
2229 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2231 assert(!provider_name == !name);
2233 av_free(program->provider_name);
2234 av_free(program-> name);
2235 program->provider_name = av_strdup(provider_name);
2236 program-> name = av_strdup( name);
2241 /************************************************************/
2242 /* output media file */
2244 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2248 if (s->oformat->priv_data_size > 0) {
2249 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2251 return AVERROR(ENOMEM);
2253 s->priv_data = NULL;
2255 if (s->oformat->set_parameters) {
2256 ret = s->oformat->set_parameters(s, ap);
2263 int av_write_header(AVFormatContext *s)
2268 // some sanity checks
2269 for(i=0;i<s->nb_streams;i++) {
2272 switch (st->codec->codec_type) {
2273 case CODEC_TYPE_AUDIO:
2274 if(st->codec->sample_rate<=0){
2275 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2279 case CODEC_TYPE_VIDEO:
2280 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2281 av_log(s, AV_LOG_ERROR, "time base not set\n");
2284 if(st->codec->width<=0 || st->codec->height<=0){
2285 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2291 if(s->oformat->codec_tag){
2292 if(st->codec->codec_tag){
2294 //check that tag + id is in the table
2295 //if neither is in the table -> OK
2296 //if tag is in the table with another id -> FAIL
2297 //if id is in the table with another tag -> FAIL unless strict < ?
2299 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2303 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2304 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2306 return AVERROR(ENOMEM);
2309 if(s->oformat->write_header){
2310 ret = s->oformat->write_header(s);
2315 /* init PTS generation */
2316 for(i=0;i<s->nb_streams;i++) {
2317 int64_t den = AV_NOPTS_VALUE;
2320 switch (st->codec->codec_type) {
2321 case CODEC_TYPE_AUDIO:
2322 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2324 case CODEC_TYPE_VIDEO:
2325 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2330 if (den != AV_NOPTS_VALUE) {
2332 return AVERROR_INVALIDDATA;
2333 av_frac_init(&st->pts, 0, 0, den);
2339 //FIXME merge with compute_pkt_fields
2340 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2341 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2342 int num, den, frame_size, i;
2344 // av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2346 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2349 /* duration field */
2350 if (pkt->duration == 0) {
2351 compute_frame_duration(&num, &den, st, NULL, pkt);
2353 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2357 //XXX/FIXME this is a temporary hack until all encoders output pts
2358 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2360 // pkt->pts= st->cur_dts;
2361 pkt->pts= st->pts.val;
2364 //calculate dts from pts
2365 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2366 st->pts_buffer[0]= pkt->pts;
2367 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2368 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2369 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2370 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2372 pkt->dts= st->pts_buffer[0];
2375 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2376 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2379 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2380 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2384 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2385 st->cur_dts= pkt->dts;
2386 st->pts.val= pkt->dts;
2389 switch (st->codec->codec_type) {
2390 case CODEC_TYPE_AUDIO:
2391 frame_size = get_audio_frame_size(st->codec, pkt->size);
2393 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2394 likely equal to the encoder delay, but it would be better if we
2395 had the real timestamps from the encoder */
2396 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2397 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2400 case CODEC_TYPE_VIDEO:
2401 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2409 static void truncate_ts(AVStream *st, AVPacket *pkt){
2410 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2413 // pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2415 if (pkt->pts != AV_NOPTS_VALUE)
2416 pkt->pts &= pts_mask;
2417 if (pkt->dts != AV_NOPTS_VALUE)
2418 pkt->dts &= pts_mask;
2421 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2425 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2426 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2429 truncate_ts(s->streams[pkt->stream_index], pkt);
2431 ret= s->oformat->write_packet(s, pkt);
2433 ret= url_ferror(s->pb);
2437 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2438 AVPacketList *pktl, **next_point, *this_pktl;
2440 int streams[MAX_STREAMS];
2443 AVStream *st= s->streams[ pkt->stream_index];
2445 // assert(pkt->destruct != av_destruct_packet); //FIXME
2447 this_pktl = av_mallocz(sizeof(AVPacketList));
2448 this_pktl->pkt= *pkt;
2449 if(pkt->destruct == av_destruct_packet)
2450 pkt->destruct= NULL; // not shared -> must keep original from being freed
2452 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2454 next_point = &s->packet_buffer;
2456 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2457 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2458 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2459 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2461 next_point= &(*next_point)->next;
2463 this_pktl->next= *next_point;
2464 *next_point= this_pktl;
2467 memset(streams, 0, sizeof(streams));
2468 pktl= s->packet_buffer;
2470 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2471 if(streams[ pktl->pkt.stream_index ] == 0)
2473 streams[ pktl->pkt.stream_index ]++;
2477 if(s->nb_streams == stream_count || (flush && stream_count)){
2478 pktl= s->packet_buffer;
2481 s->packet_buffer= pktl->next;
2485 av_init_packet(out);
2491 * Interleaves an AVPacket correctly so it can be muxed.
2492 * @param out the interleaved packet will be output here
2493 * @param in the input packet
2494 * @param flush 1 if no further packets are available as input and all
2495 * remaining packets should be output
2496 * @return 1 if a packet was output, 0 if no packet could be output,
2497 * < 0 if an error occured
2499 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2500 if(s->oformat->interleave_packet)
2501 return s->oformat->interleave_packet(s, out, in, flush);
2503 return av_interleave_packet_per_dts(s, out, in, flush);
2506 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2507 AVStream *st= s->streams[ pkt->stream_index];
2509 //FIXME/XXX/HACK drop zero sized packets
2510 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2513 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2514 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2517 if(pkt->dts == AV_NOPTS_VALUE)
2522 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2523 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2526 truncate_ts(s->streams[opkt.stream_index], &opkt);
2527 ret= s->oformat->write_packet(s, &opkt);
2529 av_free_packet(&opkt);
2534 if(url_ferror(s->pb))
2535 return url_ferror(s->pb);
2539 int av_write_trailer(AVFormatContext *s)
2545 ret= av_interleave_packet(s, &pkt, NULL, 1);
2546 if(ret<0) //FIXME cleanup needed for ret<0 ?
2551 truncate_ts(s->streams[pkt.stream_index], &pkt);
2552 ret= s->oformat->write_packet(s, &pkt);
2554 av_free_packet(&pkt);
2558 if(url_ferror(s->pb))
2562 if(s->oformat->write_trailer)
2563 ret = s->oformat->write_trailer(s);
2566 ret=url_ferror(s->pb);
2567 for(i=0;i<s->nb_streams;i++)
2568 av_freep(&s->streams[i]->priv_data);
2569 av_freep(&s->priv_data);
2573 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2576 AVProgram *program=NULL;
2579 for(i=0; i<ac->nb_programs; i++){
2580 if(ac->programs[i]->id != progid)
2582 program = ac->programs[i];
2583 for(j=0; j<program->nb_stream_indexes; j++)
2584 if(program->stream_index[j] == idx)
2587 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2590 program->stream_index = tmp;
2591 program->stream_index[program->nb_stream_indexes++] = idx;
2596 /* "user interface" functions */
2597 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2600 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2601 AVStream *st = ic->streams[i];
2602 int g = ff_gcd(st->time_base.num, st->time_base.den);
2603 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2604 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2605 /* the pid is an important information, so we display it */
2606 /* XXX: add a generic system */
2607 if (flags & AVFMT_SHOW_IDS)
2608 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2609 if (strlen(st->language) > 0)
2610 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2611 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2612 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2613 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2614 if(st->r_frame_rate.den && st->r_frame_rate.num)
2615 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2616 /* else if(st->time_base.den && st->time_base.num)
2617 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2619 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2621 av_log(NULL, AV_LOG_INFO, "\n");
2624 void dump_format(AVFormatContext *ic,
2631 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2632 is_output ? "Output" : "Input",
2634 is_output ? ic->oformat->name : ic->iformat->name,
2635 is_output ? "to" : "from", url);
2637 av_log(NULL, AV_LOG_INFO, " Duration: ");
2638 if (ic->duration != AV_NOPTS_VALUE) {
2639 int hours, mins, secs, us;
2640 secs = ic->duration / AV_TIME_BASE;
2641 us = ic->duration % AV_TIME_BASE;
2646 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2647 (10 * us) / AV_TIME_BASE);
2649 av_log(NULL, AV_LOG_INFO, "N/A");
2651 if (ic->start_time != AV_NOPTS_VALUE) {
2653 av_log(NULL, AV_LOG_INFO, ", start: ");
2654 secs = ic->start_time / AV_TIME_BASE;
2655 us = ic->start_time % AV_TIME_BASE;
2656 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2657 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2659 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2661 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2663 av_log(NULL, AV_LOG_INFO, "N/A");
2665 av_log(NULL, AV_LOG_INFO, "\n");
2667 if(ic->nb_programs) {
2669 for(j=0; j<ic->nb_programs; j++) {
2670 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2671 ic->programs[j]->name ? ic->programs[j]->name : "");
2672 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2673 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2676 for(i=0;i<ic->nb_streams;i++)
2677 dump_stream_format(ic, i, index, is_output);
2680 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2682 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2685 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2687 AVRational frame_rate;
2688 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2689 *frame_rate_num= frame_rate.num;
2690 *frame_rate_den= frame_rate.den;
2695 * Gets the current time in microseconds.
2697 int64_t av_gettime(void)
2700 gettimeofday(&tv,NULL);
2701 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2704 int64_t parse_date(const char *datestr, int duration)
2710 static const char *date_fmt[] = {
2714 static const char *time_fmt[] = {
2724 time_t now = time(0);
2726 len = strlen(datestr);
2728 lastch = datestr[len - 1];
2731 is_utc = (lastch == 'z' || lastch == 'Z');
2733 memset(&dt, 0, sizeof(dt));
2738 /* parse the year-month-day part */
2739 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2740 q = small_strptime(p, date_fmt[i], &dt);
2746 /* if the year-month-day part is missing, then take the
2747 * current year-month-day time */
2752 dt = *localtime(&now);
2754 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2759 if (*p == 'T' || *p == 't' || *p == ' ')
2762 /* parse the hour-minute-second part */
2763 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2764 q = small_strptime(p, time_fmt[i], &dt);
2770 /* parse datestr as a duration */
2775 /* parse datestr as HH:MM:SS */
2776 q = small_strptime(p, time_fmt[0], &dt);
2778 /* parse datestr as S+ */
2779 dt.tm_sec = strtol(p, (char **)&q, 10);
2781 /* the parsing didn't succeed */
2788 /* Now we have all the fields that we can get */
2794 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2796 dt.tm_isdst = -1; /* unknown */
2806 /* parse the .m... part */
2810 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2813 val += n * (*q - '0');
2817 return negative ? -t : t;
2820 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2830 while (*p != '\0' && *p != '=' && *p != '&') {
2831 if ((q - tag) < sizeof(tag) - 1)
2839 while (*p != '&' && *p != '\0') {
2840 if ((q - arg) < arg_size - 1) {
2850 if (!strcmp(tag, tag1))
2859 int av_get_frame_filename(char *buf, int buf_size,
2860 const char *path, int number)
2863 char *q, buf1[20], c;
2864 int nd, len, percentd_found;
2876 while (isdigit(*p)) {
2877 nd = nd * 10 + *p++ - '0';
2880 } while (isdigit(c));
2889 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2891 if ((q - buf + len) > buf_size - 1)
2893 memcpy(q, buf1, len);
2901 if ((q - buf) < buf_size - 1)
2905 if (!percentd_found)
2914 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2917 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2919 for(i=0;i<size;i+=16) {
2926 PRINT(" %02x", buf[i+j]);
2931 for(j=0;j<len;j++) {
2933 if (c < ' ' || c > '~')
2942 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2944 hex_dump_internal(NULL, f, 0, buf, size);
2947 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2949 hex_dump_internal(avcl, NULL, level, buf, size);
2952 //FIXME needs to know the time_base
2953 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2955 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2956 PRINT("stream #%d:\n", pkt->stream_index);
2957 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2958 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2959 /* DTS is _always_ valid after av_read_frame() */
2961 if (pkt->dts == AV_NOPTS_VALUE)
2964 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2965 /* PTS may not be known if B-frames are present. */
2967 if (pkt->pts == AV_NOPTS_VALUE)
2970 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2972 PRINT(" size=%d\n", pkt->size);
2975 av_hex_dump(f, pkt->data, pkt->size);
2978 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2980 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2983 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2985 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2988 void url_split(char *proto, int proto_size,
2989 char *authorization, int authorization_size,
2990 char *hostname, int hostname_size,
2992 char *path, int path_size,
2995 const char *p, *ls, *at, *col, *brk;
2997 if (port_ptr) *port_ptr = -1;
2998 if (proto_size > 0) proto[0] = 0;
2999 if (authorization_size > 0) authorization[0] = 0;
3000 if (hostname_size > 0) hostname[0] = 0;
3001 if (path_size > 0) path[0] = 0;
3003 /* parse protocol */
3004 if ((p = strchr(url, ':'))) {
3005 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3010 /* no protocol means plain filename */
3011 av_strlcpy(path, url, path_size);
3015 /* separate path from hostname */
3016 ls = strchr(p, '/');
3018 ls = strchr(p, '?');
3020 av_strlcpy(path, ls, path_size);
3022 ls = &p[strlen(p)]; // XXX
3024 /* the rest is hostname, use that to parse auth/port */
3026 /* authorization (user[:pass]@hostname) */
3027 if ((at = strchr(p, '@')) && at < ls) {
3028 av_strlcpy(authorization, p,
3029 FFMIN(authorization_size, at + 1 - p));
3030 p = at + 1; /* skip '@' */
3033 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3035 av_strlcpy(hostname, p + 1,
3036 FFMIN(hostname_size, brk - p));
3037 if (brk[1] == ':' && port_ptr)
3038 *port_ptr = atoi(brk + 2);
3039 } else if ((col = strchr(p, ':')) && col < ls) {
3040 av_strlcpy(hostname, p,
3041 FFMIN(col + 1 - p, hostname_size));
3042 if (port_ptr) *port_ptr = atoi(col + 1);
3044 av_strlcpy(hostname, p,
3045 FFMIN(ls + 1 - p, hostname_size));
3049 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3050 int pts_num, int pts_den)
3052 s->pts_wrap_bits = pts_wrap_bits;
3053 s->time_base.num = pts_num;
3054 s->time_base.den = pts_den;
3057 /* fraction handling */
3060 * f = val + (num / den) + 0.5.
3062 * 'num' is normalized so that it is such as 0 <= num < den.
3064 * @param f fractional number
3065 * @param val integer value
3066 * @param num must be >= 0
3067 * @param den must be >= 1
3069 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3082 * Fractional addition to f: f = f + (incr / f->den).
3084 * @param f fractional number
3085 * @param incr increment, can be positive or negative
3087 static void av_frac_add(AVFrac *f, int64_t incr)
3091 num = f->num + incr;
3094 f->val += num / den;
3100 } else if (num >= den) {
3101 f->val += num / den;