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
22 #include "libavcodec/opt.h"
23 #include "libavutil/avstring.h"
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) {
285 }else if (score == *score_max)
291 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
293 return av_probe_input_format2(pd, is_opened, &score);
296 /************************************************************/
297 /* input media file */
300 * Open a media file from an IO stream. 'fmt' must be specified.
302 static const char* format_to_name(void* ptr)
304 AVFormatContext* fc = (AVFormatContext*) ptr;
305 if(fc->iformat) return fc->iformat->name;
306 else if(fc->oformat) return fc->oformat->name;
310 #define OFFSET(x) offsetof(AVFormatContext,x)
311 #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
312 //these names are too long to be readable
313 #define E AV_OPT_FLAG_ENCODING_PARAM
314 #define D AV_OPT_FLAG_DECODING_PARAM
316 static const AVOption options[]={
317 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
318 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
320 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
321 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
322 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
323 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
324 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
325 {"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},
326 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
327 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
328 {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
336 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
338 static void avformat_get_context_defaults(AVFormatContext *s)
340 memset(s, 0, sizeof(AVFormatContext));
342 s->av_class = &av_format_context_class;
344 av_opt_set_defaults(s);
347 AVFormatContext *av_alloc_format_context(void)
350 ic = av_malloc(sizeof(AVFormatContext));
352 avformat_get_context_defaults(ic);
353 ic->av_class = &av_format_context_class;
357 int av_open_input_stream(AVFormatContext **ic_ptr,
358 ByteIOContext *pb, const char *filename,
359 AVInputFormat *fmt, AVFormatParameters *ap)
363 AVFormatParameters default_ap;
367 memset(ap, 0, sizeof(default_ap));
370 if(!ap->prealloced_context)
371 ic = av_alloc_format_context();
375 err = AVERROR(ENOMEM);
380 ic->duration = AV_NOPTS_VALUE;
381 ic->start_time = AV_NOPTS_VALUE;
382 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
384 /* allocate private data */
385 if (fmt->priv_data_size > 0) {
386 ic->priv_data = av_mallocz(fmt->priv_data_size);
387 if (!ic->priv_data) {
388 err = AVERROR(ENOMEM);
392 ic->priv_data = NULL;
395 err = ic->iformat->read_header(ic, ap);
399 if (pb && !ic->data_offset)
400 ic->data_offset = url_ftell(ic->pb);
406 av_freep(&ic->priv_data);
413 /** size of probe buffer, for guessing file type from file contents */
414 #define PROBE_BUF_MIN 2048
415 #define PROBE_BUF_MAX (1<<20)
417 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
420 AVFormatParameters *ap)
423 AVProbeData probe_data, *pd = &probe_data;
424 ByteIOContext *pb = NULL;
428 pd->filename = filename;
433 /* guess format if no file can be opened */
434 fmt = av_probe_input_format(pd, 0);
437 /* Do not open file if the format does not need it. XXX: specific
438 hack needed to handle RTSP/TCP */
439 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
440 /* if no file needed do not try to open one */
441 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
445 url_setbufsize(pb, buf_size);
448 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
449 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
450 /* read probe data */
451 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
452 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
453 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
454 if (url_fseek(pb, 0, SEEK_SET) < 0) {
456 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
462 /* guess file format */
463 fmt = av_probe_input_format2(pd, 1, &score);
468 /* if still no format found, error */
474 /* check filename in case an image number is expected */
475 if (fmt->flags & AVFMT_NEEDNUMBER) {
476 if (!av_filename_number_test(filename)) {
477 err = AVERROR_NUMEXPECTED;
481 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
494 /*******************************************************/
496 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
501 ret= s->iformat->read_packet(s, pkt);
504 st= s->streams[pkt->stream_index];
506 switch(st->codec->codec_type){
507 case CODEC_TYPE_VIDEO:
508 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
510 case CODEC_TYPE_AUDIO:
511 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
513 case CODEC_TYPE_SUBTITLE:
514 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
521 /**********************************************************/
524 * Get the number of samples of an audio frame. Return -1 on error.
526 static int get_audio_frame_size(AVCodecContext *enc, int size)
530 if (enc->frame_size <= 1) {
531 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
533 if (bits_per_sample) {
534 if (enc->channels == 0)
536 frame_size = (size << 3) / (bits_per_sample * enc->channels);
538 /* used for example by ADPCM codecs */
539 if (enc->bit_rate == 0)
541 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
544 frame_size = enc->frame_size;
551 * Return the frame duration in seconds. Return 0 if not available.
553 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
554 AVCodecParserContext *pc, AVPacket *pkt)
560 switch(st->codec->codec_type) {
561 case CODEC_TYPE_VIDEO:
562 if(st->time_base.num*1000LL > st->time_base.den){
563 *pnum = st->time_base.num;
564 *pden = st->time_base.den;
565 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
566 *pnum = st->codec->time_base.num;
567 *pden = st->codec->time_base.den;
568 if (pc && pc->repeat_pict) {
570 *pnum = (*pnum) * (2 + pc->repeat_pict);
574 case CODEC_TYPE_AUDIO:
575 frame_size = get_audio_frame_size(st->codec, pkt->size);
579 *pden = st->codec->sample_rate;
586 static int is_intra_only(AVCodecContext *enc){
587 if(enc->codec_type == CODEC_TYPE_AUDIO){
589 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
590 switch(enc->codec_id){
592 case CODEC_ID_MJPEGB:
594 case CODEC_ID_RAWVIDEO:
595 case CODEC_ID_DVVIDEO:
596 case CODEC_ID_HUFFYUV:
597 case CODEC_ID_FFVHUFF:
608 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
609 int64_t dts, int64_t pts)
611 AVStream *st= s->streams[stream_index];
612 AVPacketList *pktl= s->packet_buffer;
614 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
617 st->first_dts= dts - st->cur_dts;
620 for(; pktl; pktl= pktl->next){
621 if(pktl->pkt.stream_index != stream_index)
623 //FIXME think more about this check
624 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
625 pktl->pkt.pts += st->first_dts;
627 if(pktl->pkt.dts != AV_NOPTS_VALUE)
628 pktl->pkt.dts += st->first_dts;
630 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
631 st->start_time= pktl->pkt.pts;
633 if (st->start_time == AV_NOPTS_VALUE)
634 st->start_time = pts;
637 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
639 AVPacketList *pktl= s->packet_buffer;
641 assert(pkt->duration && !st->cur_dts);
643 for(; pktl; pktl= pktl->next){
644 if(pktl->pkt.stream_index != pkt->stream_index)
646 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
647 && !pktl->pkt.duration){
648 pktl->pkt.pts= pktl->pkt.dts= st->cur_dts;
649 st->cur_dts += pkt->duration;
650 pktl->pkt.duration= pkt->duration;
656 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
657 AVCodecParserContext *pc, AVPacket *pkt)
659 int num, den, presentation_delayed, delay, i;
662 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
663 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
664 pkt->dts -= 1LL<<st->pts_wrap_bits;
667 if (pkt->duration == 0) {
668 compute_frame_duration(&num, &den, st, pc, pkt);
670 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
672 if(st->cur_dts == 0 && pkt->duration != 0)
673 update_initial_durations(s, st, pkt);
677 /* correct timestamps with byte offset if demuxers only have timestamps
678 on packet boundaries */
679 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
680 /* this will estimate bitrate based on this frame's duration and size */
681 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
682 if(pkt->pts != AV_NOPTS_VALUE)
684 if(pkt->dts != AV_NOPTS_VALUE)
688 /* do we have a video B-frame ? */
689 delay= st->codec->has_b_frames;
690 presentation_delayed = 0;
691 /* XXX: need has_b_frame, but cannot get it if the codec is
694 pc && pc->pict_type != FF_B_TYPE)
695 presentation_delayed = 1;
696 /* This may be redundant, but it should not hurt. */
697 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
698 presentation_delayed = 1;
700 if(st->cur_dts == AV_NOPTS_VALUE){
701 st->cur_dts = 0; //FIXME maybe set it to 0 during init
704 // 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);
705 /* interpolate PTS and DTS if they are not present */
707 if (presentation_delayed) {
708 /* DTS = decompression timestamp */
709 /* PTS = presentation timestamp */
710 if (pkt->dts == AV_NOPTS_VALUE)
711 pkt->dts = st->last_IP_pts;
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 if (st->last_IP_duration == 0)
719 st->last_IP_duration = pkt->duration;
720 st->cur_dts = pkt->dts + st->last_IP_duration;
721 st->last_IP_duration = pkt->duration;
722 st->last_IP_pts= pkt->pts;
723 /* cannot compute PTS if not present (we can compute it only
724 by knowing the future */
725 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
726 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
727 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
728 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
729 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
730 pkt->pts += pkt->duration;
731 // 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);
735 /* presentation is not delayed : PTS and DTS are the same */
736 if(pkt->pts == AV_NOPTS_VALUE)
738 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
739 if(pkt->pts == AV_NOPTS_VALUE)
740 pkt->pts = st->cur_dts;
742 st->cur_dts = pkt->pts + pkt->duration;
746 if(pkt->pts != AV_NOPTS_VALUE){
747 st->pts_buffer[0]= pkt->pts;
748 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
749 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
750 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
751 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
752 if(pkt->dts == AV_NOPTS_VALUE)
753 pkt->dts= st->pts_buffer[0];
755 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
757 if(pkt->dts > st->cur_dts)
758 st->cur_dts = pkt->dts;
761 // 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);
764 if(is_intra_only(st->codec))
765 pkt->flags |= PKT_FLAG_KEY;
768 /* keyframe computation */
769 if (pc->pict_type == FF_I_TYPE)
770 pkt->flags |= PKT_FLAG_KEY;
774 void av_destruct_packet_nofree(AVPacket *pkt)
776 pkt->data = NULL; pkt->size = 0;
779 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
787 /* select current input stream component */
790 if (!st->need_parsing || !st->parser) {
791 /* no parsing needed: we just output the packet as is */
792 /* raw data support */
794 compute_pkt_fields(s, st, NULL, pkt);
797 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
798 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
799 s->cur_ptr, s->cur_len,
800 s->cur_pkt.pts, s->cur_pkt.dts);
801 s->cur_pkt.pts = AV_NOPTS_VALUE;
802 s->cur_pkt.dts = AV_NOPTS_VALUE;
803 /* increment read pointer */
807 /* return packet if any */
810 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
812 pkt->stream_index = st->index;
813 pkt->pts = st->parser->pts;
814 pkt->dts = st->parser->dts;
815 pkt->destruct = av_destruct_packet_nofree;
816 compute_pkt_fields(s, st, st->parser, pkt);
818 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
819 ff_reduce_index(s, st->index);
820 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
821 0, 0, AVINDEX_KEYFRAME);
828 av_free_packet(&s->cur_pkt);
832 /* read next packet */
833 ret = av_read_packet(s, &s->cur_pkt);
835 if (ret == AVERROR(EAGAIN))
837 /* return the last frames, if any */
838 for(i = 0; i < s->nb_streams; i++) {
840 if (st->parser && st->need_parsing) {
841 av_parser_parse(st->parser, st->codec,
842 &pkt->data, &pkt->size,
844 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
849 /* no more packets: really terminate parsing */
853 st = s->streams[s->cur_pkt.stream_index];
854 if(st->codec->debug & FF_DEBUG_PTS)
855 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
856 s->cur_pkt.stream_index,
862 s->cur_ptr = s->cur_pkt.data;
863 s->cur_len = s->cur_pkt.size;
864 if (st->need_parsing && !st->parser) {
865 st->parser = av_parser_init(st->codec->codec_id);
867 /* no parser available: just output the raw packets */
868 st->need_parsing = AVSTREAM_PARSE_NONE;
869 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
870 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
872 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
873 st->parser->last_frame_offset=
874 st->parser->cur_offset= s->cur_pkt.pos;
879 if(st->codec->debug & FF_DEBUG_PTS)
880 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
889 static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
890 AVPacketList *pktl= s->packet_buffer;
891 AVPacketList **plast_pktl= &s->packet_buffer;
893 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
895 pktl = av_mallocz(sizeof(AVPacketList));
899 /* add the packet in the buffered packet list */
905 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
909 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
912 pktl = s->packet_buffer;
914 AVPacket *next_pkt= &pktl->pkt;
916 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
917 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
918 if( pktl->pkt.stream_index == next_pkt->stream_index
919 && next_pkt->dts < pktl->pkt.dts
920 && pktl->pkt.pts != pktl->pkt.dts //not b frame
921 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
922 next_pkt->pts= pktl->pkt.dts;
926 pktl = s->packet_buffer;
929 if( next_pkt->pts != AV_NOPTS_VALUE
930 || next_pkt->dts == AV_NOPTS_VALUE
932 /* read packet from packet buffer, if there is data */
934 s->packet_buffer = pktl->next;
940 int ret= av_read_frame_internal(s, pkt);
942 if(pktl && ret != AVERROR(EAGAIN)){
949 if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
950 return AVERROR(ENOMEM);
952 assert(!s->packet_buffer);
953 return av_read_frame_internal(s, pkt);
958 /* XXX: suppress the packet queue */
959 static void flush_packet_queue(AVFormatContext *s)
964 pktl = s->packet_buffer;
967 s->packet_buffer = pktl->next;
968 av_free_packet(&pktl->pkt);
973 /*******************************************************/
976 int av_find_default_stream_index(AVFormatContext *s)
981 if (s->nb_streams <= 0)
983 for(i = 0; i < s->nb_streams; i++) {
985 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
993 * Flush the frame reader.
995 static void av_read_frame_flush(AVFormatContext *s)
1000 flush_packet_queue(s);
1002 /* free previous packet */
1004 if (s->cur_st->parser)
1005 av_free_packet(&s->cur_pkt);
1012 /* for each stream, reset read state */
1013 for(i = 0; i < s->nb_streams; i++) {
1017 av_parser_close(st->parser);
1020 st->last_IP_pts = AV_NOPTS_VALUE;
1021 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1025 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1028 for(i = 0; i < s->nb_streams; i++) {
1029 AVStream *st = s->streams[i];
1031 st->cur_dts = av_rescale(timestamp,
1032 st->time_base.den * (int64_t)ref_st->time_base.num,
1033 st->time_base.num * (int64_t)ref_st->time_base.den);
1037 void ff_reduce_index(AVFormatContext *s, int stream_index)
1039 AVStream *st= s->streams[stream_index];
1040 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1042 if((unsigned)st->nb_index_entries >= max_entries){
1044 for(i=0; 2*i<st->nb_index_entries; i++)
1045 st->index_entries[i]= st->index_entries[2*i];
1046 st->nb_index_entries= i;
1050 int av_add_index_entry(AVStream *st,
1051 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1053 AVIndexEntry *entries, *ie;
1056 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1059 entries = av_fast_realloc(st->index_entries,
1060 &st->index_entries_allocated_size,
1061 (st->nb_index_entries + 1) *
1062 sizeof(AVIndexEntry));
1066 st->index_entries= entries;
1068 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1071 index= st->nb_index_entries++;
1072 ie= &entries[index];
1073 assert(index==0 || ie[-1].timestamp < timestamp);
1075 ie= &entries[index];
1076 if(ie->timestamp != timestamp){
1077 if(ie->timestamp <= timestamp)
1079 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1080 st->nb_index_entries++;
1081 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1082 distance= ie->min_distance;
1086 ie->timestamp = timestamp;
1087 ie->min_distance= distance;
1094 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1097 AVIndexEntry *entries= st->index_entries;
1098 int nb_entries= st->nb_index_entries;
1107 timestamp = entries[m].timestamp;
1108 if(timestamp >= wanted_timestamp)
1110 if(timestamp <= wanted_timestamp)
1113 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1115 if(!(flags & AVSEEK_FLAG_ANY)){
1116 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1117 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1128 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1129 AVInputFormat *avif= s->iformat;
1130 int64_t pos_min, pos_max, pos, pos_limit;
1131 int64_t ts_min, ts_max, ts;
1135 if (stream_index < 0)
1139 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1143 ts_min= AV_NOPTS_VALUE;
1144 pos_limit= -1; //gcc falsely says it may be uninitialized
1146 st= s->streams[stream_index];
1147 if(st->index_entries){
1150 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()
1151 index= FFMAX(index, 0);
1152 e= &st->index_entries[index];
1154 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1156 ts_min= e->timestamp;
1158 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1165 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1166 assert(index < st->nb_index_entries);
1168 e= &st->index_entries[index];
1169 assert(e->timestamp >= target_ts);
1171 ts_max= e->timestamp;
1172 pos_limit= pos_max - e->min_distance;
1174 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1175 pos_max,pos_limit, ts_max);
1180 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1185 url_fseek(s->pb, pos, SEEK_SET);
1187 av_update_cur_dts(s, st, ts);
1192 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 )){
1194 int64_t start_pos, filesize;
1198 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1201 if(ts_min == AV_NOPTS_VALUE){
1202 pos_min = s->data_offset;
1203 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1204 if (ts_min == AV_NOPTS_VALUE)
1208 if(ts_max == AV_NOPTS_VALUE){
1210 filesize = url_fsize(s->pb);
1211 pos_max = filesize - 1;
1214 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1216 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1217 if (ts_max == AV_NOPTS_VALUE)
1221 int64_t tmp_pos= pos_max + 1;
1222 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1223 if(tmp_ts == AV_NOPTS_VALUE)
1227 if(tmp_pos >= filesize)
1233 if(ts_min > ts_max){
1235 }else if(ts_min == ts_max){
1240 while (pos_min < pos_limit) {
1242 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1246 assert(pos_limit <= pos_max);
1249 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1250 // interpolate position (better than dichotomy)
1251 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1252 + pos_min - approximate_keyframe_distance;
1253 }else if(no_change==1){
1254 // bisection, if interpolation failed to change min or max pos last time
1255 pos = (pos_min + pos_limit)>>1;
1257 /* linear search if bisection failed, can only happen if there
1258 are very few or no keyframes between min/max */
1263 else if(pos > pos_limit)
1267 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1273 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);
1275 if(ts == AV_NOPTS_VALUE){
1276 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1279 assert(ts != AV_NOPTS_VALUE);
1280 if (target_ts <= ts) {
1281 pos_limit = start_pos - 1;
1285 if (target_ts >= ts) {
1291 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1292 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1295 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1297 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1298 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1299 pos, ts_min, target_ts, ts_max);
1305 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1306 int64_t pos_min, pos_max;
1310 if (stream_index < 0)
1313 st= s->streams[stream_index];
1316 pos_min = s->data_offset;
1317 pos_max = url_fsize(s->pb) - 1;
1319 if (pos < pos_min) pos= pos_min;
1320 else if(pos > pos_max) pos= pos_max;
1322 url_fseek(s->pb, pos, SEEK_SET);
1325 av_update_cur_dts(s, st, ts);
1330 static int av_seek_frame_generic(AVFormatContext *s,
1331 int stream_index, int64_t timestamp, int flags)
1337 st = s->streams[stream_index];
1339 index = av_index_search_timestamp(st, timestamp, flags);
1341 if(index < 0 || index==st->nb_index_entries-1){
1345 if(st->index_entries && st->nb_index_entries){
1346 ie= &st->index_entries[st->nb_index_entries-1];
1347 url_fseek(s->pb, ie->pos, SEEK_SET);
1348 av_update_cur_dts(s, st, ie->timestamp);
1350 url_fseek(s->pb, 0, SEEK_SET);
1353 int ret = av_read_frame(s, &pkt);
1356 av_free_packet(&pkt);
1357 if(stream_index == pkt.stream_index){
1358 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1362 index = av_index_search_timestamp(st, timestamp, flags);
1367 av_read_frame_flush(s);
1368 if (s->iformat->read_seek){
1369 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1372 ie = &st->index_entries[index];
1373 url_fseek(s->pb, ie->pos, SEEK_SET);
1375 av_update_cur_dts(s, st, ie->timestamp);
1380 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1385 av_read_frame_flush(s);
1387 if(flags & AVSEEK_FLAG_BYTE)
1388 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1390 if(stream_index < 0){
1391 stream_index= av_find_default_stream_index(s);
1392 if(stream_index < 0)
1395 st= s->streams[stream_index];
1396 /* timestamp for default must be expressed in AV_TIME_BASE units */
1397 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1399 st= s->streams[stream_index];
1401 /* first, we try the format specific seek */
1402 if (s->iformat->read_seek)
1403 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1410 if(s->iformat->read_timestamp)
1411 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1413 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1416 /*******************************************************/
1419 * Returns TRUE if the stream has accurate duration in any stream.
1421 * @return TRUE if the stream has accurate duration for at least one component.
1423 static int av_has_duration(AVFormatContext *ic)
1428 for(i = 0;i < ic->nb_streams; i++) {
1429 st = ic->streams[i];
1430 if (st->duration != AV_NOPTS_VALUE)
1437 * Estimate the stream timings from the one of each components.
1439 * Also computes the global bitrate if possible.
1441 static void av_update_stream_timings(AVFormatContext *ic)
1443 int64_t start_time, start_time1, end_time, end_time1;
1444 int64_t duration, duration1;
1448 start_time = INT64_MAX;
1449 end_time = INT64_MIN;
1450 duration = INT64_MIN;
1451 for(i = 0;i < ic->nb_streams; i++) {
1452 st = ic->streams[i];
1453 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1454 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1455 if (start_time1 < start_time)
1456 start_time = start_time1;
1457 if (st->duration != AV_NOPTS_VALUE) {
1458 end_time1 = start_time1
1459 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1460 if (end_time1 > end_time)
1461 end_time = end_time1;
1464 if (st->duration != AV_NOPTS_VALUE) {
1465 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1466 if (duration1 > duration)
1467 duration = duration1;
1470 if (start_time != INT64_MAX) {
1471 ic->start_time = start_time;
1472 if (end_time != INT64_MIN) {
1473 if (end_time - start_time > duration)
1474 duration = end_time - start_time;
1477 if (duration != INT64_MIN) {
1478 ic->duration = duration;
1479 if (ic->file_size > 0) {
1480 /* compute the bitrate */
1481 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1482 (double)ic->duration;
1487 static void fill_all_stream_timings(AVFormatContext *ic)
1492 av_update_stream_timings(ic);
1493 for(i = 0;i < ic->nb_streams; i++) {
1494 st = ic->streams[i];
1495 if (st->start_time == AV_NOPTS_VALUE) {
1496 if(ic->start_time != AV_NOPTS_VALUE)
1497 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1498 if(ic->duration != AV_NOPTS_VALUE)
1499 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1504 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1506 int64_t filesize, duration;
1510 /* if bit_rate is already set, we believe it */
1511 if (ic->bit_rate == 0) {
1513 for(i=0;i<ic->nb_streams;i++) {
1514 st = ic->streams[i];
1515 bit_rate += st->codec->bit_rate;
1517 ic->bit_rate = bit_rate;
1520 /* if duration is already set, we believe it */
1521 if (ic->duration == AV_NOPTS_VALUE &&
1522 ic->bit_rate != 0 &&
1523 ic->file_size != 0) {
1524 filesize = ic->file_size;
1526 for(i = 0; i < ic->nb_streams; i++) {
1527 st = ic->streams[i];
1528 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1529 if (st->duration == AV_NOPTS_VALUE)
1530 st->duration = duration;
1536 #define DURATION_MAX_READ_SIZE 250000
1538 /* only usable for MPEG-PS streams */
1539 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1541 AVPacket pkt1, *pkt = &pkt1;
1543 int read_size, i, ret;
1545 int64_t filesize, offset, duration;
1547 /* free previous packet */
1548 if (ic->cur_st && ic->cur_st->parser)
1549 av_free_packet(&ic->cur_pkt);
1552 /* flush packet queue */
1553 flush_packet_queue(ic);
1555 for(i=0;i<ic->nb_streams;i++) {
1556 st = ic->streams[i];
1558 av_parser_close(st->parser);
1563 /* we read the first packets to get the first PTS (not fully
1564 accurate, but it is enough now) */
1565 url_fseek(ic->pb, 0, SEEK_SET);
1568 if (read_size >= DURATION_MAX_READ_SIZE)
1570 /* if all info is available, we can stop */
1571 for(i = 0;i < ic->nb_streams; i++) {
1572 st = ic->streams[i];
1573 if (st->start_time == AV_NOPTS_VALUE)
1576 if (i == ic->nb_streams)
1579 ret = av_read_packet(ic, pkt);
1582 read_size += pkt->size;
1583 st = ic->streams[pkt->stream_index];
1584 if (pkt->pts != AV_NOPTS_VALUE) {
1585 if (st->start_time == AV_NOPTS_VALUE)
1586 st->start_time = pkt->pts;
1588 av_free_packet(pkt);
1591 /* estimate the end time (duration) */
1592 /* XXX: may need to support wrapping */
1593 filesize = ic->file_size;
1594 offset = filesize - DURATION_MAX_READ_SIZE;
1598 url_fseek(ic->pb, offset, SEEK_SET);
1601 if (read_size >= DURATION_MAX_READ_SIZE)
1604 ret = av_read_packet(ic, pkt);
1607 read_size += pkt->size;
1608 st = ic->streams[pkt->stream_index];
1609 if (pkt->pts != AV_NOPTS_VALUE &&
1610 st->start_time != AV_NOPTS_VALUE) {
1611 end_time = pkt->pts;
1612 duration = end_time - st->start_time;
1614 if (st->duration == AV_NOPTS_VALUE ||
1615 st->duration < duration)
1616 st->duration = duration;
1619 av_free_packet(pkt);
1622 fill_all_stream_timings(ic);
1624 url_fseek(ic->pb, old_offset, SEEK_SET);
1625 for(i=0; i<ic->nb_streams; i++){
1627 st->cur_dts= st->first_dts;
1628 st->last_IP_pts = AV_NOPTS_VALUE;
1632 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1636 /* get the file size, if possible */
1637 if (ic->iformat->flags & AVFMT_NOFILE) {
1640 file_size = url_fsize(ic->pb);
1644 ic->file_size = file_size;
1646 if ((!strcmp(ic->iformat->name, "mpeg") ||
1647 !strcmp(ic->iformat->name, "mpegts")) &&
1648 file_size && !url_is_streamed(ic->pb)) {
1649 /* get accurate estimate from the PTSes */
1650 av_estimate_timings_from_pts(ic, old_offset);
1651 } else if (av_has_duration(ic)) {
1652 /* at least one component has timings - we use them for all
1654 fill_all_stream_timings(ic);
1656 /* less precise: use bitrate info */
1657 av_estimate_timings_from_bit_rate(ic);
1659 av_update_stream_timings(ic);
1665 for(i = 0;i < ic->nb_streams; i++) {
1666 st = ic->streams[i];
1667 printf("%d: start_time: %0.3f duration: %0.3f\n",
1668 i, (double)st->start_time / AV_TIME_BASE,
1669 (double)st->duration / AV_TIME_BASE);
1671 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1672 (double)ic->start_time / AV_TIME_BASE,
1673 (double)ic->duration / AV_TIME_BASE,
1674 ic->bit_rate / 1000);
1679 static int has_codec_parameters(AVCodecContext *enc)
1682 switch(enc->codec_type) {
1683 case CODEC_TYPE_AUDIO:
1684 val = enc->sample_rate;
1686 case CODEC_TYPE_VIDEO:
1687 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1693 return enc->codec_id != CODEC_ID_NONE && val != 0;
1696 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1700 int got_picture, data_size, ret=0;
1703 if(!st->codec->codec){
1704 codec = avcodec_find_decoder(st->codec->codec_id);
1707 ret = avcodec_open(st->codec, codec);
1712 if(!has_codec_parameters(st->codec)){
1713 switch(st->codec->codec_type) {
1714 case CODEC_TYPE_VIDEO:
1715 ret = avcodec_decode_video(st->codec, &picture,
1716 &got_picture, data, size);
1718 case CODEC_TYPE_AUDIO:
1719 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1720 samples = av_malloc(data_size);
1723 ret = avcodec_decode_audio2(st->codec, samples,
1724 &data_size, data, size);
1735 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1738 fmt = av_probe_input_format2(pd, 1, &score);
1741 if (strncmp(fmt->name, "mp3", 3) == 0)
1742 st->codec->codec_id = CODEC_ID_MP3;
1743 else if (strncmp(fmt->name, "ac3", 3) == 0)
1744 st->codec->codec_id = CODEC_ID_AC3;
1749 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1751 while (tags->id != CODEC_ID_NONE) {
1759 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1762 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1763 if(tag == tags[i].tag)
1766 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1767 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1768 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1769 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1770 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1773 return CODEC_ID_NONE;
1776 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1779 for(i=0; tags && tags[i]; i++){
1780 int tag= codec_get_tag(tags[i], id);
1786 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1789 for(i=0; tags && tags[i]; i++){
1790 enum CodecID id= codec_get_id(tags[i], tag);
1791 if(id!=CODEC_ID_NONE) return id;
1793 return CODEC_ID_NONE;
1796 /* absolute maximum size we read until we abort */
1797 #define MAX_READ_SIZE 5000000
1799 #define MAX_STD_TIMEBASES (60*12+5)
1800 static int get_std_framerate(int i){
1801 if(i<60*12) return i*1001;
1802 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1806 * Is the time base unreliable.
1807 * This is a heuristic to balance between quick acceptance of the values in
1808 * the headers vs. some extra checks.
1809 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1810 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1811 * And there are "variable" fps files this needs to detect as well.
1813 static int tb_unreliable(AVCodecContext *c){
1814 if( c->time_base.den >= 101L*c->time_base.num
1815 || c->time_base.den < 5L*c->time_base.num
1816 /* || c->codec_tag == ff_get_fourcc("DIVX")
1817 || c->codec_tag == ff_get_fourcc("XVID")*/
1818 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1823 int av_find_stream_info(AVFormatContext *ic)
1825 int i, count, ret, read_size, j;
1827 AVPacket pkt1, *pkt;
1828 int64_t last_dts[MAX_STREAMS];
1829 int duration_count[MAX_STREAMS]={0};
1830 double (*duration_error)[MAX_STD_TIMEBASES];
1831 offset_t old_offset = url_ftell(ic->pb);
1832 int64_t codec_info_duration[MAX_STREAMS]={0};
1833 int codec_info_nb_frames[MAX_STREAMS]={0};
1834 AVProbeData probe_data[MAX_STREAMS];
1835 int codec_identified[MAX_STREAMS]={0};
1837 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1838 if (!duration_error) return AVERROR(ENOMEM);
1840 for(i=0;i<ic->nb_streams;i++) {
1841 st = ic->streams[i];
1842 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1843 /* if(!st->time_base.num)
1845 if(!st->codec->time_base.num)
1846 st->codec->time_base= st->time_base;
1848 //only for the split stuff
1850 st->parser = av_parser_init(st->codec->codec_id);
1851 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1852 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1857 for(i=0;i<MAX_STREAMS;i++){
1858 last_dts[i]= AV_NOPTS_VALUE;
1861 memset(probe_data, 0, sizeof(probe_data));
1865 /* check if one codec still needs to be handled */
1866 for(i=0;i<ic->nb_streams;i++) {
1867 st = ic->streams[i];
1868 if (!has_codec_parameters(st->codec))
1870 /* variable fps and no guess at the real fps */
1871 if( tb_unreliable(st->codec)
1872 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1874 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1876 if(st->first_dts == AV_NOPTS_VALUE)
1879 if (i == ic->nb_streams) {
1880 /* NOTE: if the format has no header, then we need to read
1881 some packets to get most of the streams, so we cannot
1883 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1884 /* if we found the info for all the codecs, we can stop */
1889 /* we did not get all the codec info, but we read too much data */
1890 if (read_size >= MAX_READ_SIZE) {
1895 /* NOTE: a new stream can be added there if no header in file
1896 (AVFMTCTX_NOHEADER) */
1897 ret = av_read_frame_internal(ic, &pkt1);
1900 ret = -1; /* we could not have all the codec parameters before EOF */
1901 for(i=0;i<ic->nb_streams;i++) {
1902 st = ic->streams[i];
1903 if (!has_codec_parameters(st->codec)){
1905 avcodec_string(buf, sizeof(buf), st->codec, 0);
1906 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1914 pkt= add_to_pktbuf(ic, &pkt1);
1915 if(av_dup_packet(pkt) < 0)
1916 return AVERROR(ENOMEM);
1918 read_size += pkt->size;
1920 st = ic->streams[pkt->stream_index];
1921 if(codec_info_nb_frames[st->index]>1)
1922 codec_info_duration[st->index] += pkt->duration;
1923 if (pkt->duration != 0)
1924 codec_info_nb_frames[st->index]++;
1927 int index= pkt->stream_index;
1928 int64_t last= last_dts[index];
1929 int64_t duration= pkt->dts - last;
1931 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1932 double dur= duration * av_q2d(st->time_base);
1934 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1935 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1936 if(duration_count[index] < 2)
1937 memset(duration_error[index], 0, sizeof(*duration_error));
1938 for(i=1; i<MAX_STD_TIMEBASES; i++){
1939 int framerate= get_std_framerate(i);
1940 int ticks= lrintf(dur*framerate/(1001*12));
1941 double error= dur - ticks*1001*12/(double)framerate;
1942 duration_error[index][i] += error*error;
1944 duration_count[index]++;
1946 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1947 last_dts[pkt->stream_index]= pkt->dts;
1949 if (st->codec->codec_id == CODEC_ID_NONE) {
1950 AVProbeData *pd = &(probe_data[st->index]);
1951 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1952 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1953 pd->buf_size += pkt->size;
1954 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1957 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1958 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1960 st->codec->extradata_size= i;
1961 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1962 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1963 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1967 /* if still no information, we try to open the codec and to
1968 decompress the frame. We try to avoid that in most cases as
1969 it takes longer and uses more memory. For MPEG-4, we need to
1970 decompress for QuickTime. */
1971 if (!has_codec_parameters(st->codec) /*&&
1972 (st->codec->codec_id == CODEC_ID_FLV1 ||
1973 st->codec->codec_id == CODEC_ID_H264 ||
1974 st->codec->codec_id == CODEC_ID_H263 ||
1975 st->codec->codec_id == CODEC_ID_H261 ||
1976 st->codec->codec_id == CODEC_ID_VORBIS ||
1977 st->codec->codec_id == CODEC_ID_MJPEG ||
1978 st->codec->codec_id == CODEC_ID_PNG ||
1979 st->codec->codec_id == CODEC_ID_PAM ||
1980 st->codec->codec_id == CODEC_ID_PGM ||
1981 st->codec->codec_id == CODEC_ID_PGMYUV ||
1982 st->codec->codec_id == CODEC_ID_PBM ||
1983 st->codec->codec_id == CODEC_ID_PPM ||
1984 st->codec->codec_id == CODEC_ID_SHORTEN ||
1985 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1986 try_decode_frame(st, pkt->data, pkt->size);
1988 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) {
1994 // close codecs which were opened in try_decode_frame()
1995 for(i=0;i<ic->nb_streams;i++) {
1996 st = ic->streams[i];
1997 if(st->codec->codec)
1998 avcodec_close(st->codec);
2000 for(i=0;i<ic->nb_streams;i++) {
2001 st = ic->streams[i];
2002 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2003 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2004 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2006 if(duration_count[i]
2007 && tb_unreliable(st->codec) /*&&
2008 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2009 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2010 double best_error= 2*av_q2d(st->time_base);
2011 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2013 for(j=1; j<MAX_STD_TIMEBASES; j++){
2014 double error= duration_error[i][j] * get_std_framerate(j);
2015 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2016 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2017 if(error < best_error){
2019 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2024 if (!st->r_frame_rate.num){
2025 if( st->codec->time_base.den * (int64_t)st->time_base.num
2026 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2027 st->r_frame_rate.num = st->codec->time_base.den;
2028 st->r_frame_rate.den = st->codec->time_base.num;
2030 st->r_frame_rate.num = st->time_base.den;
2031 st->r_frame_rate.den = st->time_base.num;
2034 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2035 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2036 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2037 if (codec_identified[st->index]) {
2038 st->need_parsing = AVSTREAM_PARSE_FULL;
2041 if(!st->codec->bits_per_sample)
2042 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2046 av_estimate_timings(ic, old_offset);
2048 for(i=0;i<ic->nb_streams;i++) {
2049 st = ic->streams[i];
2050 if (codec_identified[st->index])
2053 //FIXME this is a mess
2054 if(i!=ic->nb_streams){
2055 av_read_frame_flush(ic);
2056 for(i=0;i<ic->nb_streams;i++) {
2057 st = ic->streams[i];
2058 if (codec_identified[st->index]) {
2059 av_seek_frame(ic, st->index, 0.0, 0);
2061 st->cur_dts= st->first_dts;
2063 url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2067 /* correct DTS for B-frame streams with no timestamps */
2068 for(i=0;i<ic->nb_streams;i++) {
2069 st = ic->streams[i];
2070 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2072 ppktl = &ic->packet_buffer;
2074 if(ppkt1->stream_index != i)
2076 if(ppkt1->pkt->dts < 0)
2078 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2080 ppkt1->pkt->dts -= delta;
2085 st->cur_dts -= delta;
2091 av_free(duration_error);
2092 for(i=0;i<MAX_STREAMS;i++){
2093 av_freep(&(probe_data[i].buf));
2099 /*******************************************************/
2101 int av_read_play(AVFormatContext *s)
2103 if (s->iformat->read_play)
2104 return s->iformat->read_play(s);
2106 return av_url_read_fpause(s->pb, 0);
2107 return AVERROR(ENOSYS);
2110 int av_read_pause(AVFormatContext *s)
2112 if (s->iformat->read_pause)
2113 return s->iformat->read_pause(s);
2115 return av_url_read_fpause(s->pb, 1);
2116 return AVERROR(ENOSYS);
2119 void av_close_input_stream(AVFormatContext *s)
2124 /* free previous packet */
2125 if (s->cur_st && s->cur_st->parser)
2126 av_free_packet(&s->cur_pkt);
2128 if (s->iformat->read_close)
2129 s->iformat->read_close(s);
2130 for(i=0;i<s->nb_streams;i++) {
2131 /* free all data in a stream component */
2134 av_parser_close(st->parser);
2136 av_free(st->index_entries);
2137 av_free(st->codec->extradata);
2139 av_free(st->filename);
2142 for(i=s->nb_programs-1; i>=0; i--) {
2143 av_freep(&s->programs[i]->provider_name);
2144 av_freep(&s->programs[i]->name);
2145 av_freep(&s->programs[i]->stream_index);
2146 av_freep(&s->programs[i]);
2148 av_freep(&s->programs);
2149 flush_packet_queue(s);
2150 av_freep(&s->priv_data);
2154 void av_close_input_file(AVFormatContext *s)
2156 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2157 av_close_input_stream(s);
2162 AVStream *av_new_stream(AVFormatContext *s, int id)
2167 if (s->nb_streams >= MAX_STREAMS)
2170 st = av_mallocz(sizeof(AVStream));
2174 st->codec= avcodec_alloc_context();
2176 /* no default bitrate if decoding */
2177 st->codec->bit_rate = 0;
2179 st->index = s->nb_streams;
2181 st->start_time = AV_NOPTS_VALUE;
2182 st->duration = AV_NOPTS_VALUE;
2183 st->cur_dts = AV_NOPTS_VALUE;
2184 st->first_dts = AV_NOPTS_VALUE;
2186 /* default pts setting is MPEG-like */
2187 av_set_pts_info(st, 33, 1, 90000);
2188 st->last_IP_pts = AV_NOPTS_VALUE;
2189 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2190 st->pts_buffer[i]= AV_NOPTS_VALUE;
2192 s->streams[s->nb_streams++] = st;
2196 AVProgram *av_new_program(AVFormatContext *ac, int id)
2198 AVProgram *program=NULL;
2202 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2205 for(i=0; i<ac->nb_programs; i++)
2206 if(ac->programs[i]->id == id)
2207 program = ac->programs[i];
2210 program = av_mallocz(sizeof(AVProgram));
2213 dynarray_add(&ac->programs, &ac->nb_programs, program);
2214 program->discard = AVDISCARD_NONE;
2221 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2223 assert(!provider_name == !name);
2225 av_free(program->provider_name);
2226 av_free(program-> name);
2227 program->provider_name = av_strdup(provider_name);
2228 program-> name = av_strdup( name);
2233 /************************************************************/
2234 /* output media file */
2236 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2240 if (s->oformat->priv_data_size > 0) {
2241 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2243 return AVERROR(ENOMEM);
2245 s->priv_data = NULL;
2247 if (s->oformat->set_parameters) {
2248 ret = s->oformat->set_parameters(s, ap);
2255 int av_write_header(AVFormatContext *s)
2260 // some sanity checks
2261 for(i=0;i<s->nb_streams;i++) {
2264 switch (st->codec->codec_type) {
2265 case CODEC_TYPE_AUDIO:
2266 if(st->codec->sample_rate<=0){
2267 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2271 case CODEC_TYPE_VIDEO:
2272 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2273 av_log(s, AV_LOG_ERROR, "time base not set\n");
2276 if(st->codec->width<=0 || st->codec->height<=0){
2277 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2283 if(s->oformat->codec_tag){
2284 if(st->codec->codec_tag){
2286 //check that tag + id is in the table
2287 //if neither is in the table -> OK
2288 //if tag is in the table with another id -> FAIL
2289 //if id is in the table with another tag -> FAIL unless strict < ?
2291 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2295 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2296 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2298 return AVERROR(ENOMEM);
2301 if(s->oformat->write_header){
2302 ret = s->oformat->write_header(s);
2307 /* init PTS generation */
2308 for(i=0;i<s->nb_streams;i++) {
2309 int64_t den = AV_NOPTS_VALUE;
2312 switch (st->codec->codec_type) {
2313 case CODEC_TYPE_AUDIO:
2314 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2316 case CODEC_TYPE_VIDEO:
2317 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2322 if (den != AV_NOPTS_VALUE) {
2324 return AVERROR_INVALIDDATA;
2325 av_frac_init(&st->pts, 0, 0, den);
2331 //FIXME merge with compute_pkt_fields
2332 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2333 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2334 int num, den, frame_size, i;
2336 // 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);
2338 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2341 /* duration field */
2342 if (pkt->duration == 0) {
2343 compute_frame_duration(&num, &den, st, NULL, pkt);
2345 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2349 //XXX/FIXME this is a temporary hack until all encoders output pts
2350 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2352 // pkt->pts= st->cur_dts;
2353 pkt->pts= st->pts.val;
2356 //calculate dts from pts
2357 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2358 st->pts_buffer[0]= pkt->pts;
2359 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2360 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2361 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2362 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2364 pkt->dts= st->pts_buffer[0];
2367 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2368 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2371 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2372 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2376 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2377 st->cur_dts= pkt->dts;
2378 st->pts.val= pkt->dts;
2381 switch (st->codec->codec_type) {
2382 case CODEC_TYPE_AUDIO:
2383 frame_size = get_audio_frame_size(st->codec, pkt->size);
2385 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2386 likely equal to the encoder delay, but it would be better if we
2387 had the real timestamps from the encoder */
2388 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2389 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2392 case CODEC_TYPE_VIDEO:
2393 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2401 static void truncate_ts(AVStream *st, AVPacket *pkt){
2402 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2405 // pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2407 if (pkt->pts != AV_NOPTS_VALUE)
2408 pkt->pts &= pts_mask;
2409 if (pkt->dts != AV_NOPTS_VALUE)
2410 pkt->dts &= pts_mask;
2413 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2417 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2418 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2421 truncate_ts(s->streams[pkt->stream_index], pkt);
2423 ret= s->oformat->write_packet(s, pkt);
2425 ret= url_ferror(s->pb);
2429 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2430 AVPacketList *pktl, **next_point, *this_pktl;
2432 int streams[MAX_STREAMS];
2435 AVStream *st= s->streams[ pkt->stream_index];
2437 // assert(pkt->destruct != av_destruct_packet); //FIXME
2439 this_pktl = av_mallocz(sizeof(AVPacketList));
2440 this_pktl->pkt= *pkt;
2441 if(pkt->destruct == av_destruct_packet)
2442 pkt->destruct= NULL; // not shared -> must keep original from being freed
2444 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2446 next_point = &s->packet_buffer;
2448 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2449 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2450 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2451 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2453 next_point= &(*next_point)->next;
2455 this_pktl->next= *next_point;
2456 *next_point= this_pktl;
2459 memset(streams, 0, sizeof(streams));
2460 pktl= s->packet_buffer;
2462 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2463 if(streams[ pktl->pkt.stream_index ] == 0)
2465 streams[ pktl->pkt.stream_index ]++;
2469 if(s->nb_streams == stream_count || (flush && stream_count)){
2470 pktl= s->packet_buffer;
2473 s->packet_buffer= pktl->next;
2477 av_init_packet(out);
2483 * Interleaves an AVPacket correctly so it can be muxed.
2484 * @param out the interleaved packet will be output here
2485 * @param in the input packet
2486 * @param flush 1 if no further packets are available as input and all
2487 * remaining packets should be output
2488 * @return 1 if a packet was output, 0 if no packet could be output,
2489 * < 0 if an error occurred
2491 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2492 if(s->oformat->interleave_packet)
2493 return s->oformat->interleave_packet(s, out, in, flush);
2495 return av_interleave_packet_per_dts(s, out, in, flush);
2498 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2499 AVStream *st= s->streams[ pkt->stream_index];
2501 //FIXME/XXX/HACK drop zero sized packets
2502 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2505 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2506 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2509 if(pkt->dts == AV_NOPTS_VALUE)
2514 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2515 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2518 truncate_ts(s->streams[opkt.stream_index], &opkt);
2519 ret= s->oformat->write_packet(s, &opkt);
2521 av_free_packet(&opkt);
2526 if(url_ferror(s->pb))
2527 return url_ferror(s->pb);
2531 int av_write_trailer(AVFormatContext *s)
2537 ret= av_interleave_packet(s, &pkt, NULL, 1);
2538 if(ret<0) //FIXME cleanup needed for ret<0 ?
2543 truncate_ts(s->streams[pkt.stream_index], &pkt);
2544 ret= s->oformat->write_packet(s, &pkt);
2546 av_free_packet(&pkt);
2550 if(url_ferror(s->pb))
2554 if(s->oformat->write_trailer)
2555 ret = s->oformat->write_trailer(s);
2558 ret=url_ferror(s->pb);
2559 for(i=0;i<s->nb_streams;i++)
2560 av_freep(&s->streams[i]->priv_data);
2561 av_freep(&s->priv_data);
2565 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2568 AVProgram *program=NULL;
2571 for(i=0; i<ac->nb_programs; i++){
2572 if(ac->programs[i]->id != progid)
2574 program = ac->programs[i];
2575 for(j=0; j<program->nb_stream_indexes; j++)
2576 if(program->stream_index[j] == idx)
2579 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2582 program->stream_index = tmp;
2583 program->stream_index[program->nb_stream_indexes++] = idx;
2588 /* "user interface" functions */
2589 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2592 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2593 AVStream *st = ic->streams[i];
2594 int g = ff_gcd(st->time_base.num, st->time_base.den);
2595 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2596 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2597 /* the pid is an important information, so we display it */
2598 /* XXX: add a generic system */
2599 if (flags & AVFMT_SHOW_IDS)
2600 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2601 if (strlen(st->language) > 0)
2602 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2603 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2604 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2605 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2606 if(st->r_frame_rate.den && st->r_frame_rate.num)
2607 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2608 /* else if(st->time_base.den && st->time_base.num)
2609 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2611 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2613 av_log(NULL, AV_LOG_INFO, "\n");
2616 void dump_format(AVFormatContext *ic,
2623 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2624 is_output ? "Output" : "Input",
2626 is_output ? ic->oformat->name : ic->iformat->name,
2627 is_output ? "to" : "from", url);
2629 av_log(NULL, AV_LOG_INFO, " Duration: ");
2630 if (ic->duration != AV_NOPTS_VALUE) {
2631 int hours, mins, secs, us;
2632 secs = ic->duration / AV_TIME_BASE;
2633 us = ic->duration % AV_TIME_BASE;
2638 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2639 (100 * us) / AV_TIME_BASE);
2641 av_log(NULL, AV_LOG_INFO, "N/A");
2643 if (ic->start_time != AV_NOPTS_VALUE) {
2645 av_log(NULL, AV_LOG_INFO, ", start: ");
2646 secs = ic->start_time / AV_TIME_BASE;
2647 us = ic->start_time % AV_TIME_BASE;
2648 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2649 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2651 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2653 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2655 av_log(NULL, AV_LOG_INFO, "N/A");
2657 av_log(NULL, AV_LOG_INFO, "\n");
2659 if(ic->nb_programs) {
2661 for(j=0; j<ic->nb_programs; j++) {
2662 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2663 ic->programs[j]->name ? ic->programs[j]->name : "");
2664 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2665 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2668 for(i=0;i<ic->nb_streams;i++)
2669 dump_stream_format(ic, i, index, is_output);
2672 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2674 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2677 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2679 AVRational frame_rate;
2680 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2681 *frame_rate_num= frame_rate.num;
2682 *frame_rate_den= frame_rate.den;
2687 * Gets the current time in microseconds.
2689 int64_t av_gettime(void)
2692 gettimeofday(&tv,NULL);
2693 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2696 int64_t parse_date(const char *datestr, int duration)
2702 static const char *date_fmt[] = {
2706 static const char *time_fmt[] = {
2716 time_t now = time(0);
2718 len = strlen(datestr);
2720 lastch = datestr[len - 1];
2723 is_utc = (lastch == 'z' || lastch == 'Z');
2725 memset(&dt, 0, sizeof(dt));
2730 /* parse the year-month-day part */
2731 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2732 q = small_strptime(p, date_fmt[i], &dt);
2738 /* if the year-month-day part is missing, then take the
2739 * current year-month-day time */
2744 dt = *localtime(&now);
2746 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2751 if (*p == 'T' || *p == 't' || *p == ' ')
2754 /* parse the hour-minute-second part */
2755 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2756 q = small_strptime(p, time_fmt[i], &dt);
2762 /* parse datestr as a duration */
2767 /* parse datestr as HH:MM:SS */
2768 q = small_strptime(p, time_fmt[0], &dt);
2770 /* parse datestr as S+ */
2771 dt.tm_sec = strtol(p, (char **)&q, 10);
2773 /* the parsing didn't succeed */
2780 /* Now we have all the fields that we can get */
2786 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2788 dt.tm_isdst = -1; /* unknown */
2798 /* parse the .m... part */
2802 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2805 val += n * (*q - '0');
2809 return negative ? -t : t;
2812 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2822 while (*p != '\0' && *p != '=' && *p != '&') {
2823 if ((q - tag) < sizeof(tag) - 1)
2831 while (*p != '&' && *p != '\0') {
2832 if ((q - arg) < arg_size - 1) {
2842 if (!strcmp(tag, tag1))
2851 int av_get_frame_filename(char *buf, int buf_size,
2852 const char *path, int number)
2855 char *q, buf1[20], c;
2856 int nd, len, percentd_found;
2868 while (isdigit(*p)) {
2869 nd = nd * 10 + *p++ - '0';
2872 } while (isdigit(c));
2881 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2883 if ((q - buf + len) > buf_size - 1)
2885 memcpy(q, buf1, len);
2893 if ((q - buf) < buf_size - 1)
2897 if (!percentd_found)
2906 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2909 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2911 for(i=0;i<size;i+=16) {
2918 PRINT(" %02x", buf[i+j]);
2923 for(j=0;j<len;j++) {
2925 if (c < ' ' || c > '~')
2934 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2936 hex_dump_internal(NULL, f, 0, buf, size);
2939 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2941 hex_dump_internal(avcl, NULL, level, buf, size);
2944 //FIXME needs to know the time_base
2945 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2947 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2948 PRINT("stream #%d:\n", pkt->stream_index);
2949 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2950 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2951 /* DTS is _always_ valid after av_read_frame() */
2953 if (pkt->dts == AV_NOPTS_VALUE)
2956 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2957 /* PTS may not be known if B-frames are present. */
2959 if (pkt->pts == AV_NOPTS_VALUE)
2962 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2964 PRINT(" size=%d\n", pkt->size);
2967 av_hex_dump(f, pkt->data, pkt->size);
2970 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2972 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2975 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2977 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2980 void url_split(char *proto, int proto_size,
2981 char *authorization, int authorization_size,
2982 char *hostname, int hostname_size,
2984 char *path, int path_size,
2987 const char *p, *ls, *at, *col, *brk;
2989 if (port_ptr) *port_ptr = -1;
2990 if (proto_size > 0) proto[0] = 0;
2991 if (authorization_size > 0) authorization[0] = 0;
2992 if (hostname_size > 0) hostname[0] = 0;
2993 if (path_size > 0) path[0] = 0;
2995 /* parse protocol */
2996 if ((p = strchr(url, ':'))) {
2997 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3002 /* no protocol means plain filename */
3003 av_strlcpy(path, url, path_size);
3007 /* separate path from hostname */
3008 ls = strchr(p, '/');
3010 ls = strchr(p, '?');
3012 av_strlcpy(path, ls, path_size);
3014 ls = &p[strlen(p)]; // XXX
3016 /* the rest is hostname, use that to parse auth/port */
3018 /* authorization (user[:pass]@hostname) */
3019 if ((at = strchr(p, '@')) && at < ls) {
3020 av_strlcpy(authorization, p,
3021 FFMIN(authorization_size, at + 1 - p));
3022 p = at + 1; /* skip '@' */
3025 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3027 av_strlcpy(hostname, p + 1,
3028 FFMIN(hostname_size, brk - p));
3029 if (brk[1] == ':' && port_ptr)
3030 *port_ptr = atoi(brk + 2);
3031 } else if ((col = strchr(p, ':')) && col < ls) {
3032 av_strlcpy(hostname, p,
3033 FFMIN(col + 1 - p, hostname_size));
3034 if (port_ptr) *port_ptr = atoi(col + 1);
3036 av_strlcpy(hostname, p,
3037 FFMIN(ls + 1 - p, hostname_size));
3041 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3042 int pts_num, int pts_den)
3044 s->pts_wrap_bits = pts_wrap_bits;
3045 s->time_base.num = pts_num;
3046 s->time_base.den = pts_den;
3049 /* fraction handling */
3052 * f = val + (num / den) + 0.5.
3054 * 'num' is normalized so that it is such as 0 <= num < den.
3056 * @param f fractional number
3057 * @param val integer value
3058 * @param num must be >= 0
3059 * @param den must be >= 1
3061 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3074 * Fractional addition to f: f = f + (incr / f->den).
3076 * @param f fractional number
3077 * @param incr increment, can be positive or negative
3079 static void av_frac_add(AVFrac *f, int64_t incr)
3083 num = f->num + incr;
3086 f->val += num / den;
3092 } else if (num >= den) {
3093 f->val += num / den;