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];
924 if(st->codec->debug & FF_DEBUG_PTS)
925 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%lld, dts=%lld, size=%d\n",
926 s->cur_pkt.stream_index,
932 s->cur_ptr = s->cur_pkt.data;
933 s->cur_len = s->cur_pkt.size;
934 if (st->need_parsing && !st->parser) {
935 st->parser = av_parser_init(st->codec->codec_id);
937 /* no parser available : just output the raw packets */
938 st->need_parsing = 0;
939 }else if(st->need_parsing == 2){
940 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
945 if(st->codec->debug & FF_DEBUG_PTS)
946 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%lld, dts=%lld, size=%d\n",
956 * Return the next frame of a stream.
958 * The returned packet is valid
959 * until the next av_read_frame() or until av_close_input_file() and
960 * must be freed with av_free_packet. For video, the packet contains
961 * exactly one frame. For audio, it contains an integer number of
962 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
963 * data). If the audio frames have a variable size (e.g. MPEG audio),
964 * then it contains one frame.
966 * pkt->pts, pkt->dts and pkt->duration are always set to correct
967 * values in AV_TIME_BASE unit (and guessed if the format cannot
968 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
969 * has B frames, so it is better to rely on pkt->dts if you do not
970 * decompress the payload.
972 * @return 0 if OK, < 0 if error or end of file.
974 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
978 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
981 pktl = s->packet_buffer;
983 AVPacket *next_pkt= &pktl->pkt;
985 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
986 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
987 if( pktl->pkt.stream_index == next_pkt->stream_index
988 && next_pkt->dts < pktl->pkt.dts
989 && pktl->pkt.pts != pktl->pkt.dts //not b frame
990 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
991 next_pkt->pts= pktl->pkt.dts;
995 pktl = s->packet_buffer;
998 if( next_pkt->pts != AV_NOPTS_VALUE
999 || next_pkt->dts == AV_NOPTS_VALUE
1001 /* read packet from packet buffer, if there is data */
1003 s->packet_buffer = pktl->next;
1009 AVPacketList **plast_pktl= &s->packet_buffer;
1010 int ret= av_read_frame_internal(s, pkt);
1012 if(pktl && ret != -EAGAIN){
1019 /* duplicate the packet */
1020 if (av_dup_packet(pkt) < 0)
1021 return AVERROR_NOMEM;
1023 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1025 pktl = av_mallocz(sizeof(AVPacketList));
1027 return AVERROR_NOMEM;
1029 /* add the packet in the buffered packet list */
1033 assert(!s->packet_buffer);
1034 return av_read_frame_internal(s, pkt);
1039 /* XXX: suppress the packet queue */
1040 static void flush_packet_queue(AVFormatContext *s)
1045 pktl = s->packet_buffer;
1048 s->packet_buffer = pktl->next;
1049 av_free_packet(&pktl->pkt);
1054 /*******************************************************/
1057 int av_find_default_stream_index(AVFormatContext *s)
1062 if (s->nb_streams <= 0)
1064 for(i = 0; i < s->nb_streams; i++) {
1066 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1074 * Flush the frame reader.
1076 static void av_read_frame_flush(AVFormatContext *s)
1081 flush_packet_queue(s);
1083 /* free previous packet */
1085 if (s->cur_st->parser)
1086 av_free_packet(&s->cur_pkt);
1093 /* for each stream, reset read state */
1094 for(i = 0; i < s->nb_streams; i++) {
1098 av_parser_close(st->parser);
1101 st->last_IP_pts = AV_NOPTS_VALUE;
1102 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1107 * Updates cur_dts of all streams based on given timestamp and AVStream.
1109 * Stream ref_st unchanged, others set cur_dts in their native timebase
1110 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1111 * @param timestamp new dts expressed in time_base of param ref_st
1112 * @param ref_st reference stream giving time_base of param timestamp
1114 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1117 for(i = 0; i < s->nb_streams; i++) {
1118 AVStream *st = s->streams[i];
1120 st->cur_dts = av_rescale(timestamp,
1121 st->time_base.den * (int64_t)ref_st->time_base.num,
1122 st->time_base.num * (int64_t)ref_st->time_base.den);
1127 * Add a index entry into a sorted list updateing if it is already there.
1129 * @param timestamp timestamp in the timebase of the given stream
1131 int av_add_index_entry(AVStream *st,
1132 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1134 AVIndexEntry *entries, *ie;
1137 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1140 entries = av_fast_realloc(st->index_entries,
1141 &st->index_entries_allocated_size,
1142 (st->nb_index_entries + 1) *
1143 sizeof(AVIndexEntry));
1147 st->index_entries= entries;
1149 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1152 index= st->nb_index_entries++;
1153 ie= &entries[index];
1154 assert(index==0 || ie[-1].timestamp < timestamp);
1156 ie= &entries[index];
1157 if(ie->timestamp != timestamp){
1158 if(ie->timestamp <= timestamp)
1160 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1161 st->nb_index_entries++;
1162 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1163 distance= ie->min_distance;
1167 ie->timestamp = timestamp;
1168 ie->min_distance= distance;
1176 * build an index for raw streams using a parser.
1178 static void av_build_index_raw(AVFormatContext *s)
1180 AVPacket pkt1, *pkt = &pkt1;
1185 av_read_frame_flush(s);
1186 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1189 ret = av_read_frame(s, pkt);
1192 if (pkt->stream_index == 0 && st->parser &&
1193 (pkt->flags & PKT_FLAG_KEY)) {
1194 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1195 0, 0, AVINDEX_KEYFRAME);
1197 av_free_packet(pkt);
1202 * Returns TRUE if we deal with a raw stream.
1204 * Raw codec data and parsing needed.
1206 static int is_raw_stream(AVFormatContext *s)
1210 if (s->nb_streams != 1)
1213 if (!st->need_parsing)
1219 * Gets the index for a specific timestamp.
1220 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1221 * the timestamp which is <= the requested one, if backward is 0
1222 * then it will be >=
1223 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1224 * @return < 0 if no such timestamp could be found
1226 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1229 AVIndexEntry *entries= st->index_entries;
1230 int nb_entries= st->nb_index_entries;
1239 timestamp = entries[m].timestamp;
1240 if(timestamp >= wanted_timestamp)
1242 if(timestamp <= wanted_timestamp)
1245 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1247 if(!(flags & AVSEEK_FLAG_ANY)){
1248 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1249 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1261 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1262 * this isnt supposed to be called directly by a user application, but by demuxers
1263 * @param target_ts target timestamp in the time base of the given stream
1264 * @param stream_index stream number
1266 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1267 AVInputFormat *avif= s->iformat;
1268 int64_t pos_min, pos_max, pos, pos_limit;
1269 int64_t ts_min, ts_max, ts;
1270 int64_t start_pos, filesize;
1271 int index, no_change;
1274 if (stream_index < 0)
1278 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1282 ts_min= AV_NOPTS_VALUE;
1283 pos_limit= -1; //gcc falsely says it may be uninitalized
1285 st= s->streams[stream_index];
1286 if(st->index_entries){
1289 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()
1290 index= FFMAX(index, 0);
1291 e= &st->index_entries[index];
1293 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1295 ts_min= e->timestamp;
1297 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1304 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1305 assert(index < st->nb_index_entries);
1307 e= &st->index_entries[index];
1308 assert(e->timestamp >= target_ts);
1310 ts_max= e->timestamp;
1311 pos_limit= pos_max - e->min_distance;
1313 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1314 pos_max,pos_limit, ts_max);
1319 if(ts_min == AV_NOPTS_VALUE){
1320 pos_min = s->data_offset;
1321 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1322 if (ts_min == AV_NOPTS_VALUE)
1326 if(ts_max == AV_NOPTS_VALUE){
1328 filesize = url_fsize(&s->pb);
1329 pos_max = filesize - 1;
1332 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1334 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1335 if (ts_max == AV_NOPTS_VALUE)
1339 int64_t tmp_pos= pos_max + 1;
1340 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1341 if(tmp_ts == AV_NOPTS_VALUE)
1345 if(tmp_pos >= filesize)
1351 if(ts_min > ts_max){
1353 }else if(ts_min == ts_max){
1358 while (pos_min < pos_limit) {
1360 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1364 assert(pos_limit <= pos_max);
1367 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1368 // interpolate position (better than dichotomy)
1369 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1370 + pos_min - approximate_keyframe_distance;
1371 }else if(no_change==1){
1372 // bisection, if interpolation failed to change min or max pos last time
1373 pos = (pos_min + pos_limit)>>1;
1375 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1380 else if(pos > pos_limit)
1384 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1390 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);
1392 assert(ts != AV_NOPTS_VALUE);
1393 if (target_ts <= ts) {
1394 pos_limit = start_pos - 1;
1398 if (target_ts >= ts) {
1404 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1405 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1408 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1410 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1411 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1412 pos, ts_min, target_ts, ts_max);
1415 url_fseek(&s->pb, pos, SEEK_SET);
1417 av_update_cur_dts(s, st, ts);
1422 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1423 int64_t pos_min, pos_max;
1427 if (stream_index < 0)
1430 st= s->streams[stream_index];
1433 pos_min = s->data_offset;
1434 pos_max = url_fsize(&s->pb) - 1;
1436 if (pos < pos_min) pos= pos_min;
1437 else if(pos > pos_max) pos= pos_max;
1439 url_fseek(&s->pb, pos, SEEK_SET);
1442 av_update_cur_dts(s, st, ts);
1447 static int av_seek_frame_generic(AVFormatContext *s,
1448 int stream_index, int64_t timestamp, int flags)
1454 if (!s->index_built) {
1455 if (is_raw_stream(s)) {
1456 av_build_index_raw(s);
1463 st = s->streams[stream_index];
1464 index = av_index_search_timestamp(st, timestamp, flags);
1468 /* now we have found the index, we can seek */
1469 ie = &st->index_entries[index];
1470 av_read_frame_flush(s);
1471 url_fseek(&s->pb, ie->pos, SEEK_SET);
1473 av_update_cur_dts(s, st, ie->timestamp);
1479 * Seek to the key frame at timestamp.
1480 * 'timestamp' in 'stream_index'.
1481 * @param stream_index If stream_index is (-1), a default
1482 * stream is selected, and timestamp is automatically converted
1483 * from AV_TIME_BASE units to the stream specific time_base.
1484 * @param timestamp timestamp in AVStream.time_base units
1485 * or if there is no stream specified then in AV_TIME_BASE units
1486 * @param flags flags which select direction and seeking mode
1487 * @return >= 0 on success
1489 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1494 av_read_frame_flush(s);
1496 if(flags & AVSEEK_FLAG_BYTE)
1497 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1499 if(stream_index < 0){
1500 stream_index= av_find_default_stream_index(s);
1501 if(stream_index < 0)
1504 st= s->streams[stream_index];
1505 /* timestamp for default must be expressed in AV_TIME_BASE units */
1506 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1508 st= s->streams[stream_index];
1510 /* first, we try the format specific seek */
1511 if (s->iformat->read_seek)
1512 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1519 if(s->iformat->read_timestamp)
1520 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1522 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1525 /*******************************************************/
1528 * Returns TRUE if the stream has accurate timings in any stream.
1530 * @return TRUE if the stream has accurate timings for at least one component.
1532 static int av_has_timings(AVFormatContext *ic)
1537 for(i = 0;i < ic->nb_streams; i++) {
1538 st = ic->streams[i];
1539 if (st->start_time != AV_NOPTS_VALUE &&
1540 st->duration != AV_NOPTS_VALUE)
1547 * Estimate the stream timings from the one of each components.
1549 * Also computes the global bitrate if possible.
1551 static void av_update_stream_timings(AVFormatContext *ic)
1553 int64_t start_time, start_time1, end_time, end_time1;
1557 start_time = MAXINT64;
1558 end_time = MININT64;
1559 for(i = 0;i < ic->nb_streams; i++) {
1560 st = ic->streams[i];
1561 if (st->start_time != AV_NOPTS_VALUE) {
1562 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1563 if (start_time1 < start_time)
1564 start_time = start_time1;
1565 if (st->duration != AV_NOPTS_VALUE) {
1566 end_time1 = start_time1
1567 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1568 if (end_time1 > end_time)
1569 end_time = end_time1;
1573 if (start_time != MAXINT64) {
1574 ic->start_time = start_time;
1575 if (end_time != MININT64) {
1576 ic->duration = end_time - start_time;
1577 if (ic->file_size > 0) {
1578 /* compute the bit rate */
1579 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1580 (double)ic->duration;
1587 static void fill_all_stream_timings(AVFormatContext *ic)
1592 av_update_stream_timings(ic);
1593 for(i = 0;i < ic->nb_streams; i++) {
1594 st = ic->streams[i];
1595 if (st->start_time == AV_NOPTS_VALUE) {
1596 if(ic->start_time != AV_NOPTS_VALUE)
1597 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1598 if(ic->duration != AV_NOPTS_VALUE)
1599 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1604 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1606 int64_t filesize, duration;
1610 /* if bit_rate is already set, we believe it */
1611 if (ic->bit_rate == 0) {
1613 for(i=0;i<ic->nb_streams;i++) {
1614 st = ic->streams[i];
1615 bit_rate += st->codec->bit_rate;
1617 ic->bit_rate = bit_rate;
1620 /* if duration is already set, we believe it */
1621 if (ic->duration == AV_NOPTS_VALUE &&
1622 ic->bit_rate != 0 &&
1623 ic->file_size != 0) {
1624 filesize = ic->file_size;
1626 for(i = 0; i < ic->nb_streams; i++) {
1627 st = ic->streams[i];
1628 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1629 if (st->start_time == AV_NOPTS_VALUE ||
1630 st->duration == AV_NOPTS_VALUE) {
1632 st->duration = duration;
1639 #define DURATION_MAX_READ_SIZE 250000
1641 /* only usable for MPEG-PS streams */
1642 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1644 AVPacket pkt1, *pkt = &pkt1;
1646 int read_size, i, ret;
1648 int64_t filesize, offset, duration;
1650 /* free previous packet */
1651 if (ic->cur_st && ic->cur_st->parser)
1652 av_free_packet(&ic->cur_pkt);
1655 /* flush packet queue */
1656 flush_packet_queue(ic);
1658 for(i=0;i<ic->nb_streams;i++) {
1659 st = ic->streams[i];
1661 av_parser_close(st->parser);
1666 /* we read the first packets to get the first PTS (not fully
1667 accurate, but it is enough now) */
1668 url_fseek(&ic->pb, 0, SEEK_SET);
1671 if (read_size >= DURATION_MAX_READ_SIZE)
1673 /* if all info is available, we can stop */
1674 for(i = 0;i < ic->nb_streams; i++) {
1675 st = ic->streams[i];
1676 if (st->start_time == AV_NOPTS_VALUE)
1679 if (i == ic->nb_streams)
1682 ret = av_read_packet(ic, pkt);
1685 read_size += pkt->size;
1686 st = ic->streams[pkt->stream_index];
1687 if (pkt->pts != AV_NOPTS_VALUE) {
1688 if (st->start_time == AV_NOPTS_VALUE)
1689 st->start_time = pkt->pts;
1691 av_free_packet(pkt);
1694 /* estimate the end time (duration) */
1695 /* XXX: may need to support wrapping */
1696 filesize = ic->file_size;
1697 offset = filesize - DURATION_MAX_READ_SIZE;
1701 url_fseek(&ic->pb, offset, SEEK_SET);
1704 if (read_size >= DURATION_MAX_READ_SIZE)
1706 /* if all info is available, we can stop */
1707 for(i = 0;i < ic->nb_streams; i++) {
1708 st = ic->streams[i];
1709 if (st->duration == AV_NOPTS_VALUE)
1712 if (i == ic->nb_streams)
1715 ret = av_read_packet(ic, pkt);
1718 read_size += pkt->size;
1719 st = ic->streams[pkt->stream_index];
1720 if (pkt->pts != AV_NOPTS_VALUE) {
1721 end_time = pkt->pts;
1722 duration = end_time - st->start_time;
1724 if (st->duration == AV_NOPTS_VALUE ||
1725 st->duration < duration)
1726 st->duration = duration;
1729 av_free_packet(pkt);
1732 fill_all_stream_timings(ic);
1734 url_fseek(&ic->pb, 0, SEEK_SET);
1737 static void av_estimate_timings(AVFormatContext *ic)
1741 /* get the file size, if possible */
1742 if (ic->iformat->flags & AVFMT_NOFILE) {
1745 file_size = url_fsize(&ic->pb);
1749 ic->file_size = file_size;
1751 if ((!strcmp(ic->iformat->name, "mpeg") ||
1752 !strcmp(ic->iformat->name, "mpegts")) &&
1753 file_size && !ic->pb.is_streamed) {
1754 /* get accurate estimate from the PTSes */
1755 av_estimate_timings_from_pts(ic);
1756 } else if (av_has_timings(ic)) {
1757 /* at least one components has timings - we use them for all
1759 fill_all_stream_timings(ic);
1761 /* less precise: use bit rate info */
1762 av_estimate_timings_from_bit_rate(ic);
1764 av_update_stream_timings(ic);
1770 for(i = 0;i < ic->nb_streams; i++) {
1771 st = ic->streams[i];
1772 printf("%d: start_time: %0.3f duration: %0.3f\n",
1773 i, (double)st->start_time / AV_TIME_BASE,
1774 (double)st->duration / AV_TIME_BASE);
1776 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1777 (double)ic->start_time / AV_TIME_BASE,
1778 (double)ic->duration / AV_TIME_BASE,
1779 ic->bit_rate / 1000);
1784 static int has_codec_parameters(AVCodecContext *enc)
1787 switch(enc->codec_type) {
1788 case CODEC_TYPE_AUDIO:
1789 val = enc->sample_rate;
1791 case CODEC_TYPE_VIDEO:
1792 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1801 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1805 int got_picture, ret=0;
1808 if(!st->codec->codec){
1809 codec = avcodec_find_decoder(st->codec->codec_id);
1812 ret = avcodec_open(st->codec, codec);
1817 if(!has_codec_parameters(st->codec)){
1818 switch(st->codec->codec_type) {
1819 case CODEC_TYPE_VIDEO:
1820 ret = avcodec_decode_video(st->codec, &picture,
1821 &got_picture, (uint8_t *)data, size);
1823 case CODEC_TYPE_AUDIO:
1824 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1827 ret = avcodec_decode_audio(st->codec, samples,
1828 &got_picture, (uint8_t *)data, size);
1839 /* absolute maximum size we read until we abort */
1840 #define MAX_READ_SIZE 5000000
1842 /* maximum duration until we stop analysing the stream */
1843 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 3.0))
1846 * Read the beginning of a media file to get stream information. This
1847 * is useful for file formats with no headers such as MPEG. This
1848 * function also compute the real frame rate in case of mpeg2 repeat
1851 * @param ic media file handle
1852 * @return >=0 if OK. AVERROR_xxx if error.
1853 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1855 int av_find_stream_info(AVFormatContext *ic)
1857 int i, count, ret, read_size, j;
1859 AVPacket pkt1, *pkt;
1860 AVPacketList *pktl=NULL, **ppktl;
1861 int64_t last_dts[MAX_STREAMS];
1862 int64_t duration_sum[MAX_STREAMS];
1863 int duration_count[MAX_STREAMS]={0};
1865 for(i=0;i<ic->nb_streams;i++) {
1866 st = ic->streams[i];
1867 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1868 /* if(!st->time_base.num)
1870 if(!st->codec->time_base.num)
1871 st->codec->time_base= st->time_base;
1873 //only for the split stuff
1875 st->parser = av_parser_init(st->codec->codec_id);
1876 if(st->need_parsing == 2 && st->parser){
1877 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1882 for(i=0;i<MAX_STREAMS;i++){
1883 last_dts[i]= AV_NOPTS_VALUE;
1884 duration_sum[i]= INT64_MAX;
1889 ppktl = &ic->packet_buffer;
1891 /* check if one codec still needs to be handled */
1892 for(i=0;i<ic->nb_streams;i++) {
1893 st = ic->streams[i];
1894 if (!has_codec_parameters(st->codec))
1896 /* variable fps and no guess at the real fps */
1897 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1898 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1900 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1903 if (i == ic->nb_streams) {
1904 /* NOTE: if the format has no header, then we need to read
1905 some packets to get most of the streams, so we cannot
1907 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1908 /* if we found the info for all the codecs, we can stop */
1913 /* we did not get all the codec info, but we read too much data */
1914 if (read_size >= MAX_READ_SIZE) {
1920 /* NOTE: a new stream can be added there if no header in file
1921 (AVFMTCTX_NOHEADER) */
1922 ret = av_read_frame_internal(ic, &pkt1);
1925 ret = -1; /* we could not have all the codec parameters before EOF */
1926 for(i=0;i<ic->nb_streams;i++) {
1927 st = ic->streams[i];
1928 if (!has_codec_parameters(st->codec)){
1930 avcodec_string(buf, sizeof(buf), st->codec, 0);
1931 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1939 pktl = av_mallocz(sizeof(AVPacketList));
1941 ret = AVERROR_NOMEM;
1945 /* add the packet in the buffered packet list */
1947 ppktl = &pktl->next;
1952 /* duplicate the packet */
1953 if (av_dup_packet(pkt) < 0) {
1954 ret = AVERROR_NOMEM;
1958 read_size += pkt->size;
1960 st = ic->streams[pkt->stream_index];
1961 st->codec_info_duration += pkt->duration;
1962 if (pkt->duration != 0)
1963 st->codec_info_nb_frames++;
1966 int index= pkt->stream_index;
1967 int64_t last= last_dts[index];
1968 int64_t duration= pkt->dts - last;
1970 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1971 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1972 duration_sum[index]= duration;
1973 duration_count[index]=1;
1975 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1976 duration_sum[index] += duration;
1977 duration_count[index]+= factor;
1979 if(st->codec_info_nb_frames == 0 && 0)
1980 st->codec_info_duration += duration;
1982 last_dts[pkt->stream_index]= pkt->dts;
1984 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1985 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1987 st->codec->extradata_size= i;
1988 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1989 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1990 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1994 /* if still no information, we try to open the codec and to
1995 decompress the frame. We try to avoid that in most cases as
1996 it takes longer and uses more memory. For MPEG4, we need to
1997 decompress for Quicktime. */
1998 if (!has_codec_parameters(st->codec) /*&&
1999 (st->codec->codec_id == CODEC_ID_FLV1 ||
2000 st->codec->codec_id == CODEC_ID_H264 ||
2001 st->codec->codec_id == CODEC_ID_H263 ||
2002 st->codec->codec_id == CODEC_ID_H261 ||
2003 st->codec->codec_id == CODEC_ID_VORBIS ||
2004 st->codec->codec_id == CODEC_ID_MJPEG ||
2005 st->codec->codec_id == CODEC_ID_PNG ||
2006 st->codec->codec_id == CODEC_ID_PAM ||
2007 st->codec->codec_id == CODEC_ID_PGM ||
2008 st->codec->codec_id == CODEC_ID_PGMYUV ||
2009 st->codec->codec_id == CODEC_ID_PBM ||
2010 st->codec->codec_id == CODEC_ID_PPM ||
2011 st->codec->codec_id == CODEC_ID_SHORTEN ||
2012 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2013 try_decode_frame(st, pkt->data, pkt->size);
2015 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2021 // close codecs which where opened in try_decode_frame()
2022 for(i=0;i<ic->nb_streams;i++) {
2023 st = ic->streams[i];
2024 if(st->codec->codec)
2025 avcodec_close(st->codec);
2027 for(i=0;i<ic->nb_streams;i++) {
2028 st = ic->streams[i];
2029 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2030 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2031 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2033 if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2034 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2035 int64_t num, den, error, best_error;
2037 num= st->time_base.den*duration_count[i];
2038 den= st->time_base.num*duration_sum[i];
2040 best_error= INT64_MAX;
2041 for(j=1; j<60*12; j++){
2042 error= ABS(1001*12*num - 1001*j*den);
2043 if(error < best_error){
2045 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2048 for(j=24; j<=30; j+=6){
2049 error= ABS(1001*12*num - 1000*12*j*den);
2050 if(error < best_error){
2052 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2057 /* set real frame rate info */
2058 /* compute the real frame rate for telecine */
2059 if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2060 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2061 st->codec->sub_id == 2) {
2062 if (st->codec_info_nb_frames >= 20) {
2063 float coded_frame_rate, est_frame_rate;
2064 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2065 (double)st->codec_info_duration ;
2066 coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2068 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2069 coded_frame_rate, est_frame_rate);
2071 /* if we detect that it could be a telecine, we
2072 signal it. It would be better to do it at a
2073 higher level as it can change in a film */
2074 if (coded_frame_rate >= 24.97 &&
2075 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2076 st->r_frame_rate = (AVRational){24000, 1001};
2080 /* if no real frame rate, use the codec one */
2081 if (!st->r_frame_rate.num){
2082 st->r_frame_rate.num = st->codec->time_base.den;
2083 st->r_frame_rate.den = st->codec->time_base.num;
2088 av_estimate_timings(ic);
2090 /* correct DTS for b frame streams with no timestamps */
2091 for(i=0;i<ic->nb_streams;i++) {
2092 st = ic->streams[i];
2093 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2095 ppktl = &ic->packet_buffer;
2097 if(ppkt1->stream_index != i)
2099 if(ppkt1->pkt->dts < 0)
2101 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2103 ppkt1->pkt->dts -= delta;
2108 st->cur_dts -= delta;
2116 /*******************************************************/
2119 * start playing a network based stream (e.g. RTSP stream) at the
2122 int av_read_play(AVFormatContext *s)
2124 if (!s->iformat->read_play)
2125 return AVERROR_NOTSUPP;
2126 return s->iformat->read_play(s);
2130 * Pause a network based stream (e.g. RTSP stream).
2132 * Use av_read_play() to resume it.
2134 int av_read_pause(AVFormatContext *s)
2136 if (!s->iformat->read_pause)
2137 return AVERROR_NOTSUPP;
2138 return s->iformat->read_pause(s);
2142 * Close a media file (but not its codecs).
2144 * @param s media file handle
2146 void av_close_input_file(AVFormatContext *s)
2148 int i, must_open_file;
2151 /* free previous packet */
2152 if (s->cur_st && s->cur_st->parser)
2153 av_free_packet(&s->cur_pkt);
2155 if (s->iformat->read_close)
2156 s->iformat->read_close(s);
2157 for(i=0;i<s->nb_streams;i++) {
2158 /* free all data in a stream component */
2161 av_parser_close(st->parser);
2163 av_free(st->index_entries);
2164 av_free(st->codec->extradata);
2168 flush_packet_queue(s);
2170 if (s->iformat->flags & AVFMT_NOFILE) {
2173 if (must_open_file) {
2176 av_freep(&s->priv_data);
2181 * Add a new stream to a media file.
2183 * Can only be called in the read_header() function. If the flag
2184 * AVFMTCTX_NOHEADER is in the format context, then new streams
2185 * can be added in read_packet too.
2187 * @param s media file handle
2188 * @param id file format dependent stream id
2190 AVStream *av_new_stream(AVFormatContext *s, int id)
2194 if (s->nb_streams >= MAX_STREAMS)
2197 st = av_mallocz(sizeof(AVStream));
2201 st->codec= avcodec_alloc_context();
2203 /* no default bitrate if decoding */
2204 st->codec->bit_rate = 0;
2206 st->index = s->nb_streams;
2208 st->start_time = AV_NOPTS_VALUE;
2209 st->duration = AV_NOPTS_VALUE;
2210 st->cur_dts = AV_NOPTS_VALUE;
2212 /* default pts settings is MPEG like */
2213 av_set_pts_info(st, 33, 1, 90000);
2214 st->last_IP_pts = AV_NOPTS_VALUE;
2216 s->streams[s->nb_streams++] = st;
2220 /************************************************************/
2221 /* output media file */
2223 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2227 if (s->oformat->priv_data_size > 0) {
2228 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2230 return AVERROR_NOMEM;
2232 s->priv_data = NULL;
2234 if (s->oformat->set_parameters) {
2235 ret = s->oformat->set_parameters(s, ap);
2243 * allocate the stream private data and write the stream header to an
2246 * @param s media file handle
2247 * @return 0 if OK. AVERROR_xxx if error.
2249 int av_write_header(AVFormatContext *s)
2254 // some sanity checks
2255 for(i=0;i<s->nb_streams;i++) {
2258 switch (st->codec->codec_type) {
2259 case CODEC_TYPE_AUDIO:
2260 if(st->codec->sample_rate<=0){
2261 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2265 case CODEC_TYPE_VIDEO:
2266 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2267 av_log(s, AV_LOG_ERROR, "time base not set\n");
2270 if(st->codec->width<=0 || st->codec->height<=0){
2271 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2278 if(s->oformat->write_header){
2279 ret = s->oformat->write_header(s);
2284 /* init PTS generation */
2285 for(i=0;i<s->nb_streams;i++) {
2286 int64_t den = AV_NOPTS_VALUE;
2289 switch (st->codec->codec_type) {
2290 case CODEC_TYPE_AUDIO:
2291 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2293 case CODEC_TYPE_VIDEO:
2294 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2299 if (den != AV_NOPTS_VALUE) {
2301 return AVERROR_INVALIDDATA;
2302 av_frac_init(&st->pts, 0, 0, den);
2308 //FIXME merge with compute_pkt_fields
2309 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2310 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2311 int num, den, frame_size;
2313 // 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);
2315 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2318 /* duration field */
2319 if (pkt->duration == 0) {
2320 compute_frame_duration(&num, &den, st, NULL, pkt);
2322 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2326 //XXX/FIXME this is a temporary hack until all encoders output pts
2327 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2329 // pkt->pts= st->cur_dts;
2330 pkt->pts= st->pts.val;
2333 //calculate dts from pts
2334 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2336 if(st->last_IP_pts == AV_NOPTS_VALUE){
2337 st->last_IP_pts= -pkt->duration;
2339 if(st->last_IP_pts < pkt->pts){
2340 pkt->dts= st->last_IP_pts;
2341 st->last_IP_pts= pkt->pts;
2348 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2349 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2352 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2353 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2357 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2358 st->cur_dts= pkt->dts;
2359 st->pts.val= pkt->dts;
2362 switch (st->codec->codec_type) {
2363 case CODEC_TYPE_AUDIO:
2364 frame_size = get_audio_frame_size(st->codec, pkt->size);
2366 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2367 but it would be better if we had the real timestamps from the encoder */
2368 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2369 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2372 case CODEC_TYPE_VIDEO:
2373 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2381 static void truncate_ts(AVStream *st, AVPacket *pkt){
2382 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2385 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2387 pkt->pts &= pts_mask;
2388 pkt->dts &= pts_mask;
2392 * Write a packet to an output media file.
2394 * The packet shall contain one audio or video frame.
2396 * @param s media file handle
2397 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2398 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2400 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2404 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2405 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2408 truncate_ts(s->streams[pkt->stream_index], pkt);
2410 ret= s->oformat->write_packet(s, pkt);
2412 ret= url_ferror(&s->pb);
2417 * interleave_packet implementation which will interleave per DTS.
2418 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2419 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2421 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2422 AVPacketList *pktl, **next_point, *this_pktl;
2424 int streams[MAX_STREAMS];
2427 AVStream *st= s->streams[ pkt->stream_index];
2429 // assert(pkt->destruct != av_destruct_packet); //FIXME
2431 this_pktl = av_mallocz(sizeof(AVPacketList));
2432 this_pktl->pkt= *pkt;
2433 if(pkt->destruct == av_destruct_packet)
2434 pkt->destruct= NULL; // non shared -> must keep original from being freed
2436 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2438 next_point = &s->packet_buffer;
2440 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2441 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2442 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2443 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2445 next_point= &(*next_point)->next;
2447 this_pktl->next= *next_point;
2448 *next_point= this_pktl;
2451 memset(streams, 0, sizeof(streams));
2452 pktl= s->packet_buffer;
2454 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2455 if(streams[ pktl->pkt.stream_index ] == 0)
2457 streams[ pktl->pkt.stream_index ]++;
2461 if(s->nb_streams == stream_count || (flush && stream_count)){
2462 pktl= s->packet_buffer;
2465 s->packet_buffer= pktl->next;
2469 av_init_packet(out);
2475 * Interleaves a AVPacket correctly so it can be muxed.
2476 * @param out the interleaved packet will be output here
2477 * @param in the input packet
2478 * @param flush 1 if no further packets are available as input and all
2479 * remaining packets should be output
2480 * @return 1 if a packet was output, 0 if no packet could be output,
2481 * < 0 if an error occured
2483 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2484 if(s->oformat->interleave_packet)
2485 return s->oformat->interleave_packet(s, out, in, flush);
2487 return av_interleave_packet_per_dts(s, out, in, flush);
2491 * Writes a packet to an output media file ensuring correct interleaving.
2493 * The packet must contain one audio or video frame.
2494 * If the packets are already correctly interleaved the application should
2495 * call av_write_frame() instead as its slightly faster, its also important
2496 * to keep in mind that completly non interleaved input will need huge amounts
2497 * of memory to interleave with this, so its prefereable to interleave at the
2500 * @param s media file handle
2501 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2502 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2504 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2505 AVStream *st= s->streams[ pkt->stream_index];
2507 //FIXME/XXX/HACK drop zero sized packets
2508 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2511 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2512 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2515 if(pkt->dts == AV_NOPTS_VALUE)
2520 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2521 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2524 truncate_ts(s->streams[opkt.stream_index], &opkt);
2525 ret= s->oformat->write_packet(s, &opkt);
2527 av_free_packet(&opkt);
2532 if(url_ferror(&s->pb))
2533 return url_ferror(&s->pb);
2538 * @brief Write the stream trailer to an output media file and
2539 * free the file private data.
2541 * @param s media file handle
2542 * @return 0 if OK. AVERROR_xxx if error.
2544 int av_write_trailer(AVFormatContext *s)
2550 ret= av_interleave_packet(s, &pkt, NULL, 1);
2551 if(ret<0) //FIXME cleanup needed for ret<0 ?
2556 truncate_ts(s->streams[pkt.stream_index], &pkt);
2557 ret= s->oformat->write_packet(s, &pkt);
2559 av_free_packet(&pkt);
2563 if(url_ferror(&s->pb))
2567 if(s->oformat->write_trailer)
2568 ret = s->oformat->write_trailer(s);
2571 ret=url_ferror(&s->pb);
2572 for(i=0;i<s->nb_streams;i++)
2573 av_freep(&s->streams[i]->priv_data);
2574 av_freep(&s->priv_data);
2578 /* "user interface" functions */
2580 void dump_format(AVFormatContext *ic,
2588 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2589 is_output ? "Output" : "Input",
2591 is_output ? ic->oformat->name : ic->iformat->name,
2592 is_output ? "to" : "from", url);
2594 av_log(NULL, AV_LOG_INFO, " Duration: ");
2595 if (ic->duration != AV_NOPTS_VALUE) {
2596 int hours, mins, secs, us;
2597 secs = ic->duration / AV_TIME_BASE;
2598 us = ic->duration % AV_TIME_BASE;
2603 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2604 (10 * us) / AV_TIME_BASE);
2606 av_log(NULL, AV_LOG_INFO, "N/A");
2608 if (ic->start_time != AV_NOPTS_VALUE) {
2610 av_log(NULL, AV_LOG_INFO, ", start: ");
2611 secs = ic->start_time / AV_TIME_BASE;
2612 us = ic->start_time % AV_TIME_BASE;
2613 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2614 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2616 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2618 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2620 av_log(NULL, AV_LOG_INFO, "N/A");
2622 av_log(NULL, AV_LOG_INFO, "\n");
2624 for(i=0;i<ic->nb_streams;i++) {
2625 AVStream *st = ic->streams[i];
2626 int g= ff_gcd(st->time_base.num, st->time_base.den);
2627 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2628 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2629 /* the pid is an important information, so we display it */
2630 /* XXX: add a generic system */
2632 flags = ic->oformat->flags;
2634 flags = ic->iformat->flags;
2635 if (flags & AVFMT_SHOW_IDS) {
2636 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2638 if (strlen(st->language) > 0) {
2639 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2641 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2642 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2643 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2644 if(st->r_frame_rate.den && st->r_frame_rate.num)
2645 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2646 /* else if(st->time_base.den && st->time_base.num)
2647 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2649 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2651 av_log(NULL, AV_LOG_INFO, "\n");
2658 int frame_rate, frame_rate_base;
2661 static AbvEntry frame_abvs[] = {
2662 { "ntsc", 720, 480, 30000, 1001 },
2663 { "pal", 720, 576, 25, 1 },
2664 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2665 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2666 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2667 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2668 { "film", 352, 240, 24, 1 },
2669 { "ntsc-film", 352, 240, 24000, 1001 },
2670 { "sqcif", 128, 96, 0, 0 },
2671 { "qcif", 176, 144, 0, 0 },
2672 { "cif", 352, 288, 0, 0 },
2673 { "4cif", 704, 576, 0, 0 },
2677 * parses width and height out of string str.
2679 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2682 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2684 int frame_width = 0, frame_height = 0;
2687 if (!strcmp(frame_abvs[i].abv, str)) {
2688 frame_width = frame_abvs[i].width;
2689 frame_height = frame_abvs[i].height;
2695 frame_width = strtol(p, (char **)&p, 10);
2698 frame_height = strtol(p, (char **)&p, 10);
2700 if (frame_width <= 0 || frame_height <= 0)
2702 *width_ptr = frame_width;
2703 *height_ptr = frame_height;
2708 * Converts frame rate from string to a fraction.
2710 * First we try to get an exact integer or fractional frame rate.
2711 * If this fails we convert the frame rate to a double and return
2712 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2714 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2719 /* First, we check our abbreviation table */
2720 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2721 if (!strcmp(frame_abvs[i].abv, arg)) {
2722 *frame_rate = frame_abvs[i].frame_rate;
2723 *frame_rate_base = frame_abvs[i].frame_rate_base;
2727 /* Then, we try to parse it as fraction */
2728 cp = strchr(arg, '/');
2730 cp = strchr(arg, ':');
2733 *frame_rate = strtol(arg, &cpp, 10);
2734 if (cpp != arg || cpp == cp)
2735 *frame_rate_base = strtol(cp+1, &cpp, 10);
2740 /* Finally we give up and parse it as double */
2741 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2742 *frame_rate_base = time_base.den;
2743 *frame_rate = time_base.num;
2745 if (!*frame_rate || !*frame_rate_base)
2752 * Converts date string to number of seconds since Jan 1st, 1970.
2756 * - If not a duration:
2757 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2758 * Time is localtime unless Z is suffixed to the end. In this case GMT
2759 * Return the date in micro seconds since 1970
2762 * HH[:MM[:SS[.m...]]]
2766 #ifndef CONFIG_WINCE
2767 int64_t parse_date(const char *datestr, int duration)
2773 static const char *date_fmt[] = {
2777 static const char *time_fmt[] = {
2787 time_t now = time(0);
2789 len = strlen(datestr);
2791 lastch = datestr[len - 1];
2794 is_utc = (lastch == 'z' || lastch == 'Z');
2796 memset(&dt, 0, sizeof(dt));
2801 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2802 q = small_strptime(p, date_fmt[i], &dt);
2812 dt = *localtime(&now);
2814 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2819 if (*p == 'T' || *p == 't' || *p == ' ')
2822 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2823 q = small_strptime(p, time_fmt[i], &dt);
2833 q = small_strptime(p, time_fmt[0], &dt);
2835 dt.tm_sec = strtol(p, (char **)&q, 10);
2841 /* Now we have all the fields that we can get */
2846 return now * int64_t_C(1000000);
2850 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2852 dt.tm_isdst = -1; /* unknown */
2865 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2868 val += n * (*q - '0');
2872 return negative ? -t : t;
2874 #endif /* CONFIG_WINCE */
2877 * Attempts to find a specific tag in a URL.
2879 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2880 * Return 1 if found.
2882 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2892 while (*p != '\0' && *p != '=' && *p != '&') {
2893 if ((q - tag) < sizeof(tag) - 1)
2901 while (*p != '&' && *p != '\0') {
2902 if ((q - arg) < arg_size - 1) {
2912 if (!strcmp(tag, tag1))
2922 * Returns in 'buf' the path with '%d' replaced by number.
2924 * Also handles the '%0nd' format where 'n' is the total number
2925 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2927 int get_frame_filename(char *buf, int buf_size,
2928 const char *path, int number)
2931 char *q, buf1[20], c;
2932 int nd, len, percentd_found;
2944 while (isdigit(*p)) {
2945 nd = nd * 10 + *p++ - '0';
2948 } while (isdigit(c));
2957 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2959 if ((q - buf + len) > buf_size - 1)
2961 memcpy(q, buf1, len);
2969 if ((q - buf) < buf_size - 1)
2973 if (!percentd_found)
2983 * Print nice hexa dump of a buffer
2984 * @param f stream for output
2986 * @param size buffer size
2988 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2992 for(i=0;i<size;i+=16) {
2996 fprintf(f, "%08x ", i);
2999 fprintf(f, " %02x", buf[i+j]);
3004 for(j=0;j<len;j++) {
3006 if (c < ' ' || c > '~')
3008 fprintf(f, "%c", c);
3015 * Print on 'f' a nice dump of a packet
3016 * @param f stream for output
3017 * @param pkt packet to dump
3018 * @param dump_payload true if the payload must be displayed too
3020 //FIXME needs to know the time_base
3021 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3023 fprintf(f, "stream #%d:\n", pkt->stream_index);
3024 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3025 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3026 /* DTS is _always_ valid after av_read_frame() */
3027 fprintf(f, " dts=");
3028 if (pkt->dts == AV_NOPTS_VALUE)
3031 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3032 /* PTS may be not known if B frames are present */
3033 fprintf(f, " pts=");
3034 if (pkt->pts == AV_NOPTS_VALUE)
3037 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3039 fprintf(f, " size=%d\n", pkt->size);
3041 av_hex_dump(f, pkt->data, pkt->size);
3044 void url_split(char *proto, int proto_size,
3045 char *authorization, int authorization_size,
3046 char *hostname, int hostname_size,
3048 char *path, int path_size,
3059 while (*p != ':' && *p != '\0') {
3060 if ((q - proto) < proto_size - 1)
3066 if (authorization_size > 0)
3067 authorization[0] = '\0';
3071 if (hostname_size > 0)
3075 char *at,*slash; // PETR: position of '@' character and '/' character
3082 at = strchr(p,'@'); // PETR: get the position of '@'
3083 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3084 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3086 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3088 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3089 if (*p == '@') { // PETR: passed '@'
3090 if (authorization_size > 0)
3094 } else if (!at) { // PETR: hostname
3095 if ((q - hostname) < hostname_size - 1)
3098 if ((q - authorization) < authorization_size - 1)
3103 if (hostname_size > 0)
3107 port = strtoul(p, (char **)&p, 10);
3112 pstrcpy(path, path_size, p);
3116 * Set the pts for a given stream.
3119 * @param pts_wrap_bits number of bits effectively used by the pts
3120 * (used for wrap control, 33 is the value for MPEG)
3121 * @param pts_num numerator to convert to seconds (MPEG: 1)
3122 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3124 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3125 int pts_num, int pts_den)
3127 s->pts_wrap_bits = pts_wrap_bits;
3128 s->time_base.num = pts_num;
3129 s->time_base.den = pts_den;
3132 /* fraction handling */
3135 * f = val + (num / den) + 0.5.
3137 * 'num' is normalized so that it is such as 0 <= num < den.
3139 * @param f fractional number
3140 * @param val integer value
3141 * @param num must be >= 0
3142 * @param den must be >= 1
3144 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3157 * Set f to (val + 0.5).
3159 static void av_frac_set(AVFrac *f, int64_t val)
3162 f->num = f->den >> 1;
3166 * Fractionnal addition to f: f = f + (incr / f->den).
3168 * @param f fractional number
3169 * @param incr increment, can be positive or negative
3171 static void av_frac_add(AVFrac *f, int64_t incr)
3175 num = f->num + incr;
3178 f->val += num / den;
3184 } else if (num >= den) {
3185 f->val += num / den;
3192 * register a new image format
3193 * @param img_fmt Image format descriptor
3195 void av_register_image_format(AVImageFormat *img_fmt)
3199 p = &first_image_format;
3200 while (*p != NULL) p = &(*p)->next;
3202 img_fmt->next = NULL;
3206 * Guesses image format based on data in the image.
3208 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3210 AVImageFormat *fmt1, *fmt;
3211 int score, score_max;
3215 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3216 if (fmt1->img_probe) {
3217 score = fmt1->img_probe(pd);
3218 if (score > score_max) {
3228 * Guesses image format based on file name extensions.
3230 AVImageFormat *guess_image_format(const char *filename)
3232 AVImageFormat *fmt1;
3234 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3235 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3242 * Read an image from a stream.
3243 * @param gb byte stream containing the image
3244 * @param fmt image format, NULL if probing is required
3246 int av_read_image(ByteIOContext *pb, const char *filename,
3248 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3250 uint8_t buf[PROBE_BUF_MIN];
3251 AVProbeData probe_data, *pd = &probe_data;
3256 pd->filename = filename;
3258 pos = url_ftell(pb);
3259 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3260 url_fseek(pb, pos, SEEK_SET);
3261 fmt = av_probe_image_format(pd);
3264 return AVERROR_NOFMT;
3265 ret = fmt->img_read(pb, alloc_cb, opaque);
3270 * Write an image to a stream.
3271 * @param pb byte stream for the image output
3272 * @param fmt image format
3273 * @param img image data and informations
3275 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3277 return fmt->img_write(pb, img);