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
25 * @file libavformat/utils.c
26 * Various utility functions for using ffmpeg library.
29 /** head of registered input format linked list. */
30 AVInputFormat *first_iformat = NULL;
31 /** head of registered output format linked list. */
32 AVOutputFormat *first_oformat = NULL;
33 /** head of registered image format linked list. */
34 AVImageFormat *first_image_format = NULL;
36 void av_register_input_format(AVInputFormat *format)
40 while (*p != NULL) p = &(*p)->next;
45 void av_register_output_format(AVOutputFormat *format)
49 while (*p != NULL) p = &(*p)->next;
54 int match_ext(const char *filename, const char *extensions)
62 ext = strrchr(filename, '.');
68 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
71 if (!strcasecmp(ext1, ext))
81 AVOutputFormat *guess_format(const char *short_name, const char *filename,
82 const char *mime_type)
84 AVOutputFormat *fmt, *fmt_found;
87 /* specific test for image sequences */
88 if (!short_name && filename &&
89 filename_number_test(filename) >= 0 &&
90 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
91 return guess_format("image2", NULL, NULL);
93 if (!short_name && filename &&
94 filename_number_test(filename) >= 0 &&
95 guess_image_format(filename)) {
96 return guess_format("image", NULL, NULL);
99 /* find the proper file type */
103 while (fmt != NULL) {
105 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
107 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
109 if (filename && fmt->extensions &&
110 match_ext(filename, fmt->extensions)) {
113 if (score > score_max) {
122 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
123 const char *mime_type)
125 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
128 AVOutputFormat *stream_fmt;
129 char stream_format_name[64];
131 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
132 stream_fmt = guess_format(stream_format_name, NULL, NULL);
142 * Guesses the codec id based upon muxer and filename.
144 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
145 const char *filename, const char *mime_type, enum CodecType type){
146 if(type == CODEC_TYPE_VIDEO){
147 enum CodecID codec_id= CODEC_ID_NONE;
149 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
150 codec_id= av_guess_image2_codec(filename);
152 if(codec_id == CODEC_ID_NONE)
153 codec_id= fmt->video_codec;
155 }else if(type == CODEC_TYPE_AUDIO)
156 return fmt->audio_codec;
158 return CODEC_ID_NONE;
162 * finds AVInputFormat based on input format's short name.
164 AVInputFormat *av_find_input_format(const char *short_name)
167 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
168 if (!strcmp(fmt->name, short_name))
174 /* memory handling */
177 * Default packet destructor.
179 void av_destruct_packet(AVPacket *pkt)
182 pkt->data = NULL; pkt->size = 0;
186 * Allocate the payload of a packet and intialized its fields to default values.
189 * @param size wanted payload size
190 * @return 0 if OK. AVERROR_xxx otherwise.
192 int av_new_packet(AVPacket *pkt, int size)
195 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
196 return AVERROR_NOMEM;
197 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
199 return AVERROR_NOMEM;
200 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
205 pkt->destruct = av_destruct_packet;
210 * Allocate and read the payload of a packet and intialized its fields to default values.
213 * @param size wanted payload size
214 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
216 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
218 int ret= av_new_packet(pkt, size);
223 pkt->pos= url_ftell(s);
225 ret= get_buffer(s, pkt->data, size);
234 /* This is a hack - the packet memory allocation stuff is broken. The
235 packet is allocated if it was not really allocated */
236 int av_dup_packet(AVPacket *pkt)
238 if (pkt->destruct != av_destruct_packet) {
240 /* we duplicate the packet and don't forget to put the padding
242 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
243 return AVERROR_NOMEM;
244 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
246 return AVERROR_NOMEM;
248 memcpy(data, pkt->data, pkt->size);
249 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
251 pkt->destruct = av_destruct_packet;
258 int fifo_init(FifoBuffer *f, int size)
260 f->buffer = av_malloc(size);
263 f->end = f->buffer + size;
264 f->wptr = f->rptr = f->buffer;
268 void fifo_free(FifoBuffer *f)
273 int fifo_size(FifoBuffer *f, uint8_t *rptr)
280 if (f->wptr >= rptr) {
281 size = f->wptr - rptr;
283 size = (f->end - rptr) + (f->wptr - f->buffer);
289 * Get data from the fifo (returns -1 if not enough data).
291 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
300 if (f->wptr >= rptr) {
301 size = f->wptr - rptr;
303 size = (f->end - rptr) + (f->wptr - f->buffer);
308 while (buf_size > 0) {
312 memcpy(buf, rptr, len);
326 void fifo_realloc(FifoBuffer *f, unsigned int new_size){
327 unsigned int old_size= f->end - f->buffer;
329 if(old_size < new_size){
330 uint8_t *old= f->buffer;
332 f->buffer= av_realloc(f->buffer, new_size);
334 f->rptr += f->buffer - old;
335 f->wptr += f->buffer - old;
337 if(f->wptr < f->rptr){
338 memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
339 f->rptr += new_size - old_size;
341 f->end= f->buffer + new_size;
345 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
358 memcpy(wptr, buf, len);
368 /* get data from the fifo (return -1 if not enough data) */
369 int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
371 uint8_t *rptr = *rptr_ptr;
374 if (f->wptr >= rptr) {
375 size = f->wptr - rptr;
377 size = (f->end - rptr) + (f->wptr - f->buffer);
382 while (buf_size > 0) {
386 put_buffer(pb, rptr, len);
396 int filename_number_test(const char *filename)
401 return get_frame_filename(buf, sizeof(buf), filename, 1);
407 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
409 AVInputFormat *fmt1, *fmt;
410 int score, score_max;
414 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
415 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
418 if (fmt1->read_probe) {
419 score = fmt1->read_probe(pd);
420 } else if (fmt1->extensions) {
421 if (match_ext(pd->filename, fmt1->extensions)) {
425 if (score > score_max) {
433 /************************************************************/
434 /* input media file */
437 * Open a media file from an IO stream. 'fmt' must be specified.
439 static const char* format_to_name(void* ptr)
441 AVFormatContext* fc = (AVFormatContext*) ptr;
442 if(fc->iformat) return fc->iformat->name;
443 else if(fc->oformat) return fc->oformat->name;
447 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
449 AVFormatContext *av_alloc_format_context(void)
452 ic = av_mallocz(sizeof(AVFormatContext));
454 ic->av_class = &av_format_context_class;
459 * Allocates all the structures needed to read an input stream.
460 * This does not open the needed codecs for decoding the stream[s].
462 int av_open_input_stream(AVFormatContext **ic_ptr,
463 ByteIOContext *pb, const char *filename,
464 AVInputFormat *fmt, AVFormatParameters *ap)
468 AVFormatParameters default_ap;
472 memset(ap, 0, sizeof(default_ap));
475 ic = av_alloc_format_context();
483 ic->duration = AV_NOPTS_VALUE;
484 ic->start_time = AV_NOPTS_VALUE;
485 pstrcpy(ic->filename, sizeof(ic->filename), filename);
487 /* allocate private data */
488 if (fmt->priv_data_size > 0) {
489 ic->priv_data = av_mallocz(fmt->priv_data_size);
490 if (!ic->priv_data) {
495 ic->priv_data = NULL;
498 err = ic->iformat->read_header(ic, ap);
503 ic->data_offset = url_ftell(&ic->pb);
509 av_freep(&ic->priv_data);
516 /** Size of probe buffer, for guessing file type from file contents. */
517 #define PROBE_BUF_MIN 2048
518 #define PROBE_BUF_MAX (1<<20)
521 * Open a media file as input. The codec are not opened. Only the file
522 * header (if present) is read.
524 * @param ic_ptr the opened media file handle is put here
525 * @param filename filename to open.
526 * @param fmt if non NULL, force the file format to use
527 * @param buf_size optional buffer size (zero if default is OK)
528 * @param ap additionnal parameters needed when opening the file (NULL if default)
529 * @return 0 if OK. AVERROR_xxx otherwise.
531 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
534 AVFormatParameters *ap)
536 int err, must_open_file, file_opened, probe_size;
537 AVProbeData probe_data, *pd = &probe_data;
538 ByteIOContext pb1, *pb = &pb1;
543 pd->filename = filename;
548 /* guess format if no file can be opened */
549 fmt = av_probe_input_format(pd, 0);
552 /* do not open file if the format does not need it. XXX: specific
553 hack needed to handle RTSP/TCP */
555 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
557 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
560 if (!fmt || must_open_file) {
561 /* if no file needed do not try to open one */
562 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
568 url_setbufsize(pb, buf_size);
571 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
572 /* read probe data */
573 pd->buf= av_realloc(pd->buf, probe_size);
574 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
575 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
577 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
583 /* guess file format */
584 fmt = av_probe_input_format(pd, 1);
589 /* if still no format found, error */
595 /* XXX: suppress this hack for redirectors */
596 #ifdef CONFIG_NETWORK
597 if (fmt == &redir_demux) {
598 err = redir_open(ic_ptr, pb);
604 /* check filename in case of an image number is expected */
605 if (fmt->flags & AVFMT_NEEDNUMBER) {
606 if (filename_number_test(filename) < 0) {
607 err = AVERROR_NUMEXPECTED;
611 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
624 /*******************************************************/
627 * Read a transport packet from a media file.
629 * This function is absolete and should never be used.
630 * Use av_read_frame() instead.
632 * @param s media file handle
633 * @param pkt is filled
634 * @return 0 if OK. AVERROR_xxx if error.
636 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
638 return s->iformat->read_packet(s, pkt);
641 /**********************************************************/
644 * Get the number of samples of an audio frame. Return (-1) if error.
646 static int get_audio_frame_size(AVCodecContext *enc, int size)
650 if (enc->frame_size <= 1) {
651 /* specific hack for pcm codecs because no frame size is
653 switch(enc->codec_id) {
654 case CODEC_ID_PCM_S32LE:
655 case CODEC_ID_PCM_S32BE:
656 case CODEC_ID_PCM_U32LE:
657 case CODEC_ID_PCM_U32BE:
658 if (enc->channels == 0)
660 frame_size = size / (4 * enc->channels);
662 case CODEC_ID_PCM_S24LE:
663 case CODEC_ID_PCM_S24BE:
664 case CODEC_ID_PCM_U24LE:
665 case CODEC_ID_PCM_U24BE:
666 case CODEC_ID_PCM_S24DAUD:
667 if (enc->channels == 0)
669 frame_size = size / (3 * enc->channels);
671 case CODEC_ID_PCM_S16LE:
672 case CODEC_ID_PCM_S16BE:
673 case CODEC_ID_PCM_U16LE:
674 case CODEC_ID_PCM_U16BE:
675 if (enc->channels == 0)
677 frame_size = size / (2 * enc->channels);
679 case CODEC_ID_PCM_S8:
680 case CODEC_ID_PCM_U8:
681 case CODEC_ID_PCM_MULAW:
682 case CODEC_ID_PCM_ALAW:
683 if (enc->channels == 0)
685 frame_size = size / (enc->channels);
688 /* used for example by ADPCM codecs */
689 if (enc->bit_rate == 0)
691 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
695 frame_size = enc->frame_size;
702 * Return the frame duration in seconds, return 0 if not available.
704 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
705 AVCodecParserContext *pc, AVPacket *pkt)
711 switch(st->codec->codec_type) {
712 case CODEC_TYPE_VIDEO:
713 if(st->time_base.num*1000LL > st->time_base.den){
714 *pnum = st->time_base.num;
715 *pden = st->time_base.den;
716 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
717 *pnum = st->codec->time_base.num;
718 *pden = st->codec->time_base.den;
719 if (pc && pc->repeat_pict) {
721 *pnum = (*pnum) * (2 + pc->repeat_pict);
725 case CODEC_TYPE_AUDIO:
726 frame_size = get_audio_frame_size(st->codec, pkt->size);
730 *pden = st->codec->sample_rate;
737 static int is_intra_only(AVCodecContext *enc){
738 if(enc->codec_type == CODEC_TYPE_AUDIO){
740 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
741 switch(enc->codec_id){
743 case CODEC_ID_MJPEGB:
745 case CODEC_ID_RAWVIDEO:
746 case CODEC_ID_DVVIDEO:
747 case CODEC_ID_HUFFYUV:
748 case CODEC_ID_FFVHUFF:
759 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
760 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
761 int64_t delta= last_ts - mask/2;
762 return ((lsb - delta)&mask) + delta;
765 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
766 AVCodecParserContext *pc, AVPacket *pkt)
768 int num, den, presentation_delayed;
769 /* handle wrapping */
770 if(st->cur_dts != AV_NOPTS_VALUE){
771 if(pkt->pts != AV_NOPTS_VALUE)
772 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
773 if(pkt->dts != AV_NOPTS_VALUE)
774 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
777 if (pkt->duration == 0) {
778 compute_frame_duration(&num, &den, st, pc, pkt);
780 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
784 if(is_intra_only(st->codec))
785 pkt->flags |= PKT_FLAG_KEY;
787 /* do we have a video B frame ? */
788 presentation_delayed = 0;
789 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
790 /* XXX: need has_b_frame, but cannot get it if the codec is
792 if (( st->codec->codec_id == CODEC_ID_H264
793 || st->codec->has_b_frames) &&
794 pc && pc->pict_type != FF_B_TYPE)
795 presentation_delayed = 1;
796 /* this may be redundant, but it shouldnt hurt */
797 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
798 presentation_delayed = 1;
801 if(st->cur_dts == AV_NOPTS_VALUE){
802 if(presentation_delayed) st->cur_dts = -pkt->duration;
803 else st->cur_dts = 0;
806 // 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);
807 /* interpolate PTS and DTS if they are not present */
808 if (presentation_delayed) {
809 /* DTS = decompression time stamp */
810 /* PTS = presentation time stamp */
811 if (pkt->dts == AV_NOPTS_VALUE) {
812 /* if we know the last pts, use it */
813 if(st->last_IP_pts != AV_NOPTS_VALUE)
814 st->cur_dts = pkt->dts = st->last_IP_pts;
816 pkt->dts = st->cur_dts;
818 st->cur_dts = pkt->dts;
820 /* this is tricky: the dts must be incremented by the duration
821 of the frame we are displaying, i.e. the last I or P frame */
822 if (st->last_IP_duration == 0)
823 st->cur_dts += pkt->duration;
825 st->cur_dts += st->last_IP_duration;
826 st->last_IP_duration = pkt->duration;
827 st->last_IP_pts= pkt->pts;
828 /* cannot compute PTS if not present (we can compute it only
829 by knowing the futur */
830 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
831 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
832 int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
833 int64_t new_diff= ABS(st->cur_dts - pkt->pts);
834 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
835 pkt->pts += pkt->duration;
836 // 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);
840 /* presentation is not delayed : PTS and DTS are the same */
841 if (pkt->pts == AV_NOPTS_VALUE) {
842 if (pkt->dts == AV_NOPTS_VALUE) {
843 pkt->pts = st->cur_dts;
844 pkt->dts = st->cur_dts;
847 st->cur_dts = pkt->dts;
851 st->cur_dts = pkt->pts;
854 st->cur_dts += pkt->duration;
856 // 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);
861 /* key frame computation */
862 switch(st->codec->codec_type) {
863 case CODEC_TYPE_VIDEO:
864 if (pc->pict_type == FF_I_TYPE)
865 pkt->flags |= PKT_FLAG_KEY;
867 case CODEC_TYPE_AUDIO:
868 pkt->flags |= PKT_FLAG_KEY;
876 void av_destruct_packet_nofree(AVPacket *pkt)
878 pkt->data = NULL; pkt->size = 0;
881 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
887 /* select current input stream component */
890 if (!st->need_parsing || !st->parser) {
891 /* no parsing needed: we just output the packet as is */
892 /* raw data support */
894 compute_pkt_fields(s, st, NULL, pkt);
897 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
898 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
899 s->cur_ptr, s->cur_len,
900 s->cur_pkt.pts, s->cur_pkt.dts);
901 s->cur_pkt.pts = AV_NOPTS_VALUE;
902 s->cur_pkt.dts = AV_NOPTS_VALUE;
903 /* increment read pointer */
907 /* return packet if any */
911 pkt->stream_index = st->index;
912 pkt->pts = st->parser->pts;
913 pkt->dts = st->parser->dts;
914 pkt->destruct = av_destruct_packet_nofree;
915 compute_pkt_fields(s, st, st->parser, pkt);
920 av_free_packet(&s->cur_pkt);
924 /* read next packet */
925 ret = av_read_packet(s, &s->cur_pkt);
929 /* return the last frames, if any */
930 for(i = 0; i < s->nb_streams; i++) {
932 if (st->parser && st->need_parsing) {
933 av_parser_parse(st->parser, st->codec,
934 &pkt->data, &pkt->size,
936 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
941 /* no more packets: really terminates parsing */
945 st = s->streams[s->cur_pkt.stream_index];
948 s->cur_ptr = s->cur_pkt.data;
949 s->cur_len = s->cur_pkt.size;
950 if (st->need_parsing && !st->parser) {
951 st->parser = av_parser_init(st->codec->codec_id);
953 /* no parser available : just output the raw packets */
954 st->need_parsing = 0;
955 }else if(st->need_parsing == 2){
956 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
964 * Return the next frame of a stream.
966 * The returned packet is valid
967 * until the next av_read_frame() or until av_close_input_file() and
968 * must be freed with av_free_packet. For video, the packet contains
969 * exactly one frame. For audio, it contains an integer number of
970 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
971 * data). If the audio frames have a variable size (e.g. MPEG audio),
972 * then it contains one frame.
974 * pkt->pts, pkt->dts and pkt->duration are always set to correct
975 * values in AV_TIME_BASE unit (and guessed if the format cannot
976 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
977 * has B frames, so it is better to rely on pkt->dts if you do not
978 * decompress the payload.
980 * @return 0 if OK, < 0 if error or end of file.
982 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
986 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
989 pktl = s->packet_buffer;
991 AVPacket *next_pkt= &pktl->pkt;
993 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
994 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
995 if( pktl->pkt.stream_index == next_pkt->stream_index
996 && next_pkt->dts < pktl->pkt.dts
997 && pktl->pkt.pts != pktl->pkt.dts //not b frame
998 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
999 next_pkt->pts= pktl->pkt.dts;
1003 pktl = s->packet_buffer;
1006 if( next_pkt->pts != AV_NOPTS_VALUE
1007 || next_pkt->dts == AV_NOPTS_VALUE
1009 /* read packet from packet buffer, if there is data */
1011 s->packet_buffer = pktl->next;
1017 AVPacketList **plast_pktl= &s->packet_buffer;
1018 int ret= av_read_frame_internal(s, pkt);
1020 if(pktl && ret != -EAGAIN){
1027 /* duplicate the packet */
1028 if (av_dup_packet(pkt) < 0)
1029 return AVERROR_NOMEM;
1031 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1033 pktl = av_mallocz(sizeof(AVPacketList));
1035 return AVERROR_NOMEM;
1037 /* add the packet in the buffered packet list */
1041 assert(!s->packet_buffer);
1042 return av_read_frame_internal(s, pkt);
1047 /* XXX: suppress the packet queue */
1048 static void flush_packet_queue(AVFormatContext *s)
1053 pktl = s->packet_buffer;
1056 s->packet_buffer = pktl->next;
1057 av_free_packet(&pktl->pkt);
1062 /*******************************************************/
1065 int av_find_default_stream_index(AVFormatContext *s)
1070 if (s->nb_streams <= 0)
1072 for(i = 0; i < s->nb_streams; i++) {
1074 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1082 * Flush the frame reader.
1084 static void av_read_frame_flush(AVFormatContext *s)
1089 flush_packet_queue(s);
1091 /* free previous packet */
1093 if (s->cur_st->parser)
1094 av_free_packet(&s->cur_pkt);
1101 /* for each stream, reset read state */
1102 for(i = 0; i < s->nb_streams; i++) {
1106 av_parser_close(st->parser);
1109 st->last_IP_pts = AV_NOPTS_VALUE;
1110 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1115 * Updates cur_dts of all streams based on given timestamp and AVStream.
1117 * Stream ref_st unchanged, others set cur_dts in their native timebase
1118 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1119 * @param timestamp new dts expressed in time_base of param ref_st
1120 * @param ref_st reference stream giving time_base of param timestamp
1122 static void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1125 for(i = 0; i < s->nb_streams; i++) {
1126 AVStream *st = s->streams[i];
1128 st->cur_dts = av_rescale(timestamp,
1129 st->time_base.den * (int64_t)ref_st->time_base.num,
1130 st->time_base.num * (int64_t)ref_st->time_base.den);
1135 * Add a index entry into a sorted list updateing if it is already there.
1137 * @param timestamp timestamp in the timebase of the given stream
1139 int av_add_index_entry(AVStream *st,
1140 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1142 AVIndexEntry *entries, *ie;
1145 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1148 entries = av_fast_realloc(st->index_entries,
1149 &st->index_entries_allocated_size,
1150 (st->nb_index_entries + 1) *
1151 sizeof(AVIndexEntry));
1155 st->index_entries= entries;
1157 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1160 index= st->nb_index_entries++;
1161 ie= &entries[index];
1162 assert(index==0 || ie[-1].timestamp < timestamp);
1164 ie= &entries[index];
1165 if(ie->timestamp != timestamp){
1166 if(ie->timestamp <= timestamp)
1168 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1169 st->nb_index_entries++;
1170 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1171 distance= ie->min_distance;
1175 ie->timestamp = timestamp;
1176 ie->min_distance= distance;
1184 * build an index for raw streams using a parser.
1186 static void av_build_index_raw(AVFormatContext *s)
1188 AVPacket pkt1, *pkt = &pkt1;
1193 av_read_frame_flush(s);
1194 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1197 ret = av_read_frame(s, pkt);
1200 if (pkt->stream_index == 0 && st->parser &&
1201 (pkt->flags & PKT_FLAG_KEY)) {
1202 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1203 0, 0, AVINDEX_KEYFRAME);
1205 av_free_packet(pkt);
1210 * Returns TRUE if we deal with a raw stream.
1212 * Raw codec data and parsing needed.
1214 static int is_raw_stream(AVFormatContext *s)
1218 if (s->nb_streams != 1)
1221 if (!st->need_parsing)
1227 * Gets the index for a specific timestamp.
1228 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1229 * the timestamp which is <= the requested one, if backward is 0
1230 * then it will be >=
1231 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1232 * @return < 0 if no such timestamp could be found
1234 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1237 AVIndexEntry *entries= st->index_entries;
1238 int nb_entries= st->nb_index_entries;
1247 timestamp = entries[m].timestamp;
1248 if(timestamp >= wanted_timestamp)
1250 if(timestamp <= wanted_timestamp)
1253 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1255 if(!(flags & AVSEEK_FLAG_ANY)){
1256 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1257 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1269 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1270 * this isnt supposed to be called directly by a user application, but by demuxers
1271 * @param target_ts target timestamp in the time base of the given stream
1272 * @param stream_index stream number
1274 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1275 AVInputFormat *avif= s->iformat;
1276 int64_t pos_min, pos_max, pos, pos_limit;
1277 int64_t ts_min, ts_max, ts;
1278 int64_t start_pos, filesize;
1279 int index, no_change;
1282 if (stream_index < 0)
1286 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1290 ts_min= AV_NOPTS_VALUE;
1291 pos_limit= -1; //gcc falsely says it may be uninitalized
1293 st= s->streams[stream_index];
1294 if(st->index_entries){
1297 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()
1298 index= FFMAX(index, 0);
1299 e= &st->index_entries[index];
1301 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1303 ts_min= e->timestamp;
1305 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1312 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1313 assert(index < st->nb_index_entries);
1315 e= &st->index_entries[index];
1316 assert(e->timestamp >= target_ts);
1318 ts_max= e->timestamp;
1319 pos_limit= pos_max - e->min_distance;
1321 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1322 pos_max,pos_limit, ts_max);
1327 if(ts_min == AV_NOPTS_VALUE){
1328 pos_min = s->data_offset;
1329 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1330 if (ts_min == AV_NOPTS_VALUE)
1334 if(ts_max == AV_NOPTS_VALUE){
1336 filesize = url_fsize(&s->pb);
1337 pos_max = filesize - 1;
1340 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1342 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1343 if (ts_max == AV_NOPTS_VALUE)
1347 int64_t tmp_pos= pos_max + 1;
1348 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1349 if(tmp_ts == AV_NOPTS_VALUE)
1353 if(tmp_pos >= filesize)
1359 if(ts_min > ts_max){
1361 }else if(ts_min == ts_max){
1366 while (pos_min < pos_limit) {
1368 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1372 assert(pos_limit <= pos_max);
1375 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1376 // interpolate position (better than dichotomy)
1377 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1378 + pos_min - approximate_keyframe_distance;
1379 }else if(no_change==1){
1380 // bisection, if interpolation failed to change min or max pos last time
1381 pos = (pos_min + pos_limit)>>1;
1383 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1388 else if(pos > pos_limit)
1392 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1398 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);
1400 assert(ts != AV_NOPTS_VALUE);
1401 if (target_ts <= ts) {
1402 pos_limit = start_pos - 1;
1406 if (target_ts >= ts) {
1412 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1413 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1416 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1418 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1419 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1420 pos, ts_min, target_ts, ts_max);
1423 url_fseek(&s->pb, pos, SEEK_SET);
1425 av_update_cur_dts(s, st, ts);
1430 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1431 int64_t pos_min, pos_max;
1435 if (stream_index < 0)
1438 st= s->streams[stream_index];
1441 pos_min = s->data_offset;
1442 pos_max = url_fsize(&s->pb) - 1;
1444 if (pos < pos_min) pos= pos_min;
1445 else if(pos > pos_max) pos= pos_max;
1447 url_fseek(&s->pb, pos, SEEK_SET);
1450 av_update_cur_dts(s, st, ts);
1455 static int av_seek_frame_generic(AVFormatContext *s,
1456 int stream_index, int64_t timestamp, int flags)
1462 if (!s->index_built) {
1463 if (is_raw_stream(s)) {
1464 av_build_index_raw(s);
1471 st = s->streams[stream_index];
1472 index = av_index_search_timestamp(st, timestamp, flags);
1476 /* now we have found the index, we can seek */
1477 ie = &st->index_entries[index];
1478 av_read_frame_flush(s);
1479 url_fseek(&s->pb, ie->pos, SEEK_SET);
1481 av_update_cur_dts(s, st, ie->timestamp);
1487 * Seek to the key frame at timestamp.
1488 * 'timestamp' in 'stream_index'.
1489 * @param stream_index If stream_index is (-1), a default
1490 * stream is selected, and timestamp is automatically converted
1491 * from AV_TIME_BASE units to the stream specific time_base.
1492 * @param timestamp timestamp in AVStream.time_base units
1493 * or if there is no stream specified then in AV_TIME_BASE units
1494 * @param flags flags which select direction and seeking mode
1495 * @return >= 0 on success
1497 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1502 av_read_frame_flush(s);
1504 if(flags & AVSEEK_FLAG_BYTE)
1505 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1507 if(stream_index < 0){
1508 stream_index= av_find_default_stream_index(s);
1509 if(stream_index < 0)
1512 st= s->streams[stream_index];
1513 /* timestamp for default must be expressed in AV_TIME_BASE units */
1514 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1516 st= s->streams[stream_index];
1518 /* first, we try the format specific seek */
1519 if (s->iformat->read_seek)
1520 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1527 if(s->iformat->read_timestamp)
1528 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1530 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1533 /*******************************************************/
1536 * Returns TRUE if the stream has accurate timings in any stream.
1538 * @return TRUE if the stream has accurate timings for at least one component.
1540 static int av_has_timings(AVFormatContext *ic)
1545 for(i = 0;i < ic->nb_streams; i++) {
1546 st = ic->streams[i];
1547 if (st->start_time != AV_NOPTS_VALUE &&
1548 st->duration != AV_NOPTS_VALUE)
1555 * Estimate the stream timings from the one of each components.
1557 * Also computes the global bitrate if possible.
1559 static void av_update_stream_timings(AVFormatContext *ic)
1561 int64_t start_time, start_time1, end_time, end_time1;
1565 start_time = MAXINT64;
1566 end_time = MININT64;
1567 for(i = 0;i < ic->nb_streams; i++) {
1568 st = ic->streams[i];
1569 if (st->start_time != AV_NOPTS_VALUE) {
1570 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1571 if (start_time1 < start_time)
1572 start_time = start_time1;
1573 if (st->duration != AV_NOPTS_VALUE) {
1574 end_time1 = start_time1
1575 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1576 if (end_time1 > end_time)
1577 end_time = end_time1;
1581 if (start_time != MAXINT64) {
1582 ic->start_time = start_time;
1583 if (end_time != MININT64) {
1584 ic->duration = end_time - start_time;
1585 if (ic->file_size > 0) {
1586 /* compute the bit rate */
1587 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1588 (double)ic->duration;
1595 static void fill_all_stream_timings(AVFormatContext *ic)
1600 av_update_stream_timings(ic);
1601 for(i = 0;i < ic->nb_streams; i++) {
1602 st = ic->streams[i];
1603 if (st->start_time == AV_NOPTS_VALUE) {
1604 if(ic->start_time != AV_NOPTS_VALUE)
1605 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1606 if(ic->duration != AV_NOPTS_VALUE)
1607 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1612 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1614 int64_t filesize, duration;
1618 /* if bit_rate is already set, we believe it */
1619 if (ic->bit_rate == 0) {
1621 for(i=0;i<ic->nb_streams;i++) {
1622 st = ic->streams[i];
1623 bit_rate += st->codec->bit_rate;
1625 ic->bit_rate = bit_rate;
1628 /* if duration is already set, we believe it */
1629 if (ic->duration == AV_NOPTS_VALUE &&
1630 ic->bit_rate != 0 &&
1631 ic->file_size != 0) {
1632 filesize = ic->file_size;
1634 for(i = 0; i < ic->nb_streams; i++) {
1635 st = ic->streams[i];
1636 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1637 if (st->start_time == AV_NOPTS_VALUE ||
1638 st->duration == AV_NOPTS_VALUE) {
1640 st->duration = duration;
1647 #define DURATION_MAX_READ_SIZE 250000
1649 /* only usable for MPEG-PS streams */
1650 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1652 AVPacket pkt1, *pkt = &pkt1;
1654 int read_size, i, ret;
1656 int64_t filesize, offset, duration;
1658 /* free previous packet */
1659 if (ic->cur_st && ic->cur_st->parser)
1660 av_free_packet(&ic->cur_pkt);
1663 /* flush packet queue */
1664 flush_packet_queue(ic);
1666 for(i=0;i<ic->nb_streams;i++) {
1667 st = ic->streams[i];
1669 av_parser_close(st->parser);
1674 /* we read the first packets to get the first PTS (not fully
1675 accurate, but it is enough now) */
1676 url_fseek(&ic->pb, 0, SEEK_SET);
1679 if (read_size >= DURATION_MAX_READ_SIZE)
1681 /* if all info is available, we can stop */
1682 for(i = 0;i < ic->nb_streams; i++) {
1683 st = ic->streams[i];
1684 if (st->start_time == AV_NOPTS_VALUE)
1687 if (i == ic->nb_streams)
1690 ret = av_read_packet(ic, pkt);
1693 read_size += pkt->size;
1694 st = ic->streams[pkt->stream_index];
1695 if (pkt->pts != AV_NOPTS_VALUE) {
1696 if (st->start_time == AV_NOPTS_VALUE)
1697 st->start_time = pkt->pts;
1699 av_free_packet(pkt);
1702 /* estimate the end time (duration) */
1703 /* XXX: may need to support wrapping */
1704 filesize = ic->file_size;
1705 offset = filesize - DURATION_MAX_READ_SIZE;
1709 url_fseek(&ic->pb, offset, SEEK_SET);
1712 if (read_size >= DURATION_MAX_READ_SIZE)
1714 /* if all info is available, we can stop */
1715 for(i = 0;i < ic->nb_streams; i++) {
1716 st = ic->streams[i];
1717 if (st->duration == AV_NOPTS_VALUE)
1720 if (i == ic->nb_streams)
1723 ret = av_read_packet(ic, pkt);
1726 read_size += pkt->size;
1727 st = ic->streams[pkt->stream_index];
1728 if (pkt->pts != AV_NOPTS_VALUE) {
1729 end_time = pkt->pts;
1730 duration = end_time - st->start_time;
1732 if (st->duration == AV_NOPTS_VALUE ||
1733 st->duration < duration)
1734 st->duration = duration;
1737 av_free_packet(pkt);
1740 fill_all_stream_timings(ic);
1742 url_fseek(&ic->pb, 0, SEEK_SET);
1745 static void av_estimate_timings(AVFormatContext *ic)
1749 /* get the file size, if possible */
1750 if (ic->iformat->flags & AVFMT_NOFILE) {
1753 file_size = url_fsize(&ic->pb);
1757 ic->file_size = file_size;
1759 if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
1760 /* get accurate estimate from the PTSes */
1761 av_estimate_timings_from_pts(ic);
1762 } else if (av_has_timings(ic)) {
1763 /* at least one components has timings - we use them for all
1765 fill_all_stream_timings(ic);
1767 /* less precise: use bit rate info */
1768 av_estimate_timings_from_bit_rate(ic);
1770 av_update_stream_timings(ic);
1776 for(i = 0;i < ic->nb_streams; i++) {
1777 st = ic->streams[i];
1778 printf("%d: start_time: %0.3f duration: %0.3f\n",
1779 i, (double)st->start_time / AV_TIME_BASE,
1780 (double)st->duration / AV_TIME_BASE);
1782 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1783 (double)ic->start_time / AV_TIME_BASE,
1784 (double)ic->duration / AV_TIME_BASE,
1785 ic->bit_rate / 1000);
1790 static int has_codec_parameters(AVCodecContext *enc)
1793 switch(enc->codec_type) {
1794 case CODEC_TYPE_AUDIO:
1795 val = enc->sample_rate;
1797 case CODEC_TYPE_VIDEO:
1798 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1807 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1811 int got_picture, ret=0;
1814 if(!st->codec->codec){
1815 codec = avcodec_find_decoder(st->codec->codec_id);
1818 ret = avcodec_open(st->codec, codec);
1823 if(!has_codec_parameters(st->codec)){
1824 switch(st->codec->codec_type) {
1825 case CODEC_TYPE_VIDEO:
1826 ret = avcodec_decode_video(st->codec, &picture,
1827 &got_picture, (uint8_t *)data, size);
1829 case CODEC_TYPE_AUDIO:
1830 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1833 ret = avcodec_decode_audio(st->codec, samples,
1834 &got_picture, (uint8_t *)data, size);
1845 /* absolute maximum size we read until we abort */
1846 #define MAX_READ_SIZE 5000000
1848 /* maximum duration until we stop analysing the stream */
1849 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 2.0))
1852 * Read the beginning of a media file to get stream information. This
1853 * is useful for file formats with no headers such as MPEG. This
1854 * function also compute the real frame rate in case of mpeg2 repeat
1857 * @param ic media file handle
1858 * @return >=0 if OK. AVERROR_xxx if error.
1859 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1861 int av_find_stream_info(AVFormatContext *ic)
1863 int i, count, ret, read_size, j;
1865 AVPacket pkt1, *pkt;
1866 AVPacketList *pktl=NULL, **ppktl;
1867 int64_t last_dts[MAX_STREAMS];
1868 int64_t duration_sum[MAX_STREAMS];
1869 int duration_count[MAX_STREAMS]={0};
1871 for(i=0;i<ic->nb_streams;i++) {
1872 st = ic->streams[i];
1873 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1874 /* if(!st->time_base.num)
1876 if(!st->codec->time_base.num)
1877 st->codec->time_base= st->time_base;
1879 //only for the split stuff
1881 st->parser = av_parser_init(st->codec->codec_id);
1882 if(st->need_parsing == 2 && st->parser){
1883 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1888 for(i=0;i<MAX_STREAMS;i++){
1889 last_dts[i]= AV_NOPTS_VALUE;
1890 duration_sum[i]= INT64_MAX;
1895 ppktl = &ic->packet_buffer;
1897 /* check if one codec still needs to be handled */
1898 for(i=0;i<ic->nb_streams;i++) {
1899 st = ic->streams[i];
1900 if (!has_codec_parameters(st->codec))
1902 /* variable fps and no guess at the real fps */
1903 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1904 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1906 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1909 if (i == ic->nb_streams) {
1910 /* NOTE: if the format has no header, then we need to read
1911 some packets to get most of the streams, so we cannot
1913 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1914 /* if we found the info for all the codecs, we can stop */
1919 /* we did not get all the codec info, but we read too much data */
1920 if (read_size >= MAX_READ_SIZE) {
1926 /* NOTE: a new stream can be added there if no header in file
1927 (AVFMTCTX_NOHEADER) */
1928 ret = av_read_frame_internal(ic, &pkt1);
1931 ret = -1; /* we could not have all the codec parameters before EOF */
1932 for(i=0;i<ic->nb_streams;i++) {
1933 st = ic->streams[i];
1934 if (!has_codec_parameters(st->codec)){
1936 avcodec_string(buf, sizeof(buf), st->codec, 0);
1937 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1941 if (i == ic->nb_streams)
1946 pktl = av_mallocz(sizeof(AVPacketList));
1948 ret = AVERROR_NOMEM;
1952 /* add the packet in the buffered packet list */
1954 ppktl = &pktl->next;
1959 /* duplicate the packet */
1960 if (av_dup_packet(pkt) < 0) {
1961 ret = AVERROR_NOMEM;
1965 read_size += pkt->size;
1967 st = ic->streams[pkt->stream_index];
1968 st->codec_info_duration += pkt->duration;
1969 if (pkt->duration != 0)
1970 st->codec_info_nb_frames++;
1973 int index= pkt->stream_index;
1974 int64_t last= last_dts[index];
1975 int64_t duration= pkt->dts - last;
1977 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1978 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1979 duration_sum[index]= duration;
1980 duration_count[index]=1;
1982 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1983 duration_sum[index] += duration;
1984 duration_count[index]+= factor;
1986 if(st->codec_info_nb_frames == 0 && 0)
1987 st->codec_info_duration += duration;
1989 last_dts[pkt->stream_index]= pkt->dts;
1991 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1992 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1994 st->codec->extradata_size= i;
1995 st->codec->extradata= av_malloc(st->codec->extradata_size);
1996 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2000 /* if still no information, we try to open the codec and to
2001 decompress the frame. We try to avoid that in most cases as
2002 it takes longer and uses more memory. For MPEG4, we need to
2003 decompress for Quicktime. */
2004 if (!has_codec_parameters(st->codec) /*&&
2005 (st->codec->codec_id == CODEC_ID_FLV1 ||
2006 st->codec->codec_id == CODEC_ID_H264 ||
2007 st->codec->codec_id == CODEC_ID_H263 ||
2008 st->codec->codec_id == CODEC_ID_H261 ||
2009 st->codec->codec_id == CODEC_ID_VORBIS ||
2010 st->codec->codec_id == CODEC_ID_MJPEG ||
2011 st->codec->codec_id == CODEC_ID_PNG ||
2012 st->codec->codec_id == CODEC_ID_PAM ||
2013 st->codec->codec_id == CODEC_ID_PGM ||
2014 st->codec->codec_id == CODEC_ID_PGMYUV ||
2015 st->codec->codec_id == CODEC_ID_PBM ||
2016 st->codec->codec_id == CODEC_ID_PPM ||
2017 st->codec->codec_id == CODEC_ID_SHORTEN ||
2018 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2019 try_decode_frame(st, pkt->data, pkt->size);
2021 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2027 // close codecs which where opened in try_decode_frame()
2028 for(i=0;i<ic->nb_streams;i++) {
2029 st = ic->streams[i];
2030 if(st->codec->codec)
2031 avcodec_close(st->codec);
2033 for(i=0;i<ic->nb_streams;i++) {
2034 st = ic->streams[i];
2035 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2036 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2037 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2039 if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2040 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2041 int64_t num, den, error, best_error;
2043 num= st->time_base.den*duration_count[i];
2044 den= st->time_base.num*duration_sum[i];
2046 best_error= INT64_MAX;
2047 for(j=1; j<60*12; j++){
2048 error= ABS(1001*12*num - 1001*j*den);
2049 if(error < best_error){
2051 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2054 for(j=24; j<=30; j+=6){
2055 error= ABS(1001*12*num - 1000*12*j*den);
2056 if(error < best_error){
2058 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2063 /* set real frame rate info */
2064 /* compute the real frame rate for telecine */
2065 if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2066 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2067 st->codec->sub_id == 2) {
2068 if (st->codec_info_nb_frames >= 20) {
2069 float coded_frame_rate, est_frame_rate;
2070 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2071 (double)st->codec_info_duration ;
2072 coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2074 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2075 coded_frame_rate, est_frame_rate);
2077 /* if we detect that it could be a telecine, we
2078 signal it. It would be better to do it at a
2079 higher level as it can change in a film */
2080 if (coded_frame_rate >= 24.97 &&
2081 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2082 st->r_frame_rate = (AVRational){24000, 1001};
2086 /* if no real frame rate, use the codec one */
2087 if (!st->r_frame_rate.num){
2088 st->r_frame_rate.num = st->codec->time_base.den;
2089 st->r_frame_rate.den = st->codec->time_base.num;
2094 av_estimate_timings(ic);
2096 /* correct DTS for b frame streams with no timestamps */
2097 for(i=0;i<ic->nb_streams;i++) {
2098 st = ic->streams[i];
2099 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2101 ppktl = &ic->packet_buffer;
2103 if(ppkt1->stream_index != i)
2105 if(ppkt1->pkt->dts < 0)
2107 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2109 ppkt1->pkt->dts -= delta;
2114 st->cur_dts -= delta;
2122 /*******************************************************/
2125 * start playing a network based stream (e.g. RTSP stream) at the
2128 int av_read_play(AVFormatContext *s)
2130 if (!s->iformat->read_play)
2131 return AVERROR_NOTSUPP;
2132 return s->iformat->read_play(s);
2136 * Pause a network based stream (e.g. RTSP stream).
2138 * Use av_read_play() to resume it.
2140 int av_read_pause(AVFormatContext *s)
2142 if (!s->iformat->read_pause)
2143 return AVERROR_NOTSUPP;
2144 return s->iformat->read_pause(s);
2148 * Close a media file (but not its codecs).
2150 * @param s media file handle
2152 void av_close_input_file(AVFormatContext *s)
2154 int i, must_open_file;
2157 /* free previous packet */
2158 if (s->cur_st && s->cur_st->parser)
2159 av_free_packet(&s->cur_pkt);
2161 if (s->iformat->read_close)
2162 s->iformat->read_close(s);
2163 for(i=0;i<s->nb_streams;i++) {
2164 /* free all data in a stream component */
2167 av_parser_close(st->parser);
2169 av_free(st->index_entries);
2170 av_free(st->codec->extradata);
2174 flush_packet_queue(s);
2176 if (s->iformat->flags & AVFMT_NOFILE) {
2179 if (must_open_file) {
2182 av_freep(&s->priv_data);
2187 * Add a new stream to a media file.
2189 * Can only be called in the read_header() function. If the flag
2190 * AVFMTCTX_NOHEADER is in the format context, then new streams
2191 * can be added in read_packet too.
2193 * @param s media file handle
2194 * @param id file format dependent stream id
2196 AVStream *av_new_stream(AVFormatContext *s, int id)
2200 if (s->nb_streams >= MAX_STREAMS)
2203 st = av_mallocz(sizeof(AVStream));
2207 st->codec= avcodec_alloc_context();
2209 /* no default bitrate if decoding */
2210 st->codec->bit_rate = 0;
2212 st->index = s->nb_streams;
2214 st->start_time = AV_NOPTS_VALUE;
2215 st->duration = AV_NOPTS_VALUE;
2216 st->cur_dts = AV_NOPTS_VALUE;
2218 /* default pts settings is MPEG like */
2219 av_set_pts_info(st, 33, 1, 90000);
2220 st->last_IP_pts = AV_NOPTS_VALUE;
2222 s->streams[s->nb_streams++] = st;
2226 /************************************************************/
2227 /* output media file */
2229 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2233 if (s->oformat->priv_data_size > 0) {
2234 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2236 return AVERROR_NOMEM;
2238 s->priv_data = NULL;
2240 if (s->oformat->set_parameters) {
2241 ret = s->oformat->set_parameters(s, ap);
2249 * allocate the stream private data and write the stream header to an
2252 * @param s media file handle
2253 * @return 0 if OK. AVERROR_xxx if error.
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");
2284 if(s->oformat->write_header){
2285 ret = s->oformat->write_header(s);
2290 /* init PTS generation */
2291 for(i=0;i<s->nb_streams;i++) {
2292 int64_t den = AV_NOPTS_VALUE;
2295 switch (st->codec->codec_type) {
2296 case CODEC_TYPE_AUDIO:
2297 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2299 case CODEC_TYPE_VIDEO:
2300 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2305 if (den != AV_NOPTS_VALUE) {
2307 return AVERROR_INVALIDDATA;
2308 av_frac_init(&st->pts, 0, 0, den);
2314 //FIXME merge with compute_pkt_fields
2315 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2316 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2317 int num, den, frame_size;
2319 // 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);
2321 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2324 /* duration field */
2325 if (pkt->duration == 0) {
2326 compute_frame_duration(&num, &den, st, NULL, pkt);
2328 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2332 //XXX/FIXME this is a temporary hack until all encoders output pts
2333 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2335 // pkt->pts= st->cur_dts;
2336 pkt->pts= st->pts.val;
2339 //calculate dts from pts
2340 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2342 if(st->last_IP_pts == AV_NOPTS_VALUE){
2343 st->last_IP_pts= -pkt->duration;
2345 if(st->last_IP_pts < pkt->pts){
2346 pkt->dts= st->last_IP_pts;
2347 st->last_IP_pts= pkt->pts;
2354 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2355 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2358 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2359 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2363 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2364 st->cur_dts= pkt->dts;
2365 st->pts.val= pkt->dts;
2368 switch (st->codec->codec_type) {
2369 case CODEC_TYPE_AUDIO:
2370 frame_size = get_audio_frame_size(st->codec, pkt->size);
2372 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2373 but it would be better if we had the real timestamps from the encoder */
2374 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2375 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2378 case CODEC_TYPE_VIDEO:
2379 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2387 static void truncate_ts(AVStream *st, AVPacket *pkt){
2388 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2391 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2393 pkt->pts &= pts_mask;
2394 pkt->dts &= pts_mask;
2398 * Write a packet to an output media file.
2400 * The packet shall contain one audio or video frame.
2402 * @param s media file handle
2403 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2404 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2406 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2410 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2414 truncate_ts(s->streams[pkt->stream_index], pkt);
2416 ret= s->oformat->write_packet(s, pkt);
2418 ret= url_ferror(&s->pb);
2423 * interleave_packet implementation which will interleave per DTS.
2424 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2425 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2427 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2428 AVPacketList *pktl, **next_point, *this_pktl;
2430 int streams[MAX_STREAMS];
2433 AVStream *st= s->streams[ pkt->stream_index];
2435 // assert(pkt->destruct != av_destruct_packet); //FIXME
2437 this_pktl = av_mallocz(sizeof(AVPacketList));
2438 this_pktl->pkt= *pkt;
2439 if(pkt->destruct == av_destruct_packet)
2440 pkt->destruct= NULL; // non shared -> must keep original from being freed
2442 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2444 next_point = &s->packet_buffer;
2446 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2447 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2448 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2449 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2451 next_point= &(*next_point)->next;
2453 this_pktl->next= *next_point;
2454 *next_point= this_pktl;
2457 memset(streams, 0, sizeof(streams));
2458 pktl= s->packet_buffer;
2460 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2461 if(streams[ pktl->pkt.stream_index ] == 0)
2463 streams[ pktl->pkt.stream_index ]++;
2467 if(s->nb_streams == stream_count || (flush && stream_count)){
2468 pktl= s->packet_buffer;
2471 s->packet_buffer= pktl->next;
2475 av_init_packet(out);
2481 * Interleaves a AVPacket correctly so it can be muxed.
2482 * @param out the interleaved packet will be output here
2483 * @param in the input packet
2484 * @param flush 1 if no further packets are available as input and all
2485 * remaining packets should be output
2486 * @return 1 if a packet was output, 0 if no packet could be output,
2487 * < 0 if an error occured
2489 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2490 if(s->oformat->interleave_packet)
2491 return s->oformat->interleave_packet(s, out, in, flush);
2493 return av_interleave_packet_per_dts(s, out, in, flush);
2497 * Writes a packet to an output media file ensuring correct interleaving.
2499 * The packet must contain one audio or video frame.
2500 * If the packets are already correctly interleaved the application should
2501 * call av_write_frame() instead as its slightly faster, its also important
2502 * to keep in mind that completly non interleaved input will need huge amounts
2503 * of memory to interleave with this, so its prefereable to interleave at the
2506 * @param s media file handle
2507 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2508 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2510 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2511 AVStream *st= s->streams[ pkt->stream_index];
2513 //FIXME/XXX/HACK drop zero sized packets
2514 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2517 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2518 if(compute_pkt_fields2(st, pkt) < 0)
2521 if(pkt->dts == AV_NOPTS_VALUE)
2526 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2527 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2530 truncate_ts(s->streams[opkt.stream_index], &opkt);
2531 ret= s->oformat->write_packet(s, &opkt);
2533 av_free_packet(&opkt);
2538 if(url_ferror(&s->pb))
2539 return url_ferror(&s->pb);
2544 * @brief Write the stream trailer to an output media file and
2545 * free the file private data.
2547 * @param s media file handle
2548 * @return 0 if OK. AVERROR_xxx if error.
2550 int av_write_trailer(AVFormatContext *s)
2556 ret= av_interleave_packet(s, &pkt, NULL, 1);
2557 if(ret<0) //FIXME cleanup needed for ret<0 ?
2562 truncate_ts(s->streams[pkt.stream_index], &pkt);
2563 ret= s->oformat->write_packet(s, &pkt);
2565 av_free_packet(&pkt);
2569 if(url_ferror(&s->pb))
2573 if(s->oformat->write_trailer)
2574 ret = s->oformat->write_trailer(s);
2577 ret=url_ferror(&s->pb);
2578 for(i=0;i<s->nb_streams;i++)
2579 av_freep(&s->streams[i]->priv_data);
2580 av_freep(&s->priv_data);
2584 /* "user interface" functions */
2586 void dump_format(AVFormatContext *ic,
2594 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2595 is_output ? "Output" : "Input",
2597 is_output ? ic->oformat->name : ic->iformat->name,
2598 is_output ? "to" : "from", url);
2600 av_log(NULL, AV_LOG_INFO, " Duration: ");
2601 if (ic->duration != AV_NOPTS_VALUE) {
2602 int hours, mins, secs, us;
2603 secs = ic->duration / AV_TIME_BASE;
2604 us = ic->duration % AV_TIME_BASE;
2609 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2610 (10 * us) / AV_TIME_BASE);
2612 av_log(NULL, AV_LOG_INFO, "N/A");
2614 if (ic->start_time != AV_NOPTS_VALUE) {
2616 av_log(NULL, AV_LOG_INFO, ", start: ");
2617 secs = ic->start_time / AV_TIME_BASE;
2618 us = ic->start_time % AV_TIME_BASE;
2619 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2620 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2622 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2624 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2626 av_log(NULL, AV_LOG_INFO, "N/A");
2628 av_log(NULL, AV_LOG_INFO, "\n");
2630 for(i=0;i<ic->nb_streams;i++) {
2631 AVStream *st = ic->streams[i];
2632 int g= ff_gcd(st->time_base.num, st->time_base.den);
2633 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2634 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2635 /* the pid is an important information, so we display it */
2636 /* XXX: add a generic system */
2638 flags = ic->oformat->flags;
2640 flags = ic->iformat->flags;
2641 if (flags & AVFMT_SHOW_IDS) {
2642 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2644 if (strlen(st->language) > 0) {
2645 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2647 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2648 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2649 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2650 if(st->r_frame_rate.den && st->r_frame_rate.num)
2651 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2652 /* else if(st->time_base.den && st->time_base.num)
2653 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2655 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2657 av_log(NULL, AV_LOG_INFO, "\n");
2664 int frame_rate, frame_rate_base;
2667 static AbvEntry frame_abvs[] = {
2668 { "ntsc", 720, 480, 30000, 1001 },
2669 { "pal", 720, 576, 25, 1 },
2670 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2671 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2672 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2673 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2674 { "film", 352, 240, 24, 1 },
2675 { "ntsc-film", 352, 240, 24000, 1001 },
2676 { "sqcif", 128, 96, 0, 0 },
2677 { "qcif", 176, 144, 0, 0 },
2678 { "cif", 352, 288, 0, 0 },
2679 { "4cif", 704, 576, 0, 0 },
2683 * parses width and height out of string str.
2685 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2688 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2690 int frame_width = 0, frame_height = 0;
2693 if (!strcmp(frame_abvs[i].abv, str)) {
2694 frame_width = frame_abvs[i].width;
2695 frame_height = frame_abvs[i].height;
2701 frame_width = strtol(p, (char **)&p, 10);
2704 frame_height = strtol(p, (char **)&p, 10);
2706 if (frame_width <= 0 || frame_height <= 0)
2708 *width_ptr = frame_width;
2709 *height_ptr = frame_height;
2714 * Converts frame rate from string to a fraction.
2716 * First we try to get an exact integer or fractional frame rate.
2717 * If this fails we convert the frame rate to a double and return
2718 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2720 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2725 /* First, we check our abbreviation table */
2726 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2727 if (!strcmp(frame_abvs[i].abv, arg)) {
2728 *frame_rate = frame_abvs[i].frame_rate;
2729 *frame_rate_base = frame_abvs[i].frame_rate_base;
2733 /* Then, we try to parse it as fraction */
2734 cp = strchr(arg, '/');
2736 cp = strchr(arg, ':');
2739 *frame_rate = strtol(arg, &cpp, 10);
2740 if (cpp != arg || cpp == cp)
2741 *frame_rate_base = strtol(cp+1, &cpp, 10);
2746 /* Finally we give up and parse it as double */
2747 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2748 *frame_rate_base = time_base.den;
2749 *frame_rate = time_base.num;
2751 if (!*frame_rate || !*frame_rate_base)
2758 * Converts date string to number of seconds since Jan 1st, 1970.
2762 * - If not a duration:
2763 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2764 * Time is localtime unless Z is suffixed to the end. In this case GMT
2765 * Return the date in micro seconds since 1970
2768 * HH[:MM[:SS[.m...]]]
2772 #ifndef CONFIG_WINCE
2773 int64_t parse_date(const char *datestr, int duration)
2779 static const char *date_fmt[] = {
2783 static const char *time_fmt[] = {
2793 time_t now = time(0);
2795 len = strlen(datestr);
2797 lastch = datestr[len - 1];
2800 is_utc = (lastch == 'z' || lastch == 'Z');
2802 memset(&dt, 0, sizeof(dt));
2807 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2808 q = small_strptime(p, date_fmt[i], &dt);
2818 dt = *localtime(&now);
2820 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2825 if (*p == 'T' || *p == 't' || *p == ' ')
2828 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2829 q = small_strptime(p, time_fmt[i], &dt);
2839 q = small_strptime(p, time_fmt[0], &dt);
2841 dt.tm_sec = strtol(p, (char **)&q, 10);
2847 /* Now we have all the fields that we can get */
2852 return now * int64_t_C(1000000);
2856 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2858 dt.tm_isdst = -1; /* unknown */
2871 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2874 val += n * (*q - '0');
2878 return negative ? -t : t;
2880 #endif /* CONFIG_WINCE */
2883 * Attempts to find a specific tag in a URL.
2885 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2886 * Return 1 if found.
2888 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2898 while (*p != '\0' && *p != '=' && *p != '&') {
2899 if ((q - tag) < sizeof(tag) - 1)
2907 while (*p != '&' && *p != '\0') {
2908 if ((q - arg) < arg_size - 1) {
2918 if (!strcmp(tag, tag1))
2928 * Returns in 'buf' the path with '%d' replaced by number.
2930 * Also handles the '%0nd' format where 'n' is the total number
2931 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2933 int get_frame_filename(char *buf, int buf_size,
2934 const char *path, int number)
2937 char *q, buf1[20], c;
2938 int nd, len, percentd_found;
2950 while (isdigit(*p)) {
2951 nd = nd * 10 + *p++ - '0';
2954 } while (isdigit(c));
2963 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2965 if ((q - buf + len) > buf_size - 1)
2967 memcpy(q, buf1, len);
2975 if ((q - buf) < buf_size - 1)
2979 if (!percentd_found)
2989 * Print nice hexa dump of a buffer
2990 * @param f stream for output
2992 * @param size buffer size
2994 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2998 for(i=0;i<size;i+=16) {
3002 fprintf(f, "%08x ", i);
3005 fprintf(f, " %02x", buf[i+j]);
3010 for(j=0;j<len;j++) {
3012 if (c < ' ' || c > '~')
3014 fprintf(f, "%c", c);
3021 * Print on 'f' a nice dump of a packet
3022 * @param f stream for output
3023 * @param pkt packet to dump
3024 * @param dump_payload true if the payload must be displayed too
3026 //FIXME needs to know the time_base
3027 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3029 fprintf(f, "stream #%d:\n", pkt->stream_index);
3030 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3031 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3032 /* DTS is _always_ valid after av_read_frame() */
3033 fprintf(f, " dts=");
3034 if (pkt->dts == AV_NOPTS_VALUE)
3037 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3038 /* PTS may be not known if B frames are present */
3039 fprintf(f, " pts=");
3040 if (pkt->pts == AV_NOPTS_VALUE)
3043 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3045 fprintf(f, " size=%d\n", pkt->size);
3047 av_hex_dump(f, pkt->data, pkt->size);
3050 void url_split(char *proto, int proto_size,
3051 char *authorization, int authorization_size,
3052 char *hostname, int hostname_size,
3054 char *path, int path_size,
3065 while (*p != ':' && *p != '\0') {
3066 if ((q - proto) < proto_size - 1)
3072 if (authorization_size > 0)
3073 authorization[0] = '\0';
3077 if (hostname_size > 0)
3081 char *at,*slash; // PETR: position of '@' character and '/' character
3088 at = strchr(p,'@'); // PETR: get the position of '@'
3089 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3090 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3092 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3094 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3095 if (*p == '@') { // PETR: passed '@'
3096 if (authorization_size > 0)
3100 } else if (!at) { // PETR: hostname
3101 if ((q - hostname) < hostname_size - 1)
3104 if ((q - authorization) < authorization_size - 1)
3109 if (hostname_size > 0)
3113 port = strtoul(p, (char **)&p, 10);
3118 pstrcpy(path, path_size, p);
3122 * Set the pts for a given stream.
3125 * @param pts_wrap_bits number of bits effectively used by the pts
3126 * (used for wrap control, 33 is the value for MPEG)
3127 * @param pts_num numerator to convert to seconds (MPEG: 1)
3128 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3130 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3131 int pts_num, int pts_den)
3133 s->pts_wrap_bits = pts_wrap_bits;
3134 s->time_base.num = pts_num;
3135 s->time_base.den = pts_den;
3138 /* fraction handling */
3141 * f = val + (num / den) + 0.5.
3143 * 'num' is normalized so that it is such as 0 <= num < den.
3145 * @param f fractional number
3146 * @param val integer value
3147 * @param num must be >= 0
3148 * @param den must be >= 1
3150 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3163 * Set f to (val + 0.5).
3165 void av_frac_set(AVFrac *f, int64_t val)
3168 f->num = f->den >> 1;
3172 * Fractionnal addition to f: f = f + (incr / f->den).
3174 * @param f fractional number
3175 * @param incr increment, can be positive or negative
3177 void av_frac_add(AVFrac *f, int64_t incr)
3181 num = f->num + incr;
3184 f->val += num / den;
3190 } else if (num >= den) {
3191 f->val += num / den;
3198 * register a new image format
3199 * @param img_fmt Image format descriptor
3201 void av_register_image_format(AVImageFormat *img_fmt)
3205 p = &first_image_format;
3206 while (*p != NULL) p = &(*p)->next;
3208 img_fmt->next = NULL;
3212 * Guesses image format based on data in the image.
3214 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3216 AVImageFormat *fmt1, *fmt;
3217 int score, score_max;
3221 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3222 if (fmt1->img_probe) {
3223 score = fmt1->img_probe(pd);
3224 if (score > score_max) {
3234 * Guesses image format based on file name extensions.
3236 AVImageFormat *guess_image_format(const char *filename)
3238 AVImageFormat *fmt1;
3240 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3241 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3248 * Read an image from a stream.
3249 * @param gb byte stream containing the image
3250 * @param fmt image format, NULL if probing is required
3252 int av_read_image(ByteIOContext *pb, const char *filename,
3254 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3256 uint8_t buf[PROBE_BUF_MIN];
3257 AVProbeData probe_data, *pd = &probe_data;
3262 pd->filename = filename;
3264 pos = url_ftell(pb);
3265 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3266 url_fseek(pb, pos, SEEK_SET);
3267 fmt = av_probe_image_format(pd);
3270 return AVERROR_NOFMT;
3271 ret = fmt->img_read(pb, alloc_cb, opaque);
3276 * Write an image to a stream.
3277 * @param pb byte stream for the image output
3278 * @param fmt image format
3279 * @param img image data and informations
3281 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3283 return fmt->img_write(pb, img);