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)
469 ic = av_alloc_format_context();
477 ic->duration = AV_NOPTS_VALUE;
478 ic->start_time = AV_NOPTS_VALUE;
479 pstrcpy(ic->filename, sizeof(ic->filename), filename);
481 /* allocate private data */
482 if (fmt->priv_data_size > 0) {
483 ic->priv_data = av_mallocz(fmt->priv_data_size);
484 if (!ic->priv_data) {
489 ic->priv_data = NULL;
492 err = ic->iformat->read_header(ic, ap);
497 ic->data_offset = url_ftell(&ic->pb);
503 av_freep(&ic->priv_data);
510 /** Size of probe buffer, for guessing file type from file contents. */
511 #define PROBE_BUF_SIZE 2048
514 * Open a media file as input. The codec are not opened. Only the file
515 * header (if present) is read.
517 * @param ic_ptr the opened media file handle is put here
518 * @param filename filename to open.
519 * @param fmt if non NULL, force the file format to use
520 * @param buf_size optional buffer size (zero if default is OK)
521 * @param ap additionnal parameters needed when opening the file (NULL if default)
522 * @return 0 if OK. AVERROR_xxx otherwise.
524 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
527 AVFormatParameters *ap)
529 int err, must_open_file, file_opened;
530 uint8_t buf[PROBE_BUF_SIZE];
531 AVProbeData probe_data, *pd = &probe_data;
532 ByteIOContext pb1, *pb = &pb1;
537 pd->filename = filename;
542 /* guess format if no file can be opened */
543 fmt = av_probe_input_format(pd, 0);
546 /* do not open file if the format does not need it. XXX: specific
547 hack needed to handle RTSP/TCP */
549 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
551 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
554 if (!fmt || must_open_file) {
555 /* if no file needed do not try to open one */
556 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
562 url_setbufsize(pb, buf_size);
565 /* read probe data */
566 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
567 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
569 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
577 /* guess file format */
579 fmt = av_probe_input_format(pd, 1);
582 /* if still no format found, error */
588 /* XXX: suppress this hack for redirectors */
589 #ifdef CONFIG_NETWORK
590 if (fmt == &redir_demux) {
591 err = redir_open(ic_ptr, pb);
597 /* check filename in case of an image number is expected */
598 if (fmt->flags & AVFMT_NEEDNUMBER) {
599 if (filename_number_test(filename) < 0) {
600 err = AVERROR_NUMEXPECTED;
604 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
616 /*******************************************************/
619 * Read a transport packet from a media file.
621 * This function is absolete and should never be used.
622 * Use av_read_frame() instead.
624 * @param s media file handle
625 * @param pkt is filled
626 * @return 0 if OK. AVERROR_xxx if error.
628 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
630 return s->iformat->read_packet(s, pkt);
633 /**********************************************************/
636 * Get the number of samples of an audio frame. Return (-1) if error.
638 static int get_audio_frame_size(AVCodecContext *enc, int size)
642 if (enc->frame_size <= 1) {
643 /* specific hack for pcm codecs because no frame size is
645 switch(enc->codec_id) {
646 case CODEC_ID_PCM_S32LE:
647 case CODEC_ID_PCM_S32BE:
648 case CODEC_ID_PCM_U32LE:
649 case CODEC_ID_PCM_U32BE:
650 if (enc->channels == 0)
652 frame_size = size / (4 * enc->channels);
654 case CODEC_ID_PCM_S24LE:
655 case CODEC_ID_PCM_S24BE:
656 case CODEC_ID_PCM_U24LE:
657 case CODEC_ID_PCM_U24BE:
658 case CODEC_ID_PCM_S24DAUD:
659 if (enc->channels == 0)
661 frame_size = size / (3 * enc->channels);
663 case CODEC_ID_PCM_S16LE:
664 case CODEC_ID_PCM_S16BE:
665 case CODEC_ID_PCM_U16LE:
666 case CODEC_ID_PCM_U16BE:
667 if (enc->channels == 0)
669 frame_size = size / (2 * enc->channels);
671 case CODEC_ID_PCM_S8:
672 case CODEC_ID_PCM_U8:
673 case CODEC_ID_PCM_MULAW:
674 case CODEC_ID_PCM_ALAW:
675 if (enc->channels == 0)
677 frame_size = size / (enc->channels);
680 /* used for example by ADPCM codecs */
681 if (enc->bit_rate == 0)
683 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
687 frame_size = enc->frame_size;
694 * Return the frame duration in seconds, return 0 if not available.
696 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
697 AVCodecParserContext *pc, AVPacket *pkt)
703 switch(st->codec->codec_type) {
704 case CODEC_TYPE_VIDEO:
705 if(st->time_base.num*1000LL > st->time_base.den){
706 *pnum = st->time_base.num;
707 *pden = st->time_base.den;
708 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
709 *pnum = st->codec->time_base.num;
710 *pden = st->codec->time_base.den;
711 if (pc && pc->repeat_pict) {
713 *pnum = (*pnum) * (2 + pc->repeat_pict);
717 case CODEC_TYPE_AUDIO:
718 frame_size = get_audio_frame_size(st->codec, pkt->size);
722 *pden = st->codec->sample_rate;
729 static int is_intra_only(AVCodecContext *enc){
730 if(enc->codec_type == CODEC_TYPE_AUDIO){
732 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
733 switch(enc->codec_id){
735 case CODEC_ID_MJPEGB:
737 case CODEC_ID_RAWVIDEO:
738 case CODEC_ID_DVVIDEO:
739 case CODEC_ID_HUFFYUV:
740 case CODEC_ID_FFVHUFF:
751 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
752 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
753 int64_t delta= last_ts - mask/2;
754 return ((lsb - delta)&mask) + delta;
757 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
758 AVCodecParserContext *pc, AVPacket *pkt)
760 int num, den, presentation_delayed;
761 /* handle wrapping */
762 if(st->cur_dts != AV_NOPTS_VALUE){
763 if(pkt->pts != AV_NOPTS_VALUE)
764 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
765 if(pkt->dts != AV_NOPTS_VALUE)
766 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
769 if (pkt->duration == 0) {
770 compute_frame_duration(&num, &den, st, pc, pkt);
772 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
776 if(is_intra_only(st->codec))
777 pkt->flags |= PKT_FLAG_KEY;
779 /* do we have a video B frame ? */
780 presentation_delayed = 0;
781 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
782 /* XXX: need has_b_frame, but cannot get it if the codec is
784 if (( st->codec->codec_id == CODEC_ID_H264
785 || st->codec->has_b_frames) &&
786 pc && pc->pict_type != FF_B_TYPE)
787 presentation_delayed = 1;
788 /* this may be redundant, but it shouldnt hurt */
789 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
790 presentation_delayed = 1;
793 if(st->cur_dts == AV_NOPTS_VALUE){
794 if(presentation_delayed) st->cur_dts = -pkt->duration;
795 else st->cur_dts = 0;
798 // 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);
799 /* interpolate PTS and DTS if they are not present */
800 if (presentation_delayed) {
801 /* DTS = decompression time stamp */
802 /* PTS = presentation time stamp */
803 if (pkt->dts == AV_NOPTS_VALUE) {
804 /* if we know the last pts, use it */
805 if(st->last_IP_pts != AV_NOPTS_VALUE)
806 st->cur_dts = pkt->dts = st->last_IP_pts;
808 pkt->dts = st->cur_dts;
810 st->cur_dts = pkt->dts;
812 /* this is tricky: the dts must be incremented by the duration
813 of the frame we are displaying, i.e. the last I or P frame */
814 if (st->last_IP_duration == 0)
815 st->cur_dts += pkt->duration;
817 st->cur_dts += st->last_IP_duration;
818 st->last_IP_duration = pkt->duration;
819 st->last_IP_pts= pkt->pts;
820 /* cannot compute PTS if not present (we can compute it only
821 by knowing the futur */
822 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
823 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
824 int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
825 int64_t new_diff= ABS(st->cur_dts - pkt->pts);
826 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
827 pkt->pts += pkt->duration;
828 // 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);
832 /* presentation is not delayed : PTS and DTS are the same */
833 if (pkt->pts == AV_NOPTS_VALUE) {
834 if (pkt->dts == AV_NOPTS_VALUE) {
835 pkt->pts = st->cur_dts;
836 pkt->dts = st->cur_dts;
839 st->cur_dts = pkt->dts;
843 st->cur_dts = pkt->pts;
846 st->cur_dts += pkt->duration;
848 // 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);
853 /* key frame computation */
854 switch(st->codec->codec_type) {
855 case CODEC_TYPE_VIDEO:
856 if (pc->pict_type == FF_I_TYPE)
857 pkt->flags |= PKT_FLAG_KEY;
859 case CODEC_TYPE_AUDIO:
860 pkt->flags |= PKT_FLAG_KEY;
868 void av_destruct_packet_nofree(AVPacket *pkt)
870 pkt->data = NULL; pkt->size = 0;
873 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
879 /* select current input stream component */
882 if (!st->need_parsing || !st->parser) {
883 /* no parsing needed: we just output the packet as is */
884 /* raw data support */
886 compute_pkt_fields(s, st, NULL, pkt);
889 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
890 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
891 s->cur_ptr, s->cur_len,
892 s->cur_pkt.pts, s->cur_pkt.dts);
893 s->cur_pkt.pts = AV_NOPTS_VALUE;
894 s->cur_pkt.dts = AV_NOPTS_VALUE;
895 /* increment read pointer */
899 /* return packet if any */
903 pkt->stream_index = st->index;
904 pkt->pts = st->parser->pts;
905 pkt->dts = st->parser->dts;
906 pkt->destruct = av_destruct_packet_nofree;
907 compute_pkt_fields(s, st, st->parser, pkt);
912 av_free_packet(&s->cur_pkt);
916 /* read next packet */
917 ret = av_read_packet(s, &s->cur_pkt);
921 /* return the last frames, if any */
922 for(i = 0; i < s->nb_streams; i++) {
924 if (st->parser && st->need_parsing) {
925 av_parser_parse(st->parser, st->codec,
926 &pkt->data, &pkt->size,
928 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
933 /* no more packets: really terminates parsing */
937 st = s->streams[s->cur_pkt.stream_index];
940 s->cur_ptr = s->cur_pkt.data;
941 s->cur_len = s->cur_pkt.size;
942 if (st->need_parsing && !st->parser) {
943 st->parser = av_parser_init(st->codec->codec_id);
945 /* no parser available : just output the raw packets */
946 st->need_parsing = 0;
947 }else if(st->need_parsing == 2){
948 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
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 static 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 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;
1175 * build an index for raw streams using a parser.
1177 static void av_build_index_raw(AVFormatContext *s)
1179 AVPacket pkt1, *pkt = &pkt1;
1184 av_read_frame_flush(s);
1185 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1188 ret = av_read_frame(s, pkt);
1191 if (pkt->stream_index == 0 && st->parser &&
1192 (pkt->flags & PKT_FLAG_KEY)) {
1193 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1194 0, AVINDEX_KEYFRAME);
1196 av_free_packet(pkt);
1201 * Returns TRUE if we deal with a raw stream.
1203 * Raw codec data and parsing needed.
1205 static int is_raw_stream(AVFormatContext *s)
1209 if (s->nb_streams != 1)
1212 if (!st->need_parsing)
1218 * Gets the index for a specific timestamp.
1219 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1220 * the timestamp which is <= the requested one, if backward is 0
1221 * then it will be >=
1222 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1223 * @return < 0 if no such timestamp could be found
1225 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1228 AVIndexEntry *entries= st->index_entries;
1229 int nb_entries= st->nb_index_entries;
1238 timestamp = entries[m].timestamp;
1239 if(timestamp >= wanted_timestamp)
1241 if(timestamp <= wanted_timestamp)
1244 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1246 if(!(flags & AVSEEK_FLAG_ANY)){
1247 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1248 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1260 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1261 * this isnt supposed to be called directly by a user application, but by demuxers
1262 * @param target_ts target timestamp in the time base of the given stream
1263 * @param stream_index stream number
1265 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1266 AVInputFormat *avif= s->iformat;
1267 int64_t pos_min, pos_max, pos, pos_limit;
1268 int64_t ts_min, ts_max, ts;
1269 int64_t start_pos, filesize;
1270 int index, no_change;
1273 if (stream_index < 0)
1277 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1281 ts_min= AV_NOPTS_VALUE;
1282 pos_limit= -1; //gcc falsely says it may be uninitalized
1284 st= s->streams[stream_index];
1285 if(st->index_entries){
1288 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()
1289 index= FFMAX(index, 0);
1290 e= &st->index_entries[index];
1292 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1294 ts_min= e->timestamp;
1296 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1303 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1304 assert(index < st->nb_index_entries);
1306 e= &st->index_entries[index];
1307 assert(e->timestamp >= target_ts);
1309 ts_max= e->timestamp;
1310 pos_limit= pos_max - e->min_distance;
1312 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1313 pos_max,pos_limit, ts_max);
1318 if(ts_min == AV_NOPTS_VALUE){
1319 pos_min = s->data_offset;
1320 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1321 if (ts_min == AV_NOPTS_VALUE)
1325 if(ts_max == AV_NOPTS_VALUE){
1327 filesize = url_fsize(&s->pb);
1328 pos_max = filesize - 1;
1331 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1333 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1334 if (ts_max == AV_NOPTS_VALUE)
1338 int64_t tmp_pos= pos_max + 1;
1339 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1340 if(tmp_ts == AV_NOPTS_VALUE)
1344 if(tmp_pos >= filesize)
1351 while (pos_min < pos_limit) {
1353 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1357 assert(pos_limit <= pos_max);
1360 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1361 // interpolate position (better than dichotomy)
1362 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1363 + pos_min - approximate_keyframe_distance;
1364 }else if(no_change==1){
1365 // bisection, if interpolation failed to change min or max pos last time
1366 pos = (pos_min + pos_limit)>>1;
1368 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1373 else if(pos > pos_limit)
1377 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1383 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);
1385 assert(ts != AV_NOPTS_VALUE);
1386 if (target_ts <= ts) {
1387 pos_limit = start_pos - 1;
1391 if (target_ts >= ts) {
1397 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1398 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1401 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1403 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1404 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1405 pos, ts_min, target_ts, ts_max);
1408 url_fseek(&s->pb, pos, SEEK_SET);
1410 av_update_cur_dts(s, st, ts);
1415 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1416 int64_t pos_min, pos_max;
1420 if (stream_index < 0)
1423 st= s->streams[stream_index];
1426 pos_min = s->data_offset;
1427 pos_max = url_fsize(&s->pb) - 1;
1429 if (pos < pos_min) pos= pos_min;
1430 else if(pos > pos_max) pos= pos_max;
1432 url_fseek(&s->pb, pos, SEEK_SET);
1435 av_update_cur_dts(s, st, ts);
1440 static int av_seek_frame_generic(AVFormatContext *s,
1441 int stream_index, int64_t timestamp, int flags)
1447 if (!s->index_built) {
1448 if (is_raw_stream(s)) {
1449 av_build_index_raw(s);
1456 st = s->streams[stream_index];
1457 index = av_index_search_timestamp(st, timestamp, flags);
1461 /* now we have found the index, we can seek */
1462 ie = &st->index_entries[index];
1463 av_read_frame_flush(s);
1464 url_fseek(&s->pb, ie->pos, SEEK_SET);
1466 av_update_cur_dts(s, st, ie->timestamp);
1472 * Seek to the key frame at timestamp.
1473 * 'timestamp' in 'stream_index'.
1474 * @param stream_index If stream_index is (-1), a default
1475 * stream is selected, and timestamp is automatically converted
1476 * from AV_TIME_BASE units to the stream specific time_base.
1477 * @param timestamp timestamp in AVStream.time_base units
1478 * or if there is no stream specified then in AV_TIME_BASE units
1479 * @param flags flags which select direction and seeking mode
1480 * @return >= 0 on success
1482 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1487 av_read_frame_flush(s);
1489 if(flags & AVSEEK_FLAG_BYTE)
1490 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1492 if(stream_index < 0){
1493 stream_index= av_find_default_stream_index(s);
1494 if(stream_index < 0)
1497 st= s->streams[stream_index];
1498 /* timestamp for default must be expressed in AV_TIME_BASE units */
1499 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1501 st= s->streams[stream_index];
1503 /* first, we try the format specific seek */
1504 if (s->iformat->read_seek)
1505 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1512 if(s->iformat->read_timestamp)
1513 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1515 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1518 /*******************************************************/
1521 * Returns TRUE if the stream has accurate timings in any stream.
1523 * @return TRUE if the stream has accurate timings for at least one component.
1525 static int av_has_timings(AVFormatContext *ic)
1530 for(i = 0;i < ic->nb_streams; i++) {
1531 st = ic->streams[i];
1532 if (st->start_time != AV_NOPTS_VALUE &&
1533 st->duration != AV_NOPTS_VALUE)
1540 * Estimate the stream timings from the one of each components.
1542 * Also computes the global bitrate if possible.
1544 static void av_update_stream_timings(AVFormatContext *ic)
1546 int64_t start_time, start_time1, end_time, end_time1;
1550 start_time = MAXINT64;
1551 end_time = MININT64;
1552 for(i = 0;i < ic->nb_streams; i++) {
1553 st = ic->streams[i];
1554 if (st->start_time != AV_NOPTS_VALUE) {
1555 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1556 if (start_time1 < start_time)
1557 start_time = start_time1;
1558 if (st->duration != AV_NOPTS_VALUE) {
1559 end_time1 = start_time1
1560 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1561 if (end_time1 > end_time)
1562 end_time = end_time1;
1566 if (start_time != MAXINT64) {
1567 ic->start_time = start_time;
1568 if (end_time != MININT64) {
1569 ic->duration = end_time - start_time;
1570 if (ic->file_size > 0) {
1571 /* compute the bit rate */
1572 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1573 (double)ic->duration;
1580 static void fill_all_stream_timings(AVFormatContext *ic)
1585 av_update_stream_timings(ic);
1586 for(i = 0;i < ic->nb_streams; i++) {
1587 st = ic->streams[i];
1588 if (st->start_time == AV_NOPTS_VALUE) {
1589 if(ic->start_time != AV_NOPTS_VALUE)
1590 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1591 if(ic->duration != AV_NOPTS_VALUE)
1592 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1597 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1599 int64_t filesize, duration;
1603 /* if bit_rate is already set, we believe it */
1604 if (ic->bit_rate == 0) {
1606 for(i=0;i<ic->nb_streams;i++) {
1607 st = ic->streams[i];
1608 bit_rate += st->codec->bit_rate;
1610 ic->bit_rate = bit_rate;
1613 /* if duration is already set, we believe it */
1614 if (ic->duration == AV_NOPTS_VALUE &&
1615 ic->bit_rate != 0 &&
1616 ic->file_size != 0) {
1617 filesize = ic->file_size;
1619 for(i = 0; i < ic->nb_streams; i++) {
1620 st = ic->streams[i];
1621 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1622 if (st->start_time == AV_NOPTS_VALUE ||
1623 st->duration == AV_NOPTS_VALUE) {
1625 st->duration = duration;
1632 #define DURATION_MAX_READ_SIZE 250000
1634 /* only usable for MPEG-PS streams */
1635 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1637 AVPacket pkt1, *pkt = &pkt1;
1639 int read_size, i, ret;
1641 int64_t filesize, offset, duration;
1643 /* free previous packet */
1644 if (ic->cur_st && ic->cur_st->parser)
1645 av_free_packet(&ic->cur_pkt);
1648 /* flush packet queue */
1649 flush_packet_queue(ic);
1651 for(i=0;i<ic->nb_streams;i++) {
1652 st = ic->streams[i];
1654 av_parser_close(st->parser);
1659 /* we read the first packets to get the first PTS (not fully
1660 accurate, but it is enough now) */
1661 url_fseek(&ic->pb, 0, SEEK_SET);
1664 if (read_size >= DURATION_MAX_READ_SIZE)
1666 /* if all info is available, we can stop */
1667 for(i = 0;i < ic->nb_streams; i++) {
1668 st = ic->streams[i];
1669 if (st->start_time == AV_NOPTS_VALUE)
1672 if (i == ic->nb_streams)
1675 ret = av_read_packet(ic, pkt);
1678 read_size += pkt->size;
1679 st = ic->streams[pkt->stream_index];
1680 if (pkt->pts != AV_NOPTS_VALUE) {
1681 if (st->start_time == AV_NOPTS_VALUE)
1682 st->start_time = pkt->pts;
1684 av_free_packet(pkt);
1687 /* estimate the end time (duration) */
1688 /* XXX: may need to support wrapping */
1689 filesize = ic->file_size;
1690 offset = filesize - DURATION_MAX_READ_SIZE;
1694 url_fseek(&ic->pb, offset, SEEK_SET);
1697 if (read_size >= DURATION_MAX_READ_SIZE)
1699 /* if all info is available, we can stop */
1700 for(i = 0;i < ic->nb_streams; i++) {
1701 st = ic->streams[i];
1702 if (st->duration == AV_NOPTS_VALUE)
1705 if (i == ic->nb_streams)
1708 ret = av_read_packet(ic, pkt);
1711 read_size += pkt->size;
1712 st = ic->streams[pkt->stream_index];
1713 if (pkt->pts != AV_NOPTS_VALUE) {
1714 end_time = pkt->pts;
1715 duration = end_time - st->start_time;
1717 if (st->duration == AV_NOPTS_VALUE ||
1718 st->duration < duration)
1719 st->duration = duration;
1722 av_free_packet(pkt);
1725 fill_all_stream_timings(ic);
1727 url_fseek(&ic->pb, 0, SEEK_SET);
1730 static void av_estimate_timings(AVFormatContext *ic)
1734 /* get the file size, if possible */
1735 if (ic->iformat->flags & AVFMT_NOFILE) {
1738 file_size = url_fsize(&ic->pb);
1742 ic->file_size = file_size;
1744 if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
1745 /* get accurate estimate from the PTSes */
1746 av_estimate_timings_from_pts(ic);
1747 } else if (av_has_timings(ic)) {
1748 /* at least one components has timings - we use them for all
1750 fill_all_stream_timings(ic);
1752 /* less precise: use bit rate info */
1753 av_estimate_timings_from_bit_rate(ic);
1755 av_update_stream_timings(ic);
1761 for(i = 0;i < ic->nb_streams; i++) {
1762 st = ic->streams[i];
1763 printf("%d: start_time: %0.3f duration: %0.3f\n",
1764 i, (double)st->start_time / AV_TIME_BASE,
1765 (double)st->duration / AV_TIME_BASE);
1767 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1768 (double)ic->start_time / AV_TIME_BASE,
1769 (double)ic->duration / AV_TIME_BASE,
1770 ic->bit_rate / 1000);
1775 static int has_codec_parameters(AVCodecContext *enc)
1778 switch(enc->codec_type) {
1779 case CODEC_TYPE_AUDIO:
1780 val = enc->sample_rate;
1782 case CODEC_TYPE_VIDEO:
1783 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1792 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1796 int got_picture, ret=0;
1799 if(!st->codec->codec){
1800 codec = avcodec_find_decoder(st->codec->codec_id);
1803 ret = avcodec_open(st->codec, codec);
1808 if(!has_codec_parameters(st->codec)){
1809 switch(st->codec->codec_type) {
1810 case CODEC_TYPE_VIDEO:
1811 ret = avcodec_decode_video(st->codec, &picture,
1812 &got_picture, (uint8_t *)data, size);
1814 case CODEC_TYPE_AUDIO:
1815 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1818 ret = avcodec_decode_audio(st->codec, samples,
1819 &got_picture, (uint8_t *)data, size);
1830 /* absolute maximum size we read until we abort */
1831 #define MAX_READ_SIZE 5000000
1833 /* maximum duration until we stop analysing the stream */
1834 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 2.0))
1837 * Read the beginning of a media file to get stream information. This
1838 * is useful for file formats with no headers such as MPEG. This
1839 * function also compute the real frame rate in case of mpeg2 repeat
1842 * @param ic media file handle
1843 * @return >=0 if OK. AVERROR_xxx if error.
1844 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1846 int av_find_stream_info(AVFormatContext *ic)
1848 int i, count, ret, read_size;
1850 AVPacket pkt1, *pkt;
1851 AVPacketList *pktl=NULL, **ppktl;
1852 int64_t last_dts[MAX_STREAMS];
1853 int64_t duration_sum[MAX_STREAMS];
1854 int duration_count[MAX_STREAMS]={0};
1856 for(i=0;i<ic->nb_streams;i++) {
1857 st = ic->streams[i];
1858 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1859 /* if(!st->time_base.num)
1861 if(!st->codec->time_base.num)
1862 st->codec->time_base= st->time_base;
1864 //only for the split stuff
1866 st->parser = av_parser_init(st->codec->codec_id);
1867 if(st->need_parsing == 2 && st->parser){
1868 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1873 for(i=0;i<MAX_STREAMS;i++){
1874 last_dts[i]= AV_NOPTS_VALUE;
1875 duration_sum[i]= INT64_MAX;
1880 ppktl = &ic->packet_buffer;
1882 /* check if one codec still needs to be handled */
1883 for(i=0;i<ic->nb_streams;i++) {
1884 st = ic->streams[i];
1885 if (!has_codec_parameters(st->codec))
1887 /* variable fps and no guess at the real fps */
1888 if( st->codec->time_base.den >= 1000LL*st->codec->time_base.num
1889 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1891 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1894 if (i == ic->nb_streams) {
1895 /* NOTE: if the format has no header, then we need to read
1896 some packets to get most of the streams, so we cannot
1898 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1899 /* if we found the info for all the codecs, we can stop */
1904 /* we did not get all the codec info, but we read too much data */
1905 if (read_size >= MAX_READ_SIZE) {
1911 /* NOTE: a new stream can be added there if no header in file
1912 (AVFMTCTX_NOHEADER) */
1913 ret = av_read_frame_internal(ic, &pkt1);
1916 ret = -1; /* we could not have all the codec parameters before EOF */
1917 for(i=0;i<ic->nb_streams;i++) {
1918 st = ic->streams[i];
1919 if (!has_codec_parameters(st->codec))
1922 if (i == ic->nb_streams)
1927 pktl = av_mallocz(sizeof(AVPacketList));
1929 ret = AVERROR_NOMEM;
1933 /* add the packet in the buffered packet list */
1935 ppktl = &pktl->next;
1940 /* duplicate the packet */
1941 if (av_dup_packet(pkt) < 0) {
1942 ret = AVERROR_NOMEM;
1946 read_size += pkt->size;
1948 st = ic->streams[pkt->stream_index];
1949 st->codec_info_duration += pkt->duration;
1950 if (pkt->duration != 0)
1951 st->codec_info_nb_frames++;
1954 int index= pkt->stream_index;
1955 int64_t last= last_dts[index];
1956 int64_t duration= pkt->dts - last;
1958 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1959 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1960 duration_sum[index]= duration;
1961 duration_count[index]=1;
1963 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1964 duration_sum[index] += duration;
1965 duration_count[index]+= factor;
1967 if(st->codec_info_nb_frames == 0 && 0)
1968 st->codec_info_duration += duration;
1970 last_dts[pkt->stream_index]= pkt->dts;
1972 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1973 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1975 st->codec->extradata_size= i;
1976 st->codec->extradata= av_malloc(st->codec->extradata_size);
1977 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1981 /* if still no information, we try to open the codec and to
1982 decompress the frame. We try to avoid that in most cases as
1983 it takes longer and uses more memory. For MPEG4, we need to
1984 decompress for Quicktime. */
1985 if (!has_codec_parameters(st->codec) /*&&
1986 (st->codec->codec_id == CODEC_ID_FLV1 ||
1987 st->codec->codec_id == CODEC_ID_H264 ||
1988 st->codec->codec_id == CODEC_ID_H263 ||
1989 st->codec->codec_id == CODEC_ID_H261 ||
1990 st->codec->codec_id == CODEC_ID_VORBIS ||
1991 st->codec->codec_id == CODEC_ID_MJPEG ||
1992 st->codec->codec_id == CODEC_ID_PNG ||
1993 st->codec->codec_id == CODEC_ID_PAM ||
1994 st->codec->codec_id == CODEC_ID_PGM ||
1995 st->codec->codec_id == CODEC_ID_PGMYUV ||
1996 st->codec->codec_id == CODEC_ID_PBM ||
1997 st->codec->codec_id == CODEC_ID_PPM ||
1998 st->codec->codec_id == CODEC_ID_SHORTEN ||
1999 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2000 try_decode_frame(st, pkt->data, pkt->size);
2002 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2008 // close codecs which where opened in try_decode_frame()
2009 for(i=0;i<ic->nb_streams;i++) {
2010 st = ic->streams[i];
2011 if(st->codec->codec)
2012 avcodec_close(st->codec);
2014 for(i=0;i<ic->nb_streams;i++) {
2015 st = ic->streams[i];
2016 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2017 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2018 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2020 if(duration_count[i] && st->codec->time_base.num*1000LL <= st->codec->time_base.den &&
2021 st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
2025 num= st->time_base.den*duration_count[i];
2026 den= st->time_base.num*duration_sum[i];
2028 av_reduce(&fps1.num, &fps1.den, num*1001, den*1000, FFMAX(st->time_base.den, st->time_base.num)/4);
2029 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, den, FFMAX(st->time_base.den, st->time_base.num)/4);
2030 if(fps1.num < st->r_frame_rate.num && fps1.den == 1 && (fps1.num==24 || fps1.num==30)){ //FIXME better decission
2031 st->r_frame_rate.num= fps1.num*1000;
2032 st->r_frame_rate.den= fps1.den*1001;
2036 /* set real frame rate info */
2037 /* compute the real frame rate for telecine */
2038 if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2039 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2040 st->codec->sub_id == 2) {
2041 if (st->codec_info_nb_frames >= 20) {
2042 float coded_frame_rate, est_frame_rate;
2043 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2044 (double)st->codec_info_duration ;
2045 coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2047 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2048 coded_frame_rate, est_frame_rate);
2050 /* if we detect that it could be a telecine, we
2051 signal it. It would be better to do it at a
2052 higher level as it can change in a film */
2053 if (coded_frame_rate >= 24.97 &&
2054 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2055 st->r_frame_rate = (AVRational){24000, 1001};
2059 /* if no real frame rate, use the codec one */
2060 if (!st->r_frame_rate.num){
2061 st->r_frame_rate.num = st->codec->time_base.den;
2062 st->r_frame_rate.den = st->codec->time_base.num;
2067 av_estimate_timings(ic);
2069 /* correct DTS for b frame streams with no timestamps */
2070 for(i=0;i<ic->nb_streams;i++) {
2071 st = ic->streams[i];
2072 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2074 ppktl = &ic->packet_buffer;
2076 if(ppkt1->stream_index != i)
2078 if(ppkt1->pkt->dts < 0)
2080 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2082 ppkt1->pkt->dts -= delta;
2087 st->cur_dts -= delta;
2095 /*******************************************************/
2098 * start playing a network based stream (e.g. RTSP stream) at the
2101 int av_read_play(AVFormatContext *s)
2103 if (!s->iformat->read_play)
2104 return AVERROR_NOTSUPP;
2105 return s->iformat->read_play(s);
2109 * Pause a network based stream (e.g. RTSP stream).
2111 * Use av_read_play() to resume it.
2113 int av_read_pause(AVFormatContext *s)
2115 if (!s->iformat->read_pause)
2116 return AVERROR_NOTSUPP;
2117 return s->iformat->read_pause(s);
2121 * Close a media file (but not its codecs).
2123 * @param s media file handle
2125 void av_close_input_file(AVFormatContext *s)
2127 int i, must_open_file;
2130 /* free previous packet */
2131 if (s->cur_st && s->cur_st->parser)
2132 av_free_packet(&s->cur_pkt);
2134 if (s->iformat->read_close)
2135 s->iformat->read_close(s);
2136 for(i=0;i<s->nb_streams;i++) {
2137 /* free all data in a stream component */
2140 av_parser_close(st->parser);
2142 av_free(st->index_entries);
2146 flush_packet_queue(s);
2148 if (s->iformat->flags & AVFMT_NOFILE) {
2151 if (must_open_file) {
2154 av_freep(&s->priv_data);
2159 * Add a new stream to a media file.
2161 * Can only be called in the read_header() function. If the flag
2162 * AVFMTCTX_NOHEADER is in the format context, then new streams
2163 * can be added in read_packet too.
2165 * @param s media file handle
2166 * @param id file format dependent stream id
2168 AVStream *av_new_stream(AVFormatContext *s, int id)
2172 if (s->nb_streams >= MAX_STREAMS)
2175 st = av_mallocz(sizeof(AVStream));
2179 st->codec= avcodec_alloc_context();
2181 /* no default bitrate if decoding */
2182 st->codec->bit_rate = 0;
2184 st->index = s->nb_streams;
2186 st->start_time = AV_NOPTS_VALUE;
2187 st->duration = AV_NOPTS_VALUE;
2188 st->cur_dts = AV_NOPTS_VALUE;
2190 /* default pts settings is MPEG like */
2191 av_set_pts_info(st, 33, 1, 90000);
2192 st->last_IP_pts = AV_NOPTS_VALUE;
2194 s->streams[s->nb_streams++] = st;
2198 /************************************************************/
2199 /* output media file */
2201 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2205 if (s->oformat->priv_data_size > 0) {
2206 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2208 return AVERROR_NOMEM;
2210 s->priv_data = NULL;
2212 if (s->oformat->set_parameters) {
2213 ret = s->oformat->set_parameters(s, ap);
2221 * allocate the stream private data and write the stream header to an
2224 * @param s media file handle
2225 * @return 0 if OK. AVERROR_xxx if error.
2227 int av_write_header(AVFormatContext *s)
2232 // some sanity checks
2233 for(i=0;i<s->nb_streams;i++) {
2236 switch (st->codec->codec_type) {
2237 case CODEC_TYPE_AUDIO:
2238 if(st->codec->sample_rate<=0){
2239 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2243 case CODEC_TYPE_VIDEO:
2244 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2245 av_log(s, AV_LOG_ERROR, "time base not set\n");
2248 if(st->codec->width<=0 || st->codec->height<=0){
2249 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2256 if(s->oformat->write_header){
2257 ret = s->oformat->write_header(s);
2262 /* init PTS generation */
2263 for(i=0;i<s->nb_streams;i++) {
2264 int64_t den = AV_NOPTS_VALUE;
2267 switch (st->codec->codec_type) {
2268 case CODEC_TYPE_AUDIO:
2269 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2271 case CODEC_TYPE_VIDEO:
2272 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2277 if (den != AV_NOPTS_VALUE) {
2279 return AVERROR_INVALIDDATA;
2280 av_frac_init(&st->pts, 0, 0, den);
2286 //FIXME merge with compute_pkt_fields
2287 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2288 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2289 int num, den, frame_size;
2291 // 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);
2293 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2296 /* duration field */
2297 if (pkt->duration == 0) {
2298 compute_frame_duration(&num, &den, st, NULL, pkt);
2300 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2304 //XXX/FIXME this is a temporary hack until all encoders output pts
2305 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2307 // pkt->pts= st->cur_dts;
2308 pkt->pts= st->pts.val;
2311 //calculate dts from pts
2312 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2314 if(st->last_IP_pts == AV_NOPTS_VALUE){
2315 st->last_IP_pts= -pkt->duration;
2317 if(st->last_IP_pts < pkt->pts){
2318 pkt->dts= st->last_IP_pts;
2319 st->last_IP_pts= pkt->pts;
2326 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2327 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2330 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2331 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2335 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2336 st->cur_dts= pkt->dts;
2337 st->pts.val= pkt->dts;
2340 switch (st->codec->codec_type) {
2341 case CODEC_TYPE_AUDIO:
2342 frame_size = get_audio_frame_size(st->codec, pkt->size);
2344 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2345 but it would be better if we had the real timestamps from the encoder */
2346 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2347 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2350 case CODEC_TYPE_VIDEO:
2351 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2359 static void truncate_ts(AVStream *st, AVPacket *pkt){
2360 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2363 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2365 pkt->pts &= pts_mask;
2366 pkt->dts &= pts_mask;
2370 * Write a packet to an output media file.
2372 * The packet shall contain one audio or video frame.
2374 * @param s media file handle
2375 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2376 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2378 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2382 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2386 truncate_ts(s->streams[pkt->stream_index], pkt);
2388 ret= s->oformat->write_packet(s, pkt);
2390 ret= url_ferror(&s->pb);
2395 * interleave_packet implementation which will interleave per DTS.
2396 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2397 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2399 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2400 AVPacketList *pktl, **next_point, *this_pktl;
2402 int streams[MAX_STREAMS];
2405 AVStream *st= s->streams[ pkt->stream_index];
2407 // assert(pkt->destruct != av_destruct_packet); //FIXME
2409 this_pktl = av_mallocz(sizeof(AVPacketList));
2410 this_pktl->pkt= *pkt;
2411 if(pkt->destruct == av_destruct_packet)
2412 pkt->destruct= NULL; // non shared -> must keep original from being freed
2414 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2416 next_point = &s->packet_buffer;
2418 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2419 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2420 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2421 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2423 next_point= &(*next_point)->next;
2425 this_pktl->next= *next_point;
2426 *next_point= this_pktl;
2429 memset(streams, 0, sizeof(streams));
2430 pktl= s->packet_buffer;
2432 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2433 if(streams[ pktl->pkt.stream_index ] == 0)
2435 streams[ pktl->pkt.stream_index ]++;
2439 if(s->nb_streams == stream_count || (flush && stream_count)){
2440 pktl= s->packet_buffer;
2443 s->packet_buffer= pktl->next;
2447 av_init_packet(out);
2453 * Interleaves a AVPacket correctly so it can be muxed.
2454 * @param out the interleaved packet will be output here
2455 * @param in the input packet
2456 * @param flush 1 if no further packets are available as input and all
2457 * remaining packets should be output
2458 * @return 1 if a packet was output, 0 if no packet could be output,
2459 * < 0 if an error occured
2461 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2462 if(s->oformat->interleave_packet)
2463 return s->oformat->interleave_packet(s, out, in, flush);
2465 return av_interleave_packet_per_dts(s, out, in, flush);
2469 * Writes a packet to an output media file ensuring correct interleaving.
2471 * The packet must contain one audio or video frame.
2472 * If the packets are already correctly interleaved the application should
2473 * call av_write_frame() instead as its slightly faster, its also important
2474 * to keep in mind that completly non interleaved input will need huge amounts
2475 * of memory to interleave with this, so its prefereable to interleave at the
2478 * @param s media file handle
2479 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2480 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2482 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2483 AVStream *st= s->streams[ pkt->stream_index];
2485 //FIXME/XXX/HACK drop zero sized packets
2486 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2489 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2490 if(compute_pkt_fields2(st, pkt) < 0)
2493 if(pkt->dts == AV_NOPTS_VALUE)
2498 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2499 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2502 truncate_ts(s->streams[opkt.stream_index], &opkt);
2503 ret= s->oformat->write_packet(s, &opkt);
2505 av_free_packet(&opkt);
2510 if(url_ferror(&s->pb))
2511 return url_ferror(&s->pb);
2516 * @brief Write the stream trailer to an output media file and
2517 * free the file private data.
2519 * @param s media file handle
2520 * @return 0 if OK. AVERROR_xxx if error.
2522 int av_write_trailer(AVFormatContext *s)
2528 ret= av_interleave_packet(s, &pkt, NULL, 1);
2529 if(ret<0) //FIXME cleanup needed for ret<0 ?
2534 truncate_ts(s->streams[pkt.stream_index], &pkt);
2535 ret= s->oformat->write_packet(s, &pkt);
2537 av_free_packet(&pkt);
2541 if(url_ferror(&s->pb))
2545 if(s->oformat->write_trailer)
2546 ret = s->oformat->write_trailer(s);
2549 ret=url_ferror(&s->pb);
2550 for(i=0;i<s->nb_streams;i++)
2551 av_freep(&s->streams[i]->priv_data);
2552 av_freep(&s->priv_data);
2556 /* "user interface" functions */
2558 void dump_format(AVFormatContext *ic,
2566 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2567 is_output ? "Output" : "Input",
2569 is_output ? ic->oformat->name : ic->iformat->name,
2570 is_output ? "to" : "from", url);
2572 av_log(NULL, AV_LOG_INFO, " Duration: ");
2573 if (ic->duration != AV_NOPTS_VALUE) {
2574 int hours, mins, secs, us;
2575 secs = ic->duration / AV_TIME_BASE;
2576 us = ic->duration % AV_TIME_BASE;
2581 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2582 (10 * us) / AV_TIME_BASE);
2584 av_log(NULL, AV_LOG_INFO, "N/A");
2586 if (ic->start_time != AV_NOPTS_VALUE) {
2588 av_log(NULL, AV_LOG_INFO, ", start: ");
2589 secs = ic->start_time / AV_TIME_BASE;
2590 us = ic->start_time % AV_TIME_BASE;
2591 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2592 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2594 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2596 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2598 av_log(NULL, AV_LOG_INFO, "N/A");
2600 av_log(NULL, AV_LOG_INFO, "\n");
2602 for(i=0;i<ic->nb_streams;i++) {
2603 AVStream *st = ic->streams[i];
2604 int g= ff_gcd(st->time_base.num, st->time_base.den);
2605 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2606 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2607 /* the pid is an important information, so we display it */
2608 /* XXX: add a generic system */
2610 flags = ic->oformat->flags;
2612 flags = ic->iformat->flags;
2613 if (flags & AVFMT_SHOW_IDS) {
2614 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2616 if (strlen(st->language) > 0) {
2617 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2619 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2620 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2621 if(st->r_frame_rate.den && st->r_frame_rate.num)
2622 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2623 /* else if(st->time_base.den && st->time_base.num)
2624 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2626 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2628 av_log(NULL, AV_LOG_INFO, ": %s\n", buf);
2635 int frame_rate, frame_rate_base;
2638 static AbvEntry frame_abvs[] = {
2639 { "ntsc", 720, 480, 30000, 1001 },
2640 { "pal", 720, 576, 25, 1 },
2641 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2642 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2643 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2644 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2645 { "film", 352, 240, 24, 1 },
2646 { "ntsc-film", 352, 240, 24000, 1001 },
2647 { "sqcif", 128, 96, 0, 0 },
2648 { "qcif", 176, 144, 0, 0 },
2649 { "cif", 352, 288, 0, 0 },
2650 { "4cif", 704, 576, 0, 0 },
2654 * parses width and height out of string str.
2656 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2659 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2661 int frame_width = 0, frame_height = 0;
2664 if (!strcmp(frame_abvs[i].abv, str)) {
2665 frame_width = frame_abvs[i].width;
2666 frame_height = frame_abvs[i].height;
2672 frame_width = strtol(p, (char **)&p, 10);
2675 frame_height = strtol(p, (char **)&p, 10);
2677 if (frame_width <= 0 || frame_height <= 0)
2679 *width_ptr = frame_width;
2680 *height_ptr = frame_height;
2685 * Converts frame rate from string to a fraction.
2687 * First we try to get an exact integer or fractional frame rate.
2688 * If this fails we convert the frame rate to a double and return
2689 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2691 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2696 /* First, we check our abbreviation table */
2697 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2698 if (!strcmp(frame_abvs[i].abv, arg)) {
2699 *frame_rate = frame_abvs[i].frame_rate;
2700 *frame_rate_base = frame_abvs[i].frame_rate_base;
2704 /* Then, we try to parse it as fraction */
2705 cp = strchr(arg, '/');
2707 cp = strchr(arg, ':');
2710 *frame_rate = strtol(arg, &cpp, 10);
2711 if (cpp != arg || cpp == cp)
2712 *frame_rate_base = strtol(cp+1, &cpp, 10);
2717 /* Finally we give up and parse it as double */
2718 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2719 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2721 if (!*frame_rate || !*frame_rate_base)
2728 * Converts date string to number of seconds since Jan 1st, 1970.
2732 * - If not a duration:
2733 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2734 * Time is localtime unless Z is suffixed to the end. In this case GMT
2735 * Return the date in micro seconds since 1970
2738 * HH[:MM[:SS[.m...]]]
2742 #ifndef CONFIG_WINCE
2743 int64_t parse_date(const char *datestr, int duration)
2749 static const char *date_fmt[] = {
2753 static const char *time_fmt[] = {
2763 time_t now = time(0);
2765 len = strlen(datestr);
2767 lastch = datestr[len - 1];
2770 is_utc = (lastch == 'z' || lastch == 'Z');
2772 memset(&dt, 0, sizeof(dt));
2777 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2778 q = small_strptime(p, date_fmt[i], &dt);
2788 dt = *localtime(&now);
2790 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2795 if (*p == 'T' || *p == 't' || *p == ' ')
2798 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2799 q = small_strptime(p, time_fmt[i], &dt);
2809 q = small_strptime(p, time_fmt[0], &dt);
2811 dt.tm_sec = strtol(p, (char **)&q, 10);
2817 /* Now we have all the fields that we can get */
2822 return now * int64_t_C(1000000);
2826 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2828 dt.tm_isdst = -1; /* unknown */
2841 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2844 val += n * (*q - '0');
2848 return negative ? -t : t;
2850 #endif /* CONFIG_WINCE */
2853 * Attempts to find a specific tag in a URL.
2855 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2856 * Return 1 if found.
2858 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2868 while (*p != '\0' && *p != '=' && *p != '&') {
2869 if ((q - tag) < sizeof(tag) - 1)
2877 while (*p != '&' && *p != '\0') {
2878 if ((q - arg) < arg_size - 1) {
2888 if (!strcmp(tag, tag1))
2898 * Returns in 'buf' the path with '%d' replaced by number.
2900 * Also handles the '%0nd' format where 'n' is the total number
2901 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2903 int get_frame_filename(char *buf, int buf_size,
2904 const char *path, int number)
2907 char *q, buf1[20], c;
2908 int nd, len, percentd_found;
2920 while (isdigit(*p)) {
2921 nd = nd * 10 + *p++ - '0';
2924 } while (isdigit(c));
2933 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2935 if ((q - buf + len) > buf_size - 1)
2937 memcpy(q, buf1, len);
2945 if ((q - buf) < buf_size - 1)
2949 if (!percentd_found)
2959 * Print nice hexa dump of a buffer
2960 * @param f stream for output
2962 * @param size buffer size
2964 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2968 for(i=0;i<size;i+=16) {
2972 fprintf(f, "%08x ", i);
2975 fprintf(f, " %02x", buf[i+j]);
2980 for(j=0;j<len;j++) {
2982 if (c < ' ' || c > '~')
2984 fprintf(f, "%c", c);
2991 * Print on 'f' a nice dump of a packet
2992 * @param f stream for output
2993 * @param pkt packet to dump
2994 * @param dump_payload true if the payload must be displayed too
2996 //FIXME needs to know the time_base
2997 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2999 fprintf(f, "stream #%d:\n", pkt->stream_index);
3000 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3001 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3002 /* DTS is _always_ valid after av_read_frame() */
3003 fprintf(f, " dts=");
3004 if (pkt->dts == AV_NOPTS_VALUE)
3007 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3008 /* PTS may be not known if B frames are present */
3009 fprintf(f, " pts=");
3010 if (pkt->pts == AV_NOPTS_VALUE)
3013 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3015 fprintf(f, " size=%d\n", pkt->size);
3017 av_hex_dump(f, pkt->data, pkt->size);
3020 void url_split(char *proto, int proto_size,
3021 char *authorization, int authorization_size,
3022 char *hostname, int hostname_size,
3024 char *path, int path_size,
3035 while (*p != ':' && *p != '\0') {
3036 if ((q - proto) < proto_size - 1)
3042 if (authorization_size > 0)
3043 authorization[0] = '\0';
3047 if (hostname_size > 0)
3051 char *at,*slash; // PETR: position of '@' character and '/' character
3058 at = strchr(p,'@'); // PETR: get the position of '@'
3059 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3060 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3062 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3064 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3065 if (*p == '@') { // PETR: passed '@'
3066 if (authorization_size > 0)
3070 } else if (!at) { // PETR: hostname
3071 if ((q - hostname) < hostname_size - 1)
3074 if ((q - authorization) < authorization_size - 1)
3079 if (hostname_size > 0)
3083 port = strtoul(p, (char **)&p, 10);
3088 pstrcpy(path, path_size, p);
3092 * Set the pts for a given stream.
3095 * @param pts_wrap_bits number of bits effectively used by the pts
3096 * (used for wrap control, 33 is the value for MPEG)
3097 * @param pts_num numerator to convert to seconds (MPEG: 1)
3098 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3100 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3101 int pts_num, int pts_den)
3103 s->pts_wrap_bits = pts_wrap_bits;
3104 s->time_base.num = pts_num;
3105 s->time_base.den = pts_den;
3108 /* fraction handling */
3111 * f = val + (num / den) + 0.5.
3113 * 'num' is normalized so that it is such as 0 <= num < den.
3115 * @param f fractional number
3116 * @param val integer value
3117 * @param num must be >= 0
3118 * @param den must be >= 1
3120 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3133 * Set f to (val + 0.5).
3135 void av_frac_set(AVFrac *f, int64_t val)
3138 f->num = f->den >> 1;
3142 * Fractionnal addition to f: f = f + (incr / f->den).
3144 * @param f fractional number
3145 * @param incr increment, can be positive or negative
3147 void av_frac_add(AVFrac *f, int64_t incr)
3151 num = f->num + incr;
3154 f->val += num / den;
3160 } else if (num >= den) {
3161 f->val += num / den;
3168 * register a new image format
3169 * @param img_fmt Image format descriptor
3171 void av_register_image_format(AVImageFormat *img_fmt)
3175 p = &first_image_format;
3176 while (*p != NULL) p = &(*p)->next;
3178 img_fmt->next = NULL;
3182 * Guesses image format based on data in the image.
3184 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3186 AVImageFormat *fmt1, *fmt;
3187 int score, score_max;
3191 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3192 if (fmt1->img_probe) {
3193 score = fmt1->img_probe(pd);
3194 if (score > score_max) {
3204 * Guesses image format based on file name extensions.
3206 AVImageFormat *guess_image_format(const char *filename)
3208 AVImageFormat *fmt1;
3210 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3211 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3218 * Read an image from a stream.
3219 * @param gb byte stream containing the image
3220 * @param fmt image format, NULL if probing is required
3222 int av_read_image(ByteIOContext *pb, const char *filename,
3224 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3226 uint8_t buf[PROBE_BUF_SIZE];
3227 AVProbeData probe_data, *pd = &probe_data;
3232 pd->filename = filename;
3234 pos = url_ftell(pb);
3235 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
3236 url_fseek(pb, pos, SEEK_SET);
3237 fmt = av_probe_image_format(pd);
3240 return AVERROR_NOFMT;
3241 ret = fmt->img_read(pb, alloc_cb, opaque);
3246 * Write an image to a stream.
3247 * @param pb byte stream for the image output
3248 * @param fmt image format
3249 * @param img image data and informations
3251 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3253 return fmt->img_write(pb, img);