2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "allformats.h"
26 * @file libavformat/utils.c
27 * Various utility functions for using ffmpeg library.
30 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
31 static void av_frac_add(AVFrac *f, int64_t incr);
32 static void av_frac_set(AVFrac *f, int64_t val);
34 /** head of registered input format linked list. */
35 AVInputFormat *first_iformat = NULL;
36 /** head of registered output format linked list. */
37 AVOutputFormat *first_oformat = NULL;
38 /** head of registered image format linked list. */
39 AVImageFormat *first_image_format = NULL;
41 void av_register_input_format(AVInputFormat *format)
45 while (*p != NULL) p = &(*p)->next;
50 void av_register_output_format(AVOutputFormat *format)
54 while (*p != NULL) p = &(*p)->next;
59 int match_ext(const char *filename, const char *extensions)
67 ext = strrchr(filename, '.');
73 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
76 if (!strcasecmp(ext1, ext))
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
89 AVOutputFormat *fmt, *fmt_found;
92 /* specific test for image sequences */
93 #ifdef CONFIG_IMAGE2_MUXER
94 if (!short_name && filename &&
95 filename_number_test(filename) >= 0 &&
96 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97 return guess_format("image2", NULL, NULL);
100 if (!short_name && filename &&
101 filename_number_test(filename) >= 0 &&
102 guess_image_format(filename)) {
103 return guess_format("image", NULL, NULL);
106 /* find the proper file type */
110 while (fmt != NULL) {
112 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
114 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
116 if (filename && fmt->extensions &&
117 match_ext(filename, fmt->extensions)) {
120 if (score > score_max) {
129 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
130 const char *mime_type)
132 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
135 AVOutputFormat *stream_fmt;
136 char stream_format_name[64];
138 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
139 stream_fmt = guess_format(stream_format_name, NULL, NULL);
149 * Guesses the codec id based upon muxer and filename.
151 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
152 const char *filename, const char *mime_type, enum CodecType type){
153 if(type == CODEC_TYPE_VIDEO){
154 enum CodecID codec_id= CODEC_ID_NONE;
156 #ifdef CONFIG_IMAGE2_MUXER
157 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
158 codec_id= av_guess_image2_codec(filename);
161 if(codec_id == CODEC_ID_NONE)
162 codec_id= fmt->video_codec;
164 }else if(type == CODEC_TYPE_AUDIO)
165 return fmt->audio_codec;
167 return CODEC_ID_NONE;
171 * finds AVInputFormat based on input format's short name.
173 AVInputFormat *av_find_input_format(const char *short_name)
176 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
177 if (!strcmp(fmt->name, short_name))
183 /* memory handling */
186 * Default packet destructor.
188 void av_destruct_packet(AVPacket *pkt)
191 pkt->data = NULL; pkt->size = 0;
195 * Allocate the payload of a packet and intialized its fields to default values.
198 * @param size wanted payload size
199 * @return 0 if OK. AVERROR_xxx otherwise.
201 int av_new_packet(AVPacket *pkt, int size)
204 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
205 return AVERROR_NOMEM;
206 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
208 return AVERROR_NOMEM;
209 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
214 pkt->destruct = av_destruct_packet;
219 * Allocate and read the payload of a packet and intialized its fields to default values.
222 * @param size wanted payload size
223 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
225 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
227 int ret= av_new_packet(pkt, size);
232 pkt->pos= url_ftell(s);
234 ret= get_buffer(s, pkt->data, size);
243 /* This is a hack - the packet memory allocation stuff is broken. The
244 packet is allocated if it was not really allocated */
245 int av_dup_packet(AVPacket *pkt)
247 if (pkt->destruct != av_destruct_packet) {
249 /* we duplicate the packet and don't forget to put the padding
251 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
252 return AVERROR_NOMEM;
253 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
255 return AVERROR_NOMEM;
257 memcpy(data, pkt->data, pkt->size);
258 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
260 pkt->destruct = av_destruct_packet;
267 int fifo_init(FifoBuffer *f, int size)
269 f->buffer = av_malloc(size);
272 f->end = f->buffer + size;
273 f->wptr = f->rptr = f->buffer;
277 void fifo_free(FifoBuffer *f)
282 int fifo_size(FifoBuffer *f, uint8_t *rptr)
289 if (f->wptr >= rptr) {
290 size = f->wptr - rptr;
292 size = (f->end - rptr) + (f->wptr - f->buffer);
298 * Get data from the fifo (returns -1 if not enough data).
300 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
309 if (f->wptr >= rptr) {
310 size = f->wptr - rptr;
312 size = (f->end - rptr) + (f->wptr - f->buffer);
317 while (buf_size > 0) {
321 memcpy(buf, rptr, len);
335 void fifo_realloc(FifoBuffer *f, unsigned int new_size){
336 unsigned int old_size= f->end - f->buffer;
338 if(old_size < new_size){
339 uint8_t *old= f->buffer;
341 f->buffer= av_realloc(f->buffer, new_size);
343 f->rptr += f->buffer - old;
344 f->wptr += f->buffer - old;
346 if(f->wptr < f->rptr){
347 memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
348 f->rptr += new_size - old_size;
350 f->end= f->buffer + new_size;
354 void fifo_write(FifoBuffer *f, const uint8_t *buf, int size, uint8_t **wptr_ptr)
367 memcpy(wptr, buf, len);
377 /* get data from the fifo (return -1 if not enough data) */
378 int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
380 uint8_t *rptr = *rptr_ptr;
383 if (f->wptr >= rptr) {
384 size = f->wptr - rptr;
386 size = (f->end - rptr) + (f->wptr - f->buffer);
391 while (buf_size > 0) {
395 put_buffer(pb, rptr, len);
405 int filename_number_test(const char *filename)
410 return get_frame_filename(buf, sizeof(buf), filename, 1);
416 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
418 AVInputFormat *fmt1, *fmt;
419 int score, score_max;
423 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
424 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
427 if (fmt1->read_probe) {
428 score = fmt1->read_probe(pd);
429 } else if (fmt1->extensions) {
430 if (match_ext(pd->filename, fmt1->extensions)) {
434 if (score > score_max) {
442 /************************************************************/
443 /* input media file */
446 * Open a media file from an IO stream. 'fmt' must be specified.
448 static const char* format_to_name(void* ptr)
450 AVFormatContext* fc = (AVFormatContext*) ptr;
451 if(fc->iformat) return fc->iformat->name;
452 else if(fc->oformat) return fc->oformat->name;
456 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
458 AVFormatContext *av_alloc_format_context(void)
461 ic = av_mallocz(sizeof(AVFormatContext));
463 ic->av_class = &av_format_context_class;
468 * Allocates all the structures needed to read an input stream.
469 * This does not open the needed codecs for decoding the stream[s].
471 int av_open_input_stream(AVFormatContext **ic_ptr,
472 ByteIOContext *pb, const char *filename,
473 AVInputFormat *fmt, AVFormatParameters *ap)
477 AVFormatParameters default_ap;
481 memset(ap, 0, sizeof(default_ap));
484 ic = av_alloc_format_context();
492 ic->duration = AV_NOPTS_VALUE;
493 ic->start_time = AV_NOPTS_VALUE;
494 pstrcpy(ic->filename, sizeof(ic->filename), filename);
496 /* allocate private data */
497 if (fmt->priv_data_size > 0) {
498 ic->priv_data = av_mallocz(fmt->priv_data_size);
499 if (!ic->priv_data) {
504 ic->priv_data = NULL;
507 err = ic->iformat->read_header(ic, ap);
512 ic->data_offset = url_ftell(&ic->pb);
518 av_freep(&ic->priv_data);
525 /** Size of probe buffer, for guessing file type from file contents. */
526 #define PROBE_BUF_MIN 2048
527 #define PROBE_BUF_MAX (1<<20)
530 * Open a media file as input. The codec are not opened. Only the file
531 * header (if present) is read.
533 * @param ic_ptr the opened media file handle is put here
534 * @param filename filename to open.
535 * @param fmt if non NULL, force the file format to use
536 * @param buf_size optional buffer size (zero if default is OK)
537 * @param ap additionnal parameters needed when opening the file (NULL if default)
538 * @return 0 if OK. AVERROR_xxx otherwise.
540 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
543 AVFormatParameters *ap)
545 int err, must_open_file, file_opened, probe_size;
546 AVProbeData probe_data, *pd = &probe_data;
547 ByteIOContext pb1, *pb = &pb1;
552 pd->filename = filename;
557 /* guess format if no file can be opened */
558 fmt = av_probe_input_format(pd, 0);
561 /* do not open file if the format does not need it. XXX: specific
562 hack needed to handle RTSP/TCP */
564 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
566 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
569 if (!fmt || must_open_file) {
570 /* if no file needed do not try to open one */
571 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
577 url_setbufsize(pb, buf_size);
580 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
581 /* read probe data */
582 pd->buf= av_realloc(pd->buf, probe_size);
583 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
584 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
586 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
592 /* guess file format */
593 fmt = av_probe_input_format(pd, 1);
598 /* if still no format found, error */
604 /* XXX: suppress this hack for redirectors */
605 #ifdef CONFIG_NETWORK
606 if (fmt == &redir_demuxer) {
607 err = redir_open(ic_ptr, pb);
613 /* check filename in case of an image number is expected */
614 if (fmt->flags & AVFMT_NEEDNUMBER) {
615 if (filename_number_test(filename) < 0) {
616 err = AVERROR_NUMEXPECTED;
620 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
633 /*******************************************************/
636 * Read a transport packet from a media file.
638 * This function is absolete and should never be used.
639 * Use av_read_frame() instead.
641 * @param s media file handle
642 * @param pkt is filled
643 * @return 0 if OK. AVERROR_xxx if error.
645 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
647 return s->iformat->read_packet(s, pkt);
650 /**********************************************************/
653 * Get the number of samples of an audio frame. Return (-1) if error.
655 static int get_audio_frame_size(AVCodecContext *enc, int size)
659 if (enc->frame_size <= 1) {
660 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
662 if (bits_per_sample) {
663 if (enc->channels == 0)
665 frame_size = (size << 3) / (bits_per_sample * enc->channels);
667 /* used for example by ADPCM codecs */
668 if (enc->bit_rate == 0)
670 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
673 frame_size = enc->frame_size;
680 * Return the frame duration in seconds, return 0 if not available.
682 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
683 AVCodecParserContext *pc, AVPacket *pkt)
689 switch(st->codec->codec_type) {
690 case CODEC_TYPE_VIDEO:
691 if(st->time_base.num*1000LL > st->time_base.den){
692 *pnum = st->time_base.num;
693 *pden = st->time_base.den;
694 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
695 *pnum = st->codec->time_base.num;
696 *pden = st->codec->time_base.den;
697 if (pc && pc->repeat_pict) {
699 *pnum = (*pnum) * (2 + pc->repeat_pict);
703 case CODEC_TYPE_AUDIO:
704 frame_size = get_audio_frame_size(st->codec, pkt->size);
708 *pden = st->codec->sample_rate;
715 static int is_intra_only(AVCodecContext *enc){
716 if(enc->codec_type == CODEC_TYPE_AUDIO){
718 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
719 switch(enc->codec_id){
721 case CODEC_ID_MJPEGB:
723 case CODEC_ID_RAWVIDEO:
724 case CODEC_ID_DVVIDEO:
725 case CODEC_ID_HUFFYUV:
726 case CODEC_ID_FFVHUFF:
737 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
738 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
739 int64_t delta= last_ts - mask/2;
740 return ((lsb - delta)&mask) + delta;
743 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
744 AVCodecParserContext *pc, AVPacket *pkt)
746 int num, den, presentation_delayed;
747 /* handle wrapping */
748 if(st->cur_dts != AV_NOPTS_VALUE){
749 if(pkt->pts != AV_NOPTS_VALUE)
750 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
751 if(pkt->dts != AV_NOPTS_VALUE)
752 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
755 if (pkt->duration == 0) {
756 compute_frame_duration(&num, &den, st, pc, pkt);
758 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
762 if(is_intra_only(st->codec))
763 pkt->flags |= PKT_FLAG_KEY;
765 /* do we have a video B frame ? */
766 presentation_delayed = 0;
767 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
768 /* XXX: need has_b_frame, but cannot get it if the codec is
770 if (( st->codec->codec_id == CODEC_ID_H264
771 || st->codec->has_b_frames) &&
772 pc && pc->pict_type != FF_B_TYPE)
773 presentation_delayed = 1;
774 /* this may be redundant, but it shouldnt hurt */
775 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776 presentation_delayed = 1;
779 if(st->cur_dts == AV_NOPTS_VALUE){
780 if(presentation_delayed) st->cur_dts = -pkt->duration;
781 else st->cur_dts = 0;
784 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
785 /* interpolate PTS and DTS if they are not present */
786 if (presentation_delayed) {
787 /* DTS = decompression time stamp */
788 /* PTS = presentation time stamp */
789 if (pkt->dts == AV_NOPTS_VALUE) {
790 /* if we know the last pts, use it */
791 if(st->last_IP_pts != AV_NOPTS_VALUE)
792 st->cur_dts = pkt->dts = st->last_IP_pts;
794 pkt->dts = st->cur_dts;
796 st->cur_dts = pkt->dts;
798 /* this is tricky: the dts must be incremented by the duration
799 of the frame we are displaying, i.e. the last I or P frame */
800 if (st->last_IP_duration == 0)
801 st->cur_dts += pkt->duration;
803 st->cur_dts += st->last_IP_duration;
804 st->last_IP_duration = pkt->duration;
805 st->last_IP_pts= pkt->pts;
806 /* cannot compute PTS if not present (we can compute it only
807 by knowing the futur */
808 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
809 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
810 int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
811 int64_t new_diff= ABS(st->cur_dts - pkt->pts);
812 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
813 pkt->pts += pkt->duration;
814 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
818 /* presentation is not delayed : PTS and DTS are the same */
819 if (pkt->pts == AV_NOPTS_VALUE) {
820 if (pkt->dts == AV_NOPTS_VALUE) {
821 pkt->pts = st->cur_dts;
822 pkt->dts = st->cur_dts;
825 st->cur_dts = pkt->dts;
829 st->cur_dts = pkt->pts;
832 st->cur_dts += pkt->duration;
834 // av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
839 /* key frame computation */
840 switch(st->codec->codec_type) {
841 case CODEC_TYPE_VIDEO:
842 if (pc->pict_type == FF_I_TYPE)
843 pkt->flags |= PKT_FLAG_KEY;
845 case CODEC_TYPE_AUDIO:
846 pkt->flags |= PKT_FLAG_KEY;
854 void av_destruct_packet_nofree(AVPacket *pkt)
856 pkt->data = NULL; pkt->size = 0;
859 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
865 /* select current input stream component */
868 if (!st->need_parsing || !st->parser) {
869 /* no parsing needed: we just output the packet as is */
870 /* raw data support */
872 compute_pkt_fields(s, st, NULL, pkt);
875 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
876 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
877 s->cur_ptr, s->cur_len,
878 s->cur_pkt.pts, s->cur_pkt.dts);
879 s->cur_pkt.pts = AV_NOPTS_VALUE;
880 s->cur_pkt.dts = AV_NOPTS_VALUE;
881 /* increment read pointer */
885 /* return packet if any */
889 pkt->stream_index = st->index;
890 pkt->pts = st->parser->pts;
891 pkt->dts = st->parser->dts;
892 pkt->destruct = av_destruct_packet_nofree;
893 compute_pkt_fields(s, st, st->parser, pkt);
898 av_free_packet(&s->cur_pkt);
902 /* read next packet */
903 ret = av_read_packet(s, &s->cur_pkt);
907 /* return the last frames, if any */
908 for(i = 0; i < s->nb_streams; i++) {
910 if (st->parser && st->need_parsing) {
911 av_parser_parse(st->parser, st->codec,
912 &pkt->data, &pkt->size,
914 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
919 /* no more packets: really terminates parsing */
923 st = s->streams[s->cur_pkt.stream_index];
926 s->cur_ptr = s->cur_pkt.data;
927 s->cur_len = s->cur_pkt.size;
928 if (st->need_parsing && !st->parser) {
929 st->parser = av_parser_init(st->codec->codec_id);
931 /* no parser available : just output the raw packets */
932 st->need_parsing = 0;
933 }else if(st->need_parsing == 2){
934 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
942 * Return the next frame of a stream.
944 * The returned packet is valid
945 * until the next av_read_frame() or until av_close_input_file() and
946 * must be freed with av_free_packet. For video, the packet contains
947 * exactly one frame. For audio, it contains an integer number of
948 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
949 * data). If the audio frames have a variable size (e.g. MPEG audio),
950 * then it contains one frame.
952 * pkt->pts, pkt->dts and pkt->duration are always set to correct
953 * values in AV_TIME_BASE unit (and guessed if the format cannot
954 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
955 * has B frames, so it is better to rely on pkt->dts if you do not
956 * decompress the payload.
958 * @return 0 if OK, < 0 if error or end of file.
960 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
964 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
967 pktl = s->packet_buffer;
969 AVPacket *next_pkt= &pktl->pkt;
971 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
972 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
973 if( pktl->pkt.stream_index == next_pkt->stream_index
974 && next_pkt->dts < pktl->pkt.dts
975 && pktl->pkt.pts != pktl->pkt.dts //not b frame
976 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
977 next_pkt->pts= pktl->pkt.dts;
981 pktl = s->packet_buffer;
984 if( next_pkt->pts != AV_NOPTS_VALUE
985 || next_pkt->dts == AV_NOPTS_VALUE
987 /* read packet from packet buffer, if there is data */
989 s->packet_buffer = pktl->next;
995 AVPacketList **plast_pktl= &s->packet_buffer;
996 int ret= av_read_frame_internal(s, pkt);
998 if(pktl && ret != -EAGAIN){
1005 /* duplicate the packet */
1006 if (av_dup_packet(pkt) < 0)
1007 return AVERROR_NOMEM;
1009 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1011 pktl = av_mallocz(sizeof(AVPacketList));
1013 return AVERROR_NOMEM;
1015 /* add the packet in the buffered packet list */
1019 assert(!s->packet_buffer);
1020 return av_read_frame_internal(s, pkt);
1025 /* XXX: suppress the packet queue */
1026 static void flush_packet_queue(AVFormatContext *s)
1031 pktl = s->packet_buffer;
1034 s->packet_buffer = pktl->next;
1035 av_free_packet(&pktl->pkt);
1040 /*******************************************************/
1043 int av_find_default_stream_index(AVFormatContext *s)
1048 if (s->nb_streams <= 0)
1050 for(i = 0; i < s->nb_streams; i++) {
1052 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1060 * Flush the frame reader.
1062 static void av_read_frame_flush(AVFormatContext *s)
1067 flush_packet_queue(s);
1069 /* free previous packet */
1071 if (s->cur_st->parser)
1072 av_free_packet(&s->cur_pkt);
1079 /* for each stream, reset read state */
1080 for(i = 0; i < s->nb_streams; i++) {
1084 av_parser_close(st->parser);
1087 st->last_IP_pts = AV_NOPTS_VALUE;
1088 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1093 * Updates cur_dts of all streams based on given timestamp and AVStream.
1095 * Stream ref_st unchanged, others set cur_dts in their native timebase
1096 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1097 * @param timestamp new dts expressed in time_base of param ref_st
1098 * @param ref_st reference stream giving time_base of param timestamp
1100 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1103 for(i = 0; i < s->nb_streams; i++) {
1104 AVStream *st = s->streams[i];
1106 st->cur_dts = av_rescale(timestamp,
1107 st->time_base.den * (int64_t)ref_st->time_base.num,
1108 st->time_base.num * (int64_t)ref_st->time_base.den);
1113 * Add a index entry into a sorted list updateing if it is already there.
1115 * @param timestamp timestamp in the timebase of the given stream
1117 int av_add_index_entry(AVStream *st,
1118 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1120 AVIndexEntry *entries, *ie;
1123 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1126 entries = av_fast_realloc(st->index_entries,
1127 &st->index_entries_allocated_size,
1128 (st->nb_index_entries + 1) *
1129 sizeof(AVIndexEntry));
1133 st->index_entries= entries;
1135 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1138 index= st->nb_index_entries++;
1139 ie= &entries[index];
1140 assert(index==0 || ie[-1].timestamp < timestamp);
1142 ie= &entries[index];
1143 if(ie->timestamp != timestamp){
1144 if(ie->timestamp <= timestamp)
1146 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1147 st->nb_index_entries++;
1148 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1149 distance= ie->min_distance;
1153 ie->timestamp = timestamp;
1154 ie->min_distance= distance;
1162 * build an index for raw streams using a parser.
1164 static void av_build_index_raw(AVFormatContext *s)
1166 AVPacket pkt1, *pkt = &pkt1;
1171 av_read_frame_flush(s);
1172 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1175 ret = av_read_frame(s, pkt);
1178 if (pkt->stream_index == 0 && st->parser &&
1179 (pkt->flags & PKT_FLAG_KEY)) {
1180 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1181 0, 0, AVINDEX_KEYFRAME);
1183 av_free_packet(pkt);
1188 * Returns TRUE if we deal with a raw stream.
1190 * Raw codec data and parsing needed.
1192 static int is_raw_stream(AVFormatContext *s)
1196 if (s->nb_streams != 1)
1199 if (!st->need_parsing)
1205 * Gets the index for a specific timestamp.
1206 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1207 * the timestamp which is <= the requested one, if backward is 0
1208 * then it will be >=
1209 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1210 * @return < 0 if no such timestamp could be found
1212 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1215 AVIndexEntry *entries= st->index_entries;
1216 int nb_entries= st->nb_index_entries;
1225 timestamp = entries[m].timestamp;
1226 if(timestamp >= wanted_timestamp)
1228 if(timestamp <= wanted_timestamp)
1231 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1233 if(!(flags & AVSEEK_FLAG_ANY)){
1234 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1235 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1247 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1248 * this isnt supposed to be called directly by a user application, but by demuxers
1249 * @param target_ts target timestamp in the time base of the given stream
1250 * @param stream_index stream number
1252 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1253 AVInputFormat *avif= s->iformat;
1254 int64_t pos_min, pos_max, pos, pos_limit;
1255 int64_t ts_min, ts_max, ts;
1256 int64_t start_pos, filesize;
1257 int index, no_change;
1260 if (stream_index < 0)
1264 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1268 ts_min= AV_NOPTS_VALUE;
1269 pos_limit= -1; //gcc falsely says it may be uninitalized
1271 st= s->streams[stream_index];
1272 if(st->index_entries){
1275 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()
1276 index= FFMAX(index, 0);
1277 e= &st->index_entries[index];
1279 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1281 ts_min= e->timestamp;
1283 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1290 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1291 assert(index < st->nb_index_entries);
1293 e= &st->index_entries[index];
1294 assert(e->timestamp >= target_ts);
1296 ts_max= e->timestamp;
1297 pos_limit= pos_max - e->min_distance;
1299 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1300 pos_max,pos_limit, ts_max);
1305 if(ts_min == AV_NOPTS_VALUE){
1306 pos_min = s->data_offset;
1307 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1308 if (ts_min == AV_NOPTS_VALUE)
1312 if(ts_max == AV_NOPTS_VALUE){
1314 filesize = url_fsize(&s->pb);
1315 pos_max = filesize - 1;
1318 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1320 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1321 if (ts_max == AV_NOPTS_VALUE)
1325 int64_t tmp_pos= pos_max + 1;
1326 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1327 if(tmp_ts == AV_NOPTS_VALUE)
1331 if(tmp_pos >= filesize)
1337 if(ts_min > ts_max){
1339 }else if(ts_min == ts_max){
1344 while (pos_min < pos_limit) {
1346 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1350 assert(pos_limit <= pos_max);
1353 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1354 // interpolate position (better than dichotomy)
1355 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1356 + pos_min - approximate_keyframe_distance;
1357 }else if(no_change==1){
1358 // bisection, if interpolation failed to change min or max pos last time
1359 pos = (pos_min + pos_limit)>>1;
1361 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1366 else if(pos > pos_limit)
1370 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1376 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);
1378 assert(ts != AV_NOPTS_VALUE);
1379 if (target_ts <= ts) {
1380 pos_limit = start_pos - 1;
1384 if (target_ts >= ts) {
1390 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1391 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1394 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1396 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1397 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1398 pos, ts_min, target_ts, ts_max);
1401 url_fseek(&s->pb, pos, SEEK_SET);
1403 av_update_cur_dts(s, st, ts);
1408 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1409 int64_t pos_min, pos_max;
1413 if (stream_index < 0)
1416 st= s->streams[stream_index];
1419 pos_min = s->data_offset;
1420 pos_max = url_fsize(&s->pb) - 1;
1422 if (pos < pos_min) pos= pos_min;
1423 else if(pos > pos_max) pos= pos_max;
1425 url_fseek(&s->pb, pos, SEEK_SET);
1428 av_update_cur_dts(s, st, ts);
1433 static int av_seek_frame_generic(AVFormatContext *s,
1434 int stream_index, int64_t timestamp, int flags)
1440 if (!s->index_built) {
1441 if (is_raw_stream(s)) {
1442 av_build_index_raw(s);
1449 st = s->streams[stream_index];
1450 index = av_index_search_timestamp(st, timestamp, flags);
1454 /* now we have found the index, we can seek */
1455 ie = &st->index_entries[index];
1456 av_read_frame_flush(s);
1457 url_fseek(&s->pb, ie->pos, SEEK_SET);
1459 av_update_cur_dts(s, st, ie->timestamp);
1465 * Seek to the key frame at timestamp.
1466 * 'timestamp' in 'stream_index'.
1467 * @param stream_index If stream_index is (-1), a default
1468 * stream is selected, and timestamp is automatically converted
1469 * from AV_TIME_BASE units to the stream specific time_base.
1470 * @param timestamp timestamp in AVStream.time_base units
1471 * or if there is no stream specified then in AV_TIME_BASE units
1472 * @param flags flags which select direction and seeking mode
1473 * @return >= 0 on success
1475 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1480 av_read_frame_flush(s);
1482 if(flags & AVSEEK_FLAG_BYTE)
1483 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1485 if(stream_index < 0){
1486 stream_index= av_find_default_stream_index(s);
1487 if(stream_index < 0)
1490 st= s->streams[stream_index];
1491 /* timestamp for default must be expressed in AV_TIME_BASE units */
1492 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1494 st= s->streams[stream_index];
1496 /* first, we try the format specific seek */
1497 if (s->iformat->read_seek)
1498 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1505 if(s->iformat->read_timestamp)
1506 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1508 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1511 /*******************************************************/
1514 * Returns TRUE if the stream has accurate timings in any stream.
1516 * @return TRUE if the stream has accurate timings for at least one component.
1518 static int av_has_timings(AVFormatContext *ic)
1523 for(i = 0;i < ic->nb_streams; i++) {
1524 st = ic->streams[i];
1525 if (st->start_time != AV_NOPTS_VALUE &&
1526 st->duration != AV_NOPTS_VALUE)
1533 * Estimate the stream timings from the one of each components.
1535 * Also computes the global bitrate if possible.
1537 static void av_update_stream_timings(AVFormatContext *ic)
1539 int64_t start_time, start_time1, end_time, end_time1;
1543 start_time = MAXINT64;
1544 end_time = MININT64;
1545 for(i = 0;i < ic->nb_streams; i++) {
1546 st = ic->streams[i];
1547 if (st->start_time != AV_NOPTS_VALUE) {
1548 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1549 if (start_time1 < start_time)
1550 start_time = start_time1;
1551 if (st->duration != AV_NOPTS_VALUE) {
1552 end_time1 = start_time1
1553 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1554 if (end_time1 > end_time)
1555 end_time = end_time1;
1559 if (start_time != MAXINT64) {
1560 ic->start_time = start_time;
1561 if (end_time != MININT64) {
1562 ic->duration = end_time - start_time;
1563 if (ic->file_size > 0) {
1564 /* compute the bit rate */
1565 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1566 (double)ic->duration;
1573 static void fill_all_stream_timings(AVFormatContext *ic)
1578 av_update_stream_timings(ic);
1579 for(i = 0;i < ic->nb_streams; i++) {
1580 st = ic->streams[i];
1581 if (st->start_time == AV_NOPTS_VALUE) {
1582 if(ic->start_time != AV_NOPTS_VALUE)
1583 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1584 if(ic->duration != AV_NOPTS_VALUE)
1585 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1590 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1592 int64_t filesize, duration;
1596 /* if bit_rate is already set, we believe it */
1597 if (ic->bit_rate == 0) {
1599 for(i=0;i<ic->nb_streams;i++) {
1600 st = ic->streams[i];
1601 bit_rate += st->codec->bit_rate;
1603 ic->bit_rate = bit_rate;
1606 /* if duration is already set, we believe it */
1607 if (ic->duration == AV_NOPTS_VALUE &&
1608 ic->bit_rate != 0 &&
1609 ic->file_size != 0) {
1610 filesize = ic->file_size;
1612 for(i = 0; i < ic->nb_streams; i++) {
1613 st = ic->streams[i];
1614 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1615 if (st->start_time == AV_NOPTS_VALUE ||
1616 st->duration == AV_NOPTS_VALUE) {
1618 st->duration = duration;
1625 #define DURATION_MAX_READ_SIZE 250000
1627 /* only usable for MPEG-PS streams */
1628 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1630 AVPacket pkt1, *pkt = &pkt1;
1632 int read_size, i, ret;
1634 int64_t filesize, offset, duration;
1636 /* free previous packet */
1637 if (ic->cur_st && ic->cur_st->parser)
1638 av_free_packet(&ic->cur_pkt);
1641 /* flush packet queue */
1642 flush_packet_queue(ic);
1644 for(i=0;i<ic->nb_streams;i++) {
1645 st = ic->streams[i];
1647 av_parser_close(st->parser);
1652 /* we read the first packets to get the first PTS (not fully
1653 accurate, but it is enough now) */
1654 url_fseek(&ic->pb, 0, SEEK_SET);
1657 if (read_size >= DURATION_MAX_READ_SIZE)
1659 /* if all info is available, we can stop */
1660 for(i = 0;i < ic->nb_streams; i++) {
1661 st = ic->streams[i];
1662 if (st->start_time == AV_NOPTS_VALUE)
1665 if (i == ic->nb_streams)
1668 ret = av_read_packet(ic, pkt);
1671 read_size += pkt->size;
1672 st = ic->streams[pkt->stream_index];
1673 if (pkt->pts != AV_NOPTS_VALUE) {
1674 if (st->start_time == AV_NOPTS_VALUE)
1675 st->start_time = pkt->pts;
1677 av_free_packet(pkt);
1680 /* estimate the end time (duration) */
1681 /* XXX: may need to support wrapping */
1682 filesize = ic->file_size;
1683 offset = filesize - DURATION_MAX_READ_SIZE;
1687 url_fseek(&ic->pb, offset, SEEK_SET);
1690 if (read_size >= DURATION_MAX_READ_SIZE)
1692 /* if all info is available, we can stop */
1693 for(i = 0;i < ic->nb_streams; i++) {
1694 st = ic->streams[i];
1695 if (st->duration == AV_NOPTS_VALUE)
1698 if (i == ic->nb_streams)
1701 ret = av_read_packet(ic, pkt);
1704 read_size += pkt->size;
1705 st = ic->streams[pkt->stream_index];
1706 if (pkt->pts != AV_NOPTS_VALUE) {
1707 end_time = pkt->pts;
1708 duration = end_time - st->start_time;
1710 if (st->duration == AV_NOPTS_VALUE ||
1711 st->duration < duration)
1712 st->duration = duration;
1715 av_free_packet(pkt);
1718 fill_all_stream_timings(ic);
1720 url_fseek(&ic->pb, 0, SEEK_SET);
1723 static void av_estimate_timings(AVFormatContext *ic)
1727 /* get the file size, if possible */
1728 if (ic->iformat->flags & AVFMT_NOFILE) {
1731 file_size = url_fsize(&ic->pb);
1735 ic->file_size = file_size;
1737 if ((!strcmp(ic->iformat->name, "mpeg") ||
1738 !strcmp(ic->iformat->name, "mpegts")) &&
1739 file_size && !ic->pb.is_streamed) {
1740 /* get accurate estimate from the PTSes */
1741 av_estimate_timings_from_pts(ic);
1742 } else if (av_has_timings(ic)) {
1743 /* at least one components has timings - we use them for all
1745 fill_all_stream_timings(ic);
1747 /* less precise: use bit rate info */
1748 av_estimate_timings_from_bit_rate(ic);
1750 av_update_stream_timings(ic);
1756 for(i = 0;i < ic->nb_streams; i++) {
1757 st = ic->streams[i];
1758 printf("%d: start_time: %0.3f duration: %0.3f\n",
1759 i, (double)st->start_time / AV_TIME_BASE,
1760 (double)st->duration / AV_TIME_BASE);
1762 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1763 (double)ic->start_time / AV_TIME_BASE,
1764 (double)ic->duration / AV_TIME_BASE,
1765 ic->bit_rate / 1000);
1770 static int has_codec_parameters(AVCodecContext *enc)
1773 switch(enc->codec_type) {
1774 case CODEC_TYPE_AUDIO:
1775 val = enc->sample_rate;
1777 case CODEC_TYPE_VIDEO:
1778 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1787 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1791 int got_picture, ret=0;
1794 if(!st->codec->codec){
1795 codec = avcodec_find_decoder(st->codec->codec_id);
1798 ret = avcodec_open(st->codec, codec);
1803 if(!has_codec_parameters(st->codec)){
1804 switch(st->codec->codec_type) {
1805 case CODEC_TYPE_VIDEO:
1806 ret = avcodec_decode_video(st->codec, &picture,
1807 &got_picture, (uint8_t *)data, size);
1809 case CODEC_TYPE_AUDIO:
1810 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1813 ret = avcodec_decode_audio(st->codec, samples,
1814 &got_picture, (uint8_t *)data, size);
1825 /* absolute maximum size we read until we abort */
1826 #define MAX_READ_SIZE 5000000
1828 /* maximum duration until we stop analysing the stream */
1829 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 3.0))
1832 * Read the beginning of a media file to get stream information. This
1833 * is useful for file formats with no headers such as MPEG. This
1834 * function also compute the real frame rate in case of mpeg2 repeat
1837 * @param ic media file handle
1838 * @return >=0 if OK. AVERROR_xxx if error.
1839 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1841 int av_find_stream_info(AVFormatContext *ic)
1843 int i, count, ret, read_size, j;
1845 AVPacket pkt1, *pkt;
1846 AVPacketList *pktl=NULL, **ppktl;
1847 int64_t last_dts[MAX_STREAMS];
1848 int64_t duration_sum[MAX_STREAMS];
1849 int duration_count[MAX_STREAMS]={0};
1851 for(i=0;i<ic->nb_streams;i++) {
1852 st = ic->streams[i];
1853 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1854 /* if(!st->time_base.num)
1856 if(!st->codec->time_base.num)
1857 st->codec->time_base= st->time_base;
1859 //only for the split stuff
1861 st->parser = av_parser_init(st->codec->codec_id);
1862 if(st->need_parsing == 2 && st->parser){
1863 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1868 for(i=0;i<MAX_STREAMS;i++){
1869 last_dts[i]= AV_NOPTS_VALUE;
1870 duration_sum[i]= INT64_MAX;
1875 ppktl = &ic->packet_buffer;
1877 /* check if one codec still needs to be handled */
1878 for(i=0;i<ic->nb_streams;i++) {
1879 st = ic->streams[i];
1880 if (!has_codec_parameters(st->codec))
1882 /* variable fps and no guess at the real fps */
1883 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1884 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1886 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1889 if (i == ic->nb_streams) {
1890 /* NOTE: if the format has no header, then we need to read
1891 some packets to get most of the streams, so we cannot
1893 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1894 /* if we found the info for all the codecs, we can stop */
1899 /* we did not get all the codec info, but we read too much data */
1900 if (read_size >= MAX_READ_SIZE) {
1906 /* NOTE: a new stream can be added there if no header in file
1907 (AVFMTCTX_NOHEADER) */
1908 ret = av_read_frame_internal(ic, &pkt1);
1911 ret = -1; /* we could not have all the codec parameters before EOF */
1912 for(i=0;i<ic->nb_streams;i++) {
1913 st = ic->streams[i];
1914 if (!has_codec_parameters(st->codec)){
1916 avcodec_string(buf, sizeof(buf), st->codec, 0);
1917 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1925 pktl = av_mallocz(sizeof(AVPacketList));
1927 ret = AVERROR_NOMEM;
1931 /* add the packet in the buffered packet list */
1933 ppktl = &pktl->next;
1938 /* duplicate the packet */
1939 if (av_dup_packet(pkt) < 0) {
1940 ret = AVERROR_NOMEM;
1944 read_size += pkt->size;
1946 st = ic->streams[pkt->stream_index];
1947 st->codec_info_duration += pkt->duration;
1948 if (pkt->duration != 0)
1949 st->codec_info_nb_frames++;
1952 int index= pkt->stream_index;
1953 int64_t last= last_dts[index];
1954 int64_t duration= pkt->dts - last;
1956 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1957 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1958 duration_sum[index]= duration;
1959 duration_count[index]=1;
1961 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1962 duration_sum[index] += duration;
1963 duration_count[index]+= factor;
1965 if(st->codec_info_nb_frames == 0 && 0)
1966 st->codec_info_duration += duration;
1968 last_dts[pkt->stream_index]= pkt->dts;
1970 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1971 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1973 st->codec->extradata_size= i;
1974 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1975 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1976 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1980 /* if still no information, we try to open the codec and to
1981 decompress the frame. We try to avoid that in most cases as
1982 it takes longer and uses more memory. For MPEG4, we need to
1983 decompress for Quicktime. */
1984 if (!has_codec_parameters(st->codec) /*&&
1985 (st->codec->codec_id == CODEC_ID_FLV1 ||
1986 st->codec->codec_id == CODEC_ID_H264 ||
1987 st->codec->codec_id == CODEC_ID_H263 ||
1988 st->codec->codec_id == CODEC_ID_H261 ||
1989 st->codec->codec_id == CODEC_ID_VORBIS ||
1990 st->codec->codec_id == CODEC_ID_MJPEG ||
1991 st->codec->codec_id == CODEC_ID_PNG ||
1992 st->codec->codec_id == CODEC_ID_PAM ||
1993 st->codec->codec_id == CODEC_ID_PGM ||
1994 st->codec->codec_id == CODEC_ID_PGMYUV ||
1995 st->codec->codec_id == CODEC_ID_PBM ||
1996 st->codec->codec_id == CODEC_ID_PPM ||
1997 st->codec->codec_id == CODEC_ID_SHORTEN ||
1998 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1999 try_decode_frame(st, pkt->data, pkt->size);
2001 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2007 // close codecs which where opened in try_decode_frame()
2008 for(i=0;i<ic->nb_streams;i++) {
2009 st = ic->streams[i];
2010 if(st->codec->codec)
2011 avcodec_close(st->codec);
2013 for(i=0;i<ic->nb_streams;i++) {
2014 st = ic->streams[i];
2015 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2016 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2017 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2019 if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2020 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2021 int64_t num, den, error, best_error;
2023 num= st->time_base.den*duration_count[i];
2024 den= st->time_base.num*duration_sum[i];
2026 best_error= INT64_MAX;
2027 for(j=1; j<60*12; j++){
2028 error= ABS(1001*12*num - 1001*j*den);
2029 if(error < best_error){
2031 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2034 for(j=24; j<=30; j+=6){
2035 error= ABS(1001*12*num - 1000*12*j*den);
2036 if(error < best_error){
2038 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2043 /* set real frame rate info */
2044 /* compute the real frame rate for telecine */
2045 if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2046 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2047 st->codec->sub_id == 2) {
2048 if (st->codec_info_nb_frames >= 20) {
2049 float coded_frame_rate, est_frame_rate;
2050 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2051 (double)st->codec_info_duration ;
2052 coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2054 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2055 coded_frame_rate, est_frame_rate);
2057 /* if we detect that it could be a telecine, we
2058 signal it. It would be better to do it at a
2059 higher level as it can change in a film */
2060 if (coded_frame_rate >= 24.97 &&
2061 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2062 st->r_frame_rate = (AVRational){24000, 1001};
2066 /* if no real frame rate, use the codec one */
2067 if (!st->r_frame_rate.num){
2068 st->r_frame_rate.num = st->codec->time_base.den;
2069 st->r_frame_rate.den = st->codec->time_base.num;
2074 av_estimate_timings(ic);
2076 /* correct DTS for b frame streams with no timestamps */
2077 for(i=0;i<ic->nb_streams;i++) {
2078 st = ic->streams[i];
2079 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2081 ppktl = &ic->packet_buffer;
2083 if(ppkt1->stream_index != i)
2085 if(ppkt1->pkt->dts < 0)
2087 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2089 ppkt1->pkt->dts -= delta;
2094 st->cur_dts -= delta;
2102 /*******************************************************/
2105 * start playing a network based stream (e.g. RTSP stream) at the
2108 int av_read_play(AVFormatContext *s)
2110 if (!s->iformat->read_play)
2111 return AVERROR_NOTSUPP;
2112 return s->iformat->read_play(s);
2116 * Pause a network based stream (e.g. RTSP stream).
2118 * Use av_read_play() to resume it.
2120 int av_read_pause(AVFormatContext *s)
2122 if (!s->iformat->read_pause)
2123 return AVERROR_NOTSUPP;
2124 return s->iformat->read_pause(s);
2128 * Close a media file (but not its codecs).
2130 * @param s media file handle
2132 void av_close_input_file(AVFormatContext *s)
2134 int i, must_open_file;
2137 /* free previous packet */
2138 if (s->cur_st && s->cur_st->parser)
2139 av_free_packet(&s->cur_pkt);
2141 if (s->iformat->read_close)
2142 s->iformat->read_close(s);
2143 for(i=0;i<s->nb_streams;i++) {
2144 /* free all data in a stream component */
2147 av_parser_close(st->parser);
2149 av_free(st->index_entries);
2150 av_free(st->codec->extradata);
2154 flush_packet_queue(s);
2156 if (s->iformat->flags & AVFMT_NOFILE) {
2159 if (must_open_file) {
2162 av_freep(&s->priv_data);
2167 * Add a new stream to a media file.
2169 * Can only be called in the read_header() function. If the flag
2170 * AVFMTCTX_NOHEADER is in the format context, then new streams
2171 * can be added in read_packet too.
2173 * @param s media file handle
2174 * @param id file format dependent stream id
2176 AVStream *av_new_stream(AVFormatContext *s, int id)
2180 if (s->nb_streams >= MAX_STREAMS)
2183 st = av_mallocz(sizeof(AVStream));
2187 st->codec= avcodec_alloc_context();
2189 /* no default bitrate if decoding */
2190 st->codec->bit_rate = 0;
2192 st->index = s->nb_streams;
2194 st->start_time = AV_NOPTS_VALUE;
2195 st->duration = AV_NOPTS_VALUE;
2196 st->cur_dts = AV_NOPTS_VALUE;
2198 /* default pts settings is MPEG like */
2199 av_set_pts_info(st, 33, 1, 90000);
2200 st->last_IP_pts = AV_NOPTS_VALUE;
2202 s->streams[s->nb_streams++] = st;
2206 /************************************************************/
2207 /* output media file */
2209 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2213 if (s->oformat->priv_data_size > 0) {
2214 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2216 return AVERROR_NOMEM;
2218 s->priv_data = NULL;
2220 if (s->oformat->set_parameters) {
2221 ret = s->oformat->set_parameters(s, ap);
2229 * allocate the stream private data and write the stream header to an
2232 * @param s media file handle
2233 * @return 0 if OK. AVERROR_xxx if error.
2235 int av_write_header(AVFormatContext *s)
2240 // some sanity checks
2241 for(i=0;i<s->nb_streams;i++) {
2244 switch (st->codec->codec_type) {
2245 case CODEC_TYPE_AUDIO:
2246 if(st->codec->sample_rate<=0){
2247 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2251 case CODEC_TYPE_VIDEO:
2252 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2253 av_log(s, AV_LOG_ERROR, "time base not set\n");
2256 if(st->codec->width<=0 || st->codec->height<=0){
2257 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2264 if(s->oformat->write_header){
2265 ret = s->oformat->write_header(s);
2270 /* init PTS generation */
2271 for(i=0;i<s->nb_streams;i++) {
2272 int64_t den = AV_NOPTS_VALUE;
2275 switch (st->codec->codec_type) {
2276 case CODEC_TYPE_AUDIO:
2277 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2279 case CODEC_TYPE_VIDEO:
2280 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2285 if (den != AV_NOPTS_VALUE) {
2287 return AVERROR_INVALIDDATA;
2288 av_frac_init(&st->pts, 0, 0, den);
2294 //FIXME merge with compute_pkt_fields
2295 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2296 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2297 int num, den, frame_size;
2299 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2301 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2304 /* duration field */
2305 if (pkt->duration == 0) {
2306 compute_frame_duration(&num, &den, st, NULL, pkt);
2308 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2312 //XXX/FIXME this is a temporary hack until all encoders output pts
2313 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2315 // pkt->pts= st->cur_dts;
2316 pkt->pts= st->pts.val;
2319 //calculate dts from pts
2320 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2322 if(st->last_IP_pts == AV_NOPTS_VALUE){
2323 st->last_IP_pts= -pkt->duration;
2325 if(st->last_IP_pts < pkt->pts){
2326 pkt->dts= st->last_IP_pts;
2327 st->last_IP_pts= pkt->pts;
2334 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2335 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2338 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2339 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2343 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2344 st->cur_dts= pkt->dts;
2345 st->pts.val= pkt->dts;
2348 switch (st->codec->codec_type) {
2349 case CODEC_TYPE_AUDIO:
2350 frame_size = get_audio_frame_size(st->codec, pkt->size);
2352 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2353 but it would be better if we had the real timestamps from the encoder */
2354 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2355 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2358 case CODEC_TYPE_VIDEO:
2359 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2367 static void truncate_ts(AVStream *st, AVPacket *pkt){
2368 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2371 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2373 pkt->pts &= pts_mask;
2374 pkt->dts &= pts_mask;
2378 * Write a packet to an output media file.
2380 * The packet shall contain one audio or video frame.
2382 * @param s media file handle
2383 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2384 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2386 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2390 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2394 truncate_ts(s->streams[pkt->stream_index], pkt);
2396 ret= s->oformat->write_packet(s, pkt);
2398 ret= url_ferror(&s->pb);
2403 * interleave_packet implementation which will interleave per DTS.
2404 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2405 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2407 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2408 AVPacketList *pktl, **next_point, *this_pktl;
2410 int streams[MAX_STREAMS];
2413 AVStream *st= s->streams[ pkt->stream_index];
2415 // assert(pkt->destruct != av_destruct_packet); //FIXME
2417 this_pktl = av_mallocz(sizeof(AVPacketList));
2418 this_pktl->pkt= *pkt;
2419 if(pkt->destruct == av_destruct_packet)
2420 pkt->destruct= NULL; // non shared -> must keep original from being freed
2422 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2424 next_point = &s->packet_buffer;
2426 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2427 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2428 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2429 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2431 next_point= &(*next_point)->next;
2433 this_pktl->next= *next_point;
2434 *next_point= this_pktl;
2437 memset(streams, 0, sizeof(streams));
2438 pktl= s->packet_buffer;
2440 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2441 if(streams[ pktl->pkt.stream_index ] == 0)
2443 streams[ pktl->pkt.stream_index ]++;
2447 if(s->nb_streams == stream_count || (flush && stream_count)){
2448 pktl= s->packet_buffer;
2451 s->packet_buffer= pktl->next;
2455 av_init_packet(out);
2461 * Interleaves a AVPacket correctly so it can be muxed.
2462 * @param out the interleaved packet will be output here
2463 * @param in the input packet
2464 * @param flush 1 if no further packets are available as input and all
2465 * remaining packets should be output
2466 * @return 1 if a packet was output, 0 if no packet could be output,
2467 * < 0 if an error occured
2469 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2470 if(s->oformat->interleave_packet)
2471 return s->oformat->interleave_packet(s, out, in, flush);
2473 return av_interleave_packet_per_dts(s, out, in, flush);
2477 * Writes a packet to an output media file ensuring correct interleaving.
2479 * The packet must contain one audio or video frame.
2480 * If the packets are already correctly interleaved the application should
2481 * call av_write_frame() instead as its slightly faster, its also important
2482 * to keep in mind that completly non interleaved input will need huge amounts
2483 * of memory to interleave with this, so its prefereable to interleave at the
2486 * @param s media file handle
2487 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2488 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2490 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2491 AVStream *st= s->streams[ pkt->stream_index];
2493 //FIXME/XXX/HACK drop zero sized packets
2494 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2497 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2498 if(compute_pkt_fields2(st, pkt) < 0)
2501 if(pkt->dts == AV_NOPTS_VALUE)
2506 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2507 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2510 truncate_ts(s->streams[opkt.stream_index], &opkt);
2511 ret= s->oformat->write_packet(s, &opkt);
2513 av_free_packet(&opkt);
2518 if(url_ferror(&s->pb))
2519 return url_ferror(&s->pb);
2524 * @brief Write the stream trailer to an output media file and
2525 * free the file private data.
2527 * @param s media file handle
2528 * @return 0 if OK. AVERROR_xxx if error.
2530 int av_write_trailer(AVFormatContext *s)
2536 ret= av_interleave_packet(s, &pkt, NULL, 1);
2537 if(ret<0) //FIXME cleanup needed for ret<0 ?
2542 truncate_ts(s->streams[pkt.stream_index], &pkt);
2543 ret= s->oformat->write_packet(s, &pkt);
2545 av_free_packet(&pkt);
2549 if(url_ferror(&s->pb))
2553 if(s->oformat->write_trailer)
2554 ret = s->oformat->write_trailer(s);
2557 ret=url_ferror(&s->pb);
2558 for(i=0;i<s->nb_streams;i++)
2559 av_freep(&s->streams[i]->priv_data);
2560 av_freep(&s->priv_data);
2564 /* "user interface" functions */
2566 void dump_format(AVFormatContext *ic,
2574 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2575 is_output ? "Output" : "Input",
2577 is_output ? ic->oformat->name : ic->iformat->name,
2578 is_output ? "to" : "from", url);
2580 av_log(NULL, AV_LOG_INFO, " Duration: ");
2581 if (ic->duration != AV_NOPTS_VALUE) {
2582 int hours, mins, secs, us;
2583 secs = ic->duration / AV_TIME_BASE;
2584 us = ic->duration % AV_TIME_BASE;
2589 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2590 (10 * us) / AV_TIME_BASE);
2592 av_log(NULL, AV_LOG_INFO, "N/A");
2594 if (ic->start_time != AV_NOPTS_VALUE) {
2596 av_log(NULL, AV_LOG_INFO, ", start: ");
2597 secs = ic->start_time / AV_TIME_BASE;
2598 us = ic->start_time % AV_TIME_BASE;
2599 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2600 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2602 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2604 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2606 av_log(NULL, AV_LOG_INFO, "N/A");
2608 av_log(NULL, AV_LOG_INFO, "\n");
2610 for(i=0;i<ic->nb_streams;i++) {
2611 AVStream *st = ic->streams[i];
2612 int g= ff_gcd(st->time_base.num, st->time_base.den);
2613 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2614 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2615 /* the pid is an important information, so we display it */
2616 /* XXX: add a generic system */
2618 flags = ic->oformat->flags;
2620 flags = ic->iformat->flags;
2621 if (flags & AVFMT_SHOW_IDS) {
2622 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2624 if (strlen(st->language) > 0) {
2625 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2627 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2628 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2629 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2630 if(st->r_frame_rate.den && st->r_frame_rate.num)
2631 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2632 /* else if(st->time_base.den && st->time_base.num)
2633 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2635 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2637 av_log(NULL, AV_LOG_INFO, "\n");
2644 int frame_rate, frame_rate_base;
2647 static AbvEntry frame_abvs[] = {
2648 { "ntsc", 720, 480, 30000, 1001 },
2649 { "pal", 720, 576, 25, 1 },
2650 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2651 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2652 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2653 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2654 { "film", 352, 240, 24, 1 },
2655 { "ntsc-film", 352, 240, 24000, 1001 },
2656 { "sqcif", 128, 96, 0, 0 },
2657 { "qcif", 176, 144, 0, 0 },
2658 { "cif", 352, 288, 0, 0 },
2659 { "4cif", 704, 576, 0, 0 },
2663 * parses width and height out of string str.
2665 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2668 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2670 int frame_width = 0, frame_height = 0;
2673 if (!strcmp(frame_abvs[i].abv, str)) {
2674 frame_width = frame_abvs[i].width;
2675 frame_height = frame_abvs[i].height;
2681 frame_width = strtol(p, (char **)&p, 10);
2684 frame_height = strtol(p, (char **)&p, 10);
2686 if (frame_width <= 0 || frame_height <= 0)
2688 *width_ptr = frame_width;
2689 *height_ptr = frame_height;
2694 * Converts frame rate from string to a fraction.
2696 * First we try to get an exact integer or fractional frame rate.
2697 * If this fails we convert the frame rate to a double and return
2698 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2700 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2705 /* First, we check our abbreviation table */
2706 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2707 if (!strcmp(frame_abvs[i].abv, arg)) {
2708 *frame_rate = frame_abvs[i].frame_rate;
2709 *frame_rate_base = frame_abvs[i].frame_rate_base;
2713 /* Then, we try to parse it as fraction */
2714 cp = strchr(arg, '/');
2716 cp = strchr(arg, ':');
2719 *frame_rate = strtol(arg, &cpp, 10);
2720 if (cpp != arg || cpp == cp)
2721 *frame_rate_base = strtol(cp+1, &cpp, 10);
2726 /* Finally we give up and parse it as double */
2727 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2728 *frame_rate_base = time_base.den;
2729 *frame_rate = time_base.num;
2731 if (!*frame_rate || !*frame_rate_base)
2738 * Converts date string to number of seconds since Jan 1st, 1970.
2742 * - If not a duration:
2743 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2744 * Time is localtime unless Z is suffixed to the end. In this case GMT
2745 * Return the date in micro seconds since 1970
2748 * HH[:MM[:SS[.m...]]]
2752 #ifndef CONFIG_WINCE
2753 int64_t parse_date(const char *datestr, int duration)
2759 static const char *date_fmt[] = {
2763 static const char *time_fmt[] = {
2773 time_t now = time(0);
2775 len = strlen(datestr);
2777 lastch = datestr[len - 1];
2780 is_utc = (lastch == 'z' || lastch == 'Z');
2782 memset(&dt, 0, sizeof(dt));
2787 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2788 q = small_strptime(p, date_fmt[i], &dt);
2798 dt = *localtime(&now);
2800 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2805 if (*p == 'T' || *p == 't' || *p == ' ')
2808 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2809 q = small_strptime(p, time_fmt[i], &dt);
2819 q = small_strptime(p, time_fmt[0], &dt);
2821 dt.tm_sec = strtol(p, (char **)&q, 10);
2827 /* Now we have all the fields that we can get */
2832 return now * int64_t_C(1000000);
2836 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2838 dt.tm_isdst = -1; /* unknown */
2851 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2854 val += n * (*q - '0');
2858 return negative ? -t : t;
2860 #endif /* CONFIG_WINCE */
2863 * Attempts to find a specific tag in a URL.
2865 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2866 * Return 1 if found.
2868 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2878 while (*p != '\0' && *p != '=' && *p != '&') {
2879 if ((q - tag) < sizeof(tag) - 1)
2887 while (*p != '&' && *p != '\0') {
2888 if ((q - arg) < arg_size - 1) {
2898 if (!strcmp(tag, tag1))
2908 * Returns in 'buf' the path with '%d' replaced by number.
2910 * Also handles the '%0nd' format where 'n' is the total number
2911 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2913 int get_frame_filename(char *buf, int buf_size,
2914 const char *path, int number)
2917 char *q, buf1[20], c;
2918 int nd, len, percentd_found;
2930 while (isdigit(*p)) {
2931 nd = nd * 10 + *p++ - '0';
2934 } while (isdigit(c));
2943 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2945 if ((q - buf + len) > buf_size - 1)
2947 memcpy(q, buf1, len);
2955 if ((q - buf) < buf_size - 1)
2959 if (!percentd_found)
2969 * Print nice hexa dump of a buffer
2970 * @param f stream for output
2972 * @param size buffer size
2974 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2978 for(i=0;i<size;i+=16) {
2982 fprintf(f, "%08x ", i);
2985 fprintf(f, " %02x", buf[i+j]);
2990 for(j=0;j<len;j++) {
2992 if (c < ' ' || c > '~')
2994 fprintf(f, "%c", c);
3001 * Print on 'f' a nice dump of a packet
3002 * @param f stream for output
3003 * @param pkt packet to dump
3004 * @param dump_payload true if the payload must be displayed too
3006 //FIXME needs to know the time_base
3007 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3009 fprintf(f, "stream #%d:\n", pkt->stream_index);
3010 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3011 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3012 /* DTS is _always_ valid after av_read_frame() */
3013 fprintf(f, " dts=");
3014 if (pkt->dts == AV_NOPTS_VALUE)
3017 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3018 /* PTS may be not known if B frames are present */
3019 fprintf(f, " pts=");
3020 if (pkt->pts == AV_NOPTS_VALUE)
3023 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3025 fprintf(f, " size=%d\n", pkt->size);
3027 av_hex_dump(f, pkt->data, pkt->size);
3030 void url_split(char *proto, int proto_size,
3031 char *authorization, int authorization_size,
3032 char *hostname, int hostname_size,
3034 char *path, int path_size,
3045 while (*p != ':' && *p != '\0') {
3046 if ((q - proto) < proto_size - 1)
3052 if (authorization_size > 0)
3053 authorization[0] = '\0';
3057 if (hostname_size > 0)
3061 char *at,*slash; // PETR: position of '@' character and '/' character
3068 at = strchr(p,'@'); // PETR: get the position of '@'
3069 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3070 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3072 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3074 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3075 if (*p == '@') { // PETR: passed '@'
3076 if (authorization_size > 0)
3080 } else if (!at) { // PETR: hostname
3081 if ((q - hostname) < hostname_size - 1)
3084 if ((q - authorization) < authorization_size - 1)
3089 if (hostname_size > 0)
3093 port = strtoul(p, (char **)&p, 10);
3098 pstrcpy(path, path_size, p);
3102 * Set the pts for a given stream.
3105 * @param pts_wrap_bits number of bits effectively used by the pts
3106 * (used for wrap control, 33 is the value for MPEG)
3107 * @param pts_num numerator to convert to seconds (MPEG: 1)
3108 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3110 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3111 int pts_num, int pts_den)
3113 s->pts_wrap_bits = pts_wrap_bits;
3114 s->time_base.num = pts_num;
3115 s->time_base.den = pts_den;
3118 /* fraction handling */
3121 * f = val + (num / den) + 0.5.
3123 * 'num' is normalized so that it is such as 0 <= num < den.
3125 * @param f fractional number
3126 * @param val integer value
3127 * @param num must be >= 0
3128 * @param den must be >= 1
3130 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3143 * Set f to (val + 0.5).
3145 static void av_frac_set(AVFrac *f, int64_t val)
3148 f->num = f->den >> 1;
3152 * Fractionnal addition to f: f = f + (incr / f->den).
3154 * @param f fractional number
3155 * @param incr increment, can be positive or negative
3157 static void av_frac_add(AVFrac *f, int64_t incr)
3161 num = f->num + incr;
3164 f->val += num / den;
3170 } else if (num >= den) {
3171 f->val += num / den;
3178 * register a new image format
3179 * @param img_fmt Image format descriptor
3181 void av_register_image_format(AVImageFormat *img_fmt)
3185 p = &first_image_format;
3186 while (*p != NULL) p = &(*p)->next;
3188 img_fmt->next = NULL;
3192 * Guesses image format based on data in the image.
3194 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3196 AVImageFormat *fmt1, *fmt;
3197 int score, score_max;
3201 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3202 if (fmt1->img_probe) {
3203 score = fmt1->img_probe(pd);
3204 if (score > score_max) {
3214 * Guesses image format based on file name extensions.
3216 AVImageFormat *guess_image_format(const char *filename)
3218 AVImageFormat *fmt1;
3220 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3221 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3228 * Read an image from a stream.
3229 * @param gb byte stream containing the image
3230 * @param fmt image format, NULL if probing is required
3232 int av_read_image(ByteIOContext *pb, const char *filename,
3234 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3236 uint8_t buf[PROBE_BUF_MIN];
3237 AVProbeData probe_data, *pd = &probe_data;
3242 pd->filename = filename;
3244 pos = url_ftell(pb);
3245 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3246 url_fseek(pb, pos, SEEK_SET);
3247 fmt = av_probe_image_format(pd);
3250 return AVERROR_NOFMT;
3251 ret = fmt->img_read(pb, alloc_cb, opaque);
3256 * Write an image to a stream.
3257 * @param pb byte stream for the image output
3258 * @param fmt image format
3259 * @param img image data and informations
3261 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3263 return fmt->img_write(pb, img);