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 131072
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);
2173 flush_packet_queue(s);
2175 if (s->iformat->flags & AVFMT_NOFILE) {
2178 if (must_open_file) {
2181 av_freep(&s->priv_data);
2186 * Add a new stream to a media file.
2188 * Can only be called in the read_header() function. If the flag
2189 * AVFMTCTX_NOHEADER is in the format context, then new streams
2190 * can be added in read_packet too.
2192 * @param s media file handle
2193 * @param id file format dependent stream id
2195 AVStream *av_new_stream(AVFormatContext *s, int id)
2199 if (s->nb_streams >= MAX_STREAMS)
2202 st = av_mallocz(sizeof(AVStream));
2206 st->codec= avcodec_alloc_context();
2208 /* no default bitrate if decoding */
2209 st->codec->bit_rate = 0;
2211 st->index = s->nb_streams;
2213 st->start_time = AV_NOPTS_VALUE;
2214 st->duration = AV_NOPTS_VALUE;
2215 st->cur_dts = AV_NOPTS_VALUE;
2217 /* default pts settings is MPEG like */
2218 av_set_pts_info(st, 33, 1, 90000);
2219 st->last_IP_pts = AV_NOPTS_VALUE;
2221 s->streams[s->nb_streams++] = st;
2225 /************************************************************/
2226 /* output media file */
2228 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2232 if (s->oformat->priv_data_size > 0) {
2233 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2235 return AVERROR_NOMEM;
2237 s->priv_data = NULL;
2239 if (s->oformat->set_parameters) {
2240 ret = s->oformat->set_parameters(s, ap);
2248 * allocate the stream private data and write the stream header to an
2251 * @param s media file handle
2252 * @return 0 if OK. AVERROR_xxx if error.
2254 int av_write_header(AVFormatContext *s)
2259 // some sanity checks
2260 for(i=0;i<s->nb_streams;i++) {
2263 switch (st->codec->codec_type) {
2264 case CODEC_TYPE_AUDIO:
2265 if(st->codec->sample_rate<=0){
2266 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2270 case CODEC_TYPE_VIDEO:
2271 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2272 av_log(s, AV_LOG_ERROR, "time base not set\n");
2275 if(st->codec->width<=0 || st->codec->height<=0){
2276 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2283 if(s->oformat->write_header){
2284 ret = s->oformat->write_header(s);
2289 /* init PTS generation */
2290 for(i=0;i<s->nb_streams;i++) {
2291 int64_t den = AV_NOPTS_VALUE;
2294 switch (st->codec->codec_type) {
2295 case CODEC_TYPE_AUDIO:
2296 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2298 case CODEC_TYPE_VIDEO:
2299 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2304 if (den != AV_NOPTS_VALUE) {
2306 return AVERROR_INVALIDDATA;
2307 av_frac_init(&st->pts, 0, 0, den);
2313 //FIXME merge with compute_pkt_fields
2314 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2315 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2316 int num, den, frame_size;
2318 // 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);
2320 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2323 /* duration field */
2324 if (pkt->duration == 0) {
2325 compute_frame_duration(&num, &den, st, NULL, pkt);
2327 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2331 //XXX/FIXME this is a temporary hack until all encoders output pts
2332 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2334 // pkt->pts= st->cur_dts;
2335 pkt->pts= st->pts.val;
2338 //calculate dts from pts
2339 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2341 if(st->last_IP_pts == AV_NOPTS_VALUE){
2342 st->last_IP_pts= -pkt->duration;
2344 if(st->last_IP_pts < pkt->pts){
2345 pkt->dts= st->last_IP_pts;
2346 st->last_IP_pts= pkt->pts;
2353 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2354 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2357 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2358 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2362 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2363 st->cur_dts= pkt->dts;
2364 st->pts.val= pkt->dts;
2367 switch (st->codec->codec_type) {
2368 case CODEC_TYPE_AUDIO:
2369 frame_size = get_audio_frame_size(st->codec, pkt->size);
2371 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2372 but it would be better if we had the real timestamps from the encoder */
2373 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2374 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2377 case CODEC_TYPE_VIDEO:
2378 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2386 static void truncate_ts(AVStream *st, AVPacket *pkt){
2387 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2390 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2392 pkt->pts &= pts_mask;
2393 pkt->dts &= pts_mask;
2397 * Write a packet to an output media file.
2399 * The packet shall contain one audio or video frame.
2401 * @param s media file handle
2402 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2403 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2405 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2409 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2413 truncate_ts(s->streams[pkt->stream_index], pkt);
2415 ret= s->oformat->write_packet(s, pkt);
2417 ret= url_ferror(&s->pb);
2422 * interleave_packet implementation which will interleave per DTS.
2423 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2424 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2426 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2427 AVPacketList *pktl, **next_point, *this_pktl;
2429 int streams[MAX_STREAMS];
2432 AVStream *st= s->streams[ pkt->stream_index];
2434 // assert(pkt->destruct != av_destruct_packet); //FIXME
2436 this_pktl = av_mallocz(sizeof(AVPacketList));
2437 this_pktl->pkt= *pkt;
2438 if(pkt->destruct == av_destruct_packet)
2439 pkt->destruct= NULL; // non shared -> must keep original from being freed
2441 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2443 next_point = &s->packet_buffer;
2445 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2446 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2447 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2448 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2450 next_point= &(*next_point)->next;
2452 this_pktl->next= *next_point;
2453 *next_point= this_pktl;
2456 memset(streams, 0, sizeof(streams));
2457 pktl= s->packet_buffer;
2459 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2460 if(streams[ pktl->pkt.stream_index ] == 0)
2462 streams[ pktl->pkt.stream_index ]++;
2466 if(s->nb_streams == stream_count || (flush && stream_count)){
2467 pktl= s->packet_buffer;
2470 s->packet_buffer= pktl->next;
2474 av_init_packet(out);
2480 * Interleaves a AVPacket correctly so it can be muxed.
2481 * @param out the interleaved packet will be output here
2482 * @param in the input packet
2483 * @param flush 1 if no further packets are available as input and all
2484 * remaining packets should be output
2485 * @return 1 if a packet was output, 0 if no packet could be output,
2486 * < 0 if an error occured
2488 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2489 if(s->oformat->interleave_packet)
2490 return s->oformat->interleave_packet(s, out, in, flush);
2492 return av_interleave_packet_per_dts(s, out, in, flush);
2496 * Writes a packet to an output media file ensuring correct interleaving.
2498 * The packet must contain one audio or video frame.
2499 * If the packets are already correctly interleaved the application should
2500 * call av_write_frame() instead as its slightly faster, its also important
2501 * to keep in mind that completly non interleaved input will need huge amounts
2502 * of memory to interleave with this, so its prefereable to interleave at the
2505 * @param s media file handle
2506 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2507 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2509 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2510 AVStream *st= s->streams[ pkt->stream_index];
2512 //FIXME/XXX/HACK drop zero sized packets
2513 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2516 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2517 if(compute_pkt_fields2(st, pkt) < 0)
2520 if(pkt->dts == AV_NOPTS_VALUE)
2525 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2526 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2529 truncate_ts(s->streams[opkt.stream_index], &opkt);
2530 ret= s->oformat->write_packet(s, &opkt);
2532 av_free_packet(&opkt);
2537 if(url_ferror(&s->pb))
2538 return url_ferror(&s->pb);
2543 * @brief Write the stream trailer to an output media file and
2544 * free the file private data.
2546 * @param s media file handle
2547 * @return 0 if OK. AVERROR_xxx if error.
2549 int av_write_trailer(AVFormatContext *s)
2555 ret= av_interleave_packet(s, &pkt, NULL, 1);
2556 if(ret<0) //FIXME cleanup needed for ret<0 ?
2561 truncate_ts(s->streams[pkt.stream_index], &pkt);
2562 ret= s->oformat->write_packet(s, &pkt);
2564 av_free_packet(&pkt);
2568 if(url_ferror(&s->pb))
2572 if(s->oformat->write_trailer)
2573 ret = s->oformat->write_trailer(s);
2576 ret=url_ferror(&s->pb);
2577 for(i=0;i<s->nb_streams;i++)
2578 av_freep(&s->streams[i]->priv_data);
2579 av_freep(&s->priv_data);
2583 /* "user interface" functions */
2585 void dump_format(AVFormatContext *ic,
2593 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2594 is_output ? "Output" : "Input",
2596 is_output ? ic->oformat->name : ic->iformat->name,
2597 is_output ? "to" : "from", url);
2599 av_log(NULL, AV_LOG_INFO, " Duration: ");
2600 if (ic->duration != AV_NOPTS_VALUE) {
2601 int hours, mins, secs, us;
2602 secs = ic->duration / AV_TIME_BASE;
2603 us = ic->duration % AV_TIME_BASE;
2608 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2609 (10 * us) / AV_TIME_BASE);
2611 av_log(NULL, AV_LOG_INFO, "N/A");
2613 if (ic->start_time != AV_NOPTS_VALUE) {
2615 av_log(NULL, AV_LOG_INFO, ", start: ");
2616 secs = ic->start_time / AV_TIME_BASE;
2617 us = ic->start_time % AV_TIME_BASE;
2618 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2619 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2621 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2623 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2625 av_log(NULL, AV_LOG_INFO, "N/A");
2627 av_log(NULL, AV_LOG_INFO, "\n");
2629 for(i=0;i<ic->nb_streams;i++) {
2630 AVStream *st = ic->streams[i];
2631 int g= ff_gcd(st->time_base.num, st->time_base.den);
2632 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2633 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2634 /* the pid is an important information, so we display it */
2635 /* XXX: add a generic system */
2637 flags = ic->oformat->flags;
2639 flags = ic->iformat->flags;
2640 if (flags & AVFMT_SHOW_IDS) {
2641 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2643 if (strlen(st->language) > 0) {
2644 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2646 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2647 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2648 if(st->r_frame_rate.den && st->r_frame_rate.num)
2649 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2650 /* else if(st->time_base.den && st->time_base.num)
2651 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2653 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2655 av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
2662 int frame_rate, frame_rate_base;
2665 static AbvEntry frame_abvs[] = {
2666 { "ntsc", 720, 480, 30000, 1001 },
2667 { "pal", 720, 576, 25, 1 },
2668 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2669 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2670 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2671 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2672 { "film", 352, 240, 24, 1 },
2673 { "ntsc-film", 352, 240, 24000, 1001 },
2674 { "sqcif", 128, 96, 0, 0 },
2675 { "qcif", 176, 144, 0, 0 },
2676 { "cif", 352, 288, 0, 0 },
2677 { "4cif", 704, 576, 0, 0 },
2681 * parses width and height out of string str.
2683 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2686 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2688 int frame_width = 0, frame_height = 0;
2691 if (!strcmp(frame_abvs[i].abv, str)) {
2692 frame_width = frame_abvs[i].width;
2693 frame_height = frame_abvs[i].height;
2699 frame_width = strtol(p, (char **)&p, 10);
2702 frame_height = strtol(p, (char **)&p, 10);
2704 if (frame_width <= 0 || frame_height <= 0)
2706 *width_ptr = frame_width;
2707 *height_ptr = frame_height;
2712 * Converts frame rate from string to a fraction.
2714 * First we try to get an exact integer or fractional frame rate.
2715 * If this fails we convert the frame rate to a double and return
2716 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2718 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2723 /* First, we check our abbreviation table */
2724 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2725 if (!strcmp(frame_abvs[i].abv, arg)) {
2726 *frame_rate = frame_abvs[i].frame_rate;
2727 *frame_rate_base = frame_abvs[i].frame_rate_base;
2731 /* Then, we try to parse it as fraction */
2732 cp = strchr(arg, '/');
2734 cp = strchr(arg, ':');
2737 *frame_rate = strtol(arg, &cpp, 10);
2738 if (cpp != arg || cpp == cp)
2739 *frame_rate_base = strtol(cp+1, &cpp, 10);
2744 /* Finally we give up and parse it as double */
2745 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2746 *frame_rate_base = time_base.den;
2747 *frame_rate = time_base.num;
2749 if (!*frame_rate || !*frame_rate_base)
2756 * Converts date string to number of seconds since Jan 1st, 1970.
2760 * - If not a duration:
2761 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2762 * Time is localtime unless Z is suffixed to the end. In this case GMT
2763 * Return the date in micro seconds since 1970
2766 * HH[:MM[:SS[.m...]]]
2770 #ifndef CONFIG_WINCE
2771 int64_t parse_date(const char *datestr, int duration)
2777 static const char *date_fmt[] = {
2781 static const char *time_fmt[] = {
2791 time_t now = time(0);
2793 len = strlen(datestr);
2795 lastch = datestr[len - 1];
2798 is_utc = (lastch == 'z' || lastch == 'Z');
2800 memset(&dt, 0, sizeof(dt));
2805 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2806 q = small_strptime(p, date_fmt[i], &dt);
2816 dt = *localtime(&now);
2818 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2823 if (*p == 'T' || *p == 't' || *p == ' ')
2826 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2827 q = small_strptime(p, time_fmt[i], &dt);
2837 q = small_strptime(p, time_fmt[0], &dt);
2839 dt.tm_sec = strtol(p, (char **)&q, 10);
2845 /* Now we have all the fields that we can get */
2850 return now * int64_t_C(1000000);
2854 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2856 dt.tm_isdst = -1; /* unknown */
2869 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2872 val += n * (*q - '0');
2876 return negative ? -t : t;
2878 #endif /* CONFIG_WINCE */
2881 * Attempts to find a specific tag in a URL.
2883 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2884 * Return 1 if found.
2886 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2896 while (*p != '\0' && *p != '=' && *p != '&') {
2897 if ((q - tag) < sizeof(tag) - 1)
2905 while (*p != '&' && *p != '\0') {
2906 if ((q - arg) < arg_size - 1) {
2916 if (!strcmp(tag, tag1))
2926 * Returns in 'buf' the path with '%d' replaced by number.
2928 * Also handles the '%0nd' format where 'n' is the total number
2929 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2931 int get_frame_filename(char *buf, int buf_size,
2932 const char *path, int number)
2935 char *q, buf1[20], c;
2936 int nd, len, percentd_found;
2948 while (isdigit(*p)) {
2949 nd = nd * 10 + *p++ - '0';
2952 } while (isdigit(c));
2961 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2963 if ((q - buf + len) > buf_size - 1)
2965 memcpy(q, buf1, len);
2973 if ((q - buf) < buf_size - 1)
2977 if (!percentd_found)
2987 * Print nice hexa dump of a buffer
2988 * @param f stream for output
2990 * @param size buffer size
2992 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2996 for(i=0;i<size;i+=16) {
3000 fprintf(f, "%08x ", i);
3003 fprintf(f, " %02x", buf[i+j]);
3008 for(j=0;j<len;j++) {
3010 if (c < ' ' || c > '~')
3012 fprintf(f, "%c", c);
3019 * Print on 'f' a nice dump of a packet
3020 * @param f stream for output
3021 * @param pkt packet to dump
3022 * @param dump_payload true if the payload must be displayed too
3024 //FIXME needs to know the time_base
3025 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3027 fprintf(f, "stream #%d:\n", pkt->stream_index);
3028 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3029 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3030 /* DTS is _always_ valid after av_read_frame() */
3031 fprintf(f, " dts=");
3032 if (pkt->dts == AV_NOPTS_VALUE)
3035 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3036 /* PTS may be not known if B frames are present */
3037 fprintf(f, " pts=");
3038 if (pkt->pts == AV_NOPTS_VALUE)
3041 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3043 fprintf(f, " size=%d\n", pkt->size);
3045 av_hex_dump(f, pkt->data, pkt->size);
3048 void url_split(char *proto, int proto_size,
3049 char *authorization, int authorization_size,
3050 char *hostname, int hostname_size,
3052 char *path, int path_size,
3063 while (*p != ':' && *p != '\0') {
3064 if ((q - proto) < proto_size - 1)
3070 if (authorization_size > 0)
3071 authorization[0] = '\0';
3075 if (hostname_size > 0)
3079 char *at,*slash; // PETR: position of '@' character and '/' character
3086 at = strchr(p,'@'); // PETR: get the position of '@'
3087 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3088 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3090 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3092 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3093 if (*p == '@') { // PETR: passed '@'
3094 if (authorization_size > 0)
3098 } else if (!at) { // PETR: hostname
3099 if ((q - hostname) < hostname_size - 1)
3102 if ((q - authorization) < authorization_size - 1)
3107 if (hostname_size > 0)
3111 port = strtoul(p, (char **)&p, 10);
3116 pstrcpy(path, path_size, p);
3120 * Set the pts for a given stream.
3123 * @param pts_wrap_bits number of bits effectively used by the pts
3124 * (used for wrap control, 33 is the value for MPEG)
3125 * @param pts_num numerator to convert to seconds (MPEG: 1)
3126 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3128 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3129 int pts_num, int pts_den)
3131 s->pts_wrap_bits = pts_wrap_bits;
3132 s->time_base.num = pts_num;
3133 s->time_base.den = pts_den;
3136 /* fraction handling */
3139 * f = val + (num / den) + 0.5.
3141 * 'num' is normalized so that it is such as 0 <= num < den.
3143 * @param f fractional number
3144 * @param val integer value
3145 * @param num must be >= 0
3146 * @param den must be >= 1
3148 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3161 * Set f to (val + 0.5).
3163 void av_frac_set(AVFrac *f, int64_t val)
3166 f->num = f->den >> 1;
3170 * Fractionnal addition to f: f = f + (incr / f->den).
3172 * @param f fractional number
3173 * @param incr increment, can be positive or negative
3175 void av_frac_add(AVFrac *f, int64_t incr)
3179 num = f->num + incr;
3182 f->val += num / den;
3188 } else if (num >= den) {
3189 f->val += num / den;
3196 * register a new image format
3197 * @param img_fmt Image format descriptor
3199 void av_register_image_format(AVImageFormat *img_fmt)
3203 p = &first_image_format;
3204 while (*p != NULL) p = &(*p)->next;
3206 img_fmt->next = NULL;
3210 * Guesses image format based on data in the image.
3212 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3214 AVImageFormat *fmt1, *fmt;
3215 int score, score_max;
3219 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3220 if (fmt1->img_probe) {
3221 score = fmt1->img_probe(pd);
3222 if (score > score_max) {
3232 * Guesses image format based on file name extensions.
3234 AVImageFormat *guess_image_format(const char *filename)
3236 AVImageFormat *fmt1;
3238 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3239 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3246 * Read an image from a stream.
3247 * @param gb byte stream containing the image
3248 * @param fmt image format, NULL if probing is required
3250 int av_read_image(ByteIOContext *pb, const char *filename,
3252 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3254 uint8_t buf[PROBE_BUF_MIN];
3255 AVProbeData probe_data, *pd = &probe_data;
3260 pd->filename = filename;
3262 pos = url_ftell(pb);
3263 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3264 url_fseek(pb, pos, SEEK_SET);
3265 fmt = av_probe_image_format(pd);
3268 return AVERROR_NOFMT;
3269 ret = fmt->img_read(pb, alloc_cb, opaque);
3274 * Write an image to a stream.
3275 * @param pb byte stream for the image output
3276 * @param fmt image format
3277 * @param img image data and informations
3279 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3281 return fmt->img_write(pb, img);