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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #define strcasecmp _stricmp
27 #include <sys/types.h>
28 #include <sys/timeb.h>
36 AVInputFormat *first_iformat;
37 AVOutputFormat *first_oformat;
39 void av_register_input_format(AVInputFormat *format)
43 while (*p != NULL) p = &(*p)->next;
48 void av_register_output_format(AVOutputFormat *format)
52 while (*p != NULL) p = &(*p)->next;
57 int match_ext(const char *filename, const char *extensions)
62 ext = strrchr(filename, '.');
68 while (*p != '\0' && *p != ',')
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 /* find the proper file type */
93 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
95 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
97 if (filename && fmt->extensions &&
98 match_ext(filename, fmt->extensions)) {
101 if (score > score_max) {
110 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
111 const char *mime_type)
113 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
116 AVOutputFormat *stream_fmt;
117 char stream_format_name[64];
119 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
120 stream_fmt = guess_format(stream_format_name, NULL, NULL);
129 AVInputFormat *av_find_input_format(const char *short_name)
132 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
133 if (!strcmp(fmt->name, short_name))
139 /* memory handling */
142 * Allocate the payload of a packet and intialized its fields to default values.
145 * @param size wanted payload size
146 * @return 0 if OK. AVERROR_xxx otherwise.
148 int av_new_packet(AVPacket *pkt, int size)
151 pkt->data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
153 return AVERROR_NOMEM;
156 pkt->pts = AV_NOPTS_VALUE;
157 pkt->stream_index = 0;
160 for(i=0; i<FF_INPUT_BUFFER_PADDING_SIZE; i++)
161 pkt->data[size+i]= 0;
169 * @param pkt packet to free
171 void av_free_packet(AVPacket *pkt)
173 av_freep(&pkt->data);
180 int fifo_init(FifoBuffer *f, int size)
182 f->buffer = av_malloc(size);
185 f->end = f->buffer + size;
186 f->wptr = f->rptr = f->buffer;
190 void fifo_free(FifoBuffer *f)
195 int fifo_size(FifoBuffer *f, UINT8 *rptr)
199 if (f->wptr >= rptr) {
200 size = f->wptr - rptr;
202 size = (f->end - rptr) + (f->wptr - f->buffer);
207 /* get data from the fifo (return -1 if not enough data) */
208 int fifo_read(FifoBuffer *f, UINT8 *buf, int buf_size, UINT8 **rptr_ptr)
210 UINT8 *rptr = *rptr_ptr;
213 if (f->wptr >= rptr) {
214 size = f->wptr - rptr;
216 size = (f->end - rptr) + (f->wptr - f->buffer);
221 while (buf_size > 0) {
225 memcpy(buf, rptr, len);
236 void fifo_write(FifoBuffer *f, UINT8 *buf, int size, UINT8 **wptr_ptr)
245 memcpy(wptr, buf, len);
255 int filename_number_test(const char *filename)
258 return get_frame_filename(buf, sizeof(buf), filename, 1);
261 /* guess file format */
262 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
264 AVInputFormat *fmt1, *fmt;
265 int score, score_max;
269 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
270 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
273 if (fmt1->read_probe) {
274 score = fmt1->read_probe(pd);
275 } else if (fmt1->extensions) {
276 if (match_ext(pd->filename, fmt1->extensions)) {
280 if (score > score_max) {
288 /************************************************************/
289 /* input media file */
291 #define PROBE_BUF_SIZE 2048
294 * Open a media file as input. The codec are not opened. Only the file
295 * header (if present) is read.
297 * @param ic_ptr the opened media file handle is put here
298 * @param filename filename to open.
299 * @param fmt if non NULL, force the file format to use
300 * @param buf_size optional buffer size (zero if default is OK)
301 * @param ap additionnal parameters needed when opening the file (NULL if default)
302 * @return 0 if OK. AVERROR_xxx otherwise.
304 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
307 AVFormatParameters *ap)
309 AVFormatContext *ic = NULL;
311 char buf[PROBE_BUF_SIZE];
312 AVProbeData probe_data, *pd = &probe_data;
314 ic = av_mallocz(sizeof(AVFormatContext));
319 pstrcpy(ic->filename, sizeof(ic->filename), filename);
320 pd->filename = ic->filename;
325 /* guess format if no file can be opened */
326 fmt = av_probe_input_format(pd, 0);
329 /* if no file needed do not try to open one */
330 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
331 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
336 url_setbufsize(&ic->pb, buf_size);
339 /* read probe data */
340 pd->buf_size = get_buffer(&ic->pb, buf, PROBE_BUF_SIZE);
341 url_fseek(&ic->pb, 0, SEEK_SET);
345 /* guess file format */
347 fmt = av_probe_input_format(pd, 1);
350 /* if still no format found, error */
356 /* XXX: suppress this hack for redirectors */
357 if (fmt == &redir_demux) {
358 err = redir_open(ic_ptr, &ic->pb);
366 /* allocate private data */
367 ic->priv_data = av_mallocz(fmt->priv_data_size);
368 if (!ic->priv_data) {
373 /* default pts settings is MPEG like */
374 av_set_pts_info(ic, 33, 1, 90000);
376 /* check filename in case of an image number is expected */
377 if (ic->iformat->flags & AVFMT_NEEDNUMBER) {
378 if (filename_number_test(ic->filename) < 0) {
379 err = AVERROR_NUMEXPECTED;
384 err = ic->iformat->read_header(ic, ap);
390 if (!(fmt->flags & AVFMT_NOFILE)) {
395 av_freep(&ic->priv_data);
403 * Read a packet from a media file
404 * @param s media file handle
405 * @param pkt is filled
406 * @return 0 if OK. AVERROR_xxx if error.
408 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
412 pktl = s->packet_buffer;
414 /* read packet from packet buffer, if there is data */
416 s->packet_buffer = pktl->next;
420 return s->iformat->read_packet(s, pkt);
424 /* state for codec information */
425 #define CSTATE_NOTFOUND 0
426 #define CSTATE_DECODING 1
427 #define CSTATE_FOUND 2
429 static int has_codec_parameters(AVCodecContext *enc)
432 switch(enc->codec_type) {
433 case CODEC_TYPE_AUDIO:
434 val = enc->sample_rate;
436 case CODEC_TYPE_VIDEO:
447 * Read the beginning of a media file to get stream information. This
448 * is useful for file formats with no headers such as MPEG. This
449 * function also compute the real frame rate in case of mpeg2 repeat
452 * @param ic media file handle
453 * @return >=0 if OK. AVERROR_xxx if error.
455 int av_find_stream_info(AVFormatContext *ic)
457 int i, count, ret, got_picture, size, read_size;
462 AVPacketList *pktl=NULL, **ppktl;
463 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
465 int min_read_size, max_read_size;
467 /* typical mpeg ts rate is 40 Mbits. DVD rate is about 10
468 Mbits. We read at most 0.1 second of file to find all streams */
470 /* XXX: base it on stream bitrate when possible */
471 if (ic->iformat == &mpegts_demux) {
472 /* maximum number of bytes we accept to read to find all the streams
474 min_read_size = 3000000;
476 min_read_size = 125000;
478 /* max read size is 2 seconds of video max */
479 max_read_size = min_read_size * 20;
481 /* set initial codec state */
482 for(i=0;i<ic->nb_streams;i++) {
484 if (has_codec_parameters(&st->codec))
485 st->codec_info_state = CSTATE_FOUND;
487 st->codec_info_state = CSTATE_NOTFOUND;
488 st->codec_info_nb_repeat_frames = 0;
489 st->codec_info_nb_real_frames = 0;
494 ppktl = &ic->packet_buffer;
496 /* check if one codec still needs to be handled */
497 for(i=0;i<ic->nb_streams;i++) {
499 if (st->codec_info_state != CSTATE_FOUND)
502 if (i == ic->nb_streams) {
503 /* NOTE: if the format has no header, then we need to read
504 some packets to get most of the streams, so we cannot
506 if (!(ic->iformat->flags & AVFMT_NOHEADER) ||
507 read_size >= min_read_size) {
508 /* if we found the info for all the codecs, we can stop */
513 /* we did not get all the codec info, but we read too much data */
514 if (read_size >= max_read_size) {
520 pktl = av_mallocz(sizeof(AVPacketList));
526 /* add the packet in the buffered packet list */
530 /* NOTE: a new stream can be added there if no header in file
533 if (ic->iformat->read_packet(ic, pkt) < 0) {
535 ret = -1; /* we could not have all the codec parameters before EOF */
536 if ((ic->iformat->flags & AVFMT_NOHEADER) &&
541 read_size += pkt->size;
543 /* open new codecs */
544 for(i=0;i<ic->nb_streams;i++) {
546 if (st->codec_info_state == CSTATE_NOTFOUND) {
547 /* set to found in case of error */
548 st->codec_info_state = CSTATE_FOUND;
549 codec = avcodec_find_decoder(st->codec.codec_id);
551 if(codec->capabilities & CODEC_CAP_TRUNCATED)
552 st->codec.flags |= CODEC_FLAG_TRUNCATED;
554 ret = avcodec_open(&st->codec, codec);
556 st->codec_info_state = CSTATE_DECODING;
561 st = ic->streams[pkt->stream_index];
562 if (st->codec_info_state == CSTATE_DECODING) {
563 /* decode the data and update codec parameters */
567 switch(st->codec.codec_type) {
568 case CODEC_TYPE_VIDEO:
569 ret = avcodec_decode_video(&st->codec, &picture,
570 &got_picture, ptr, size);
572 case CODEC_TYPE_AUDIO:
573 ret = avcodec_decode_audio(&st->codec, samples,
574 &got_picture, ptr, size);
581 /* if error, simply ignore because another packet
586 /* we got the parameters - now we can stop
587 examining this stream */
588 /* XXX: add a codec info so that we can decide if
589 the codec can repeat frames */
590 if (st->codec.codec_id == CODEC_ID_MPEG1VIDEO &&
591 ic->iformat != &mpegts_demux &&
592 st->codec.sub_id == 2) {
593 /* for mpeg2 video, we want to know the real
594 frame rate, so we decode 40 frames. In mpeg
595 TS case we do not do it because it would be
597 st->codec_info_nb_real_frames++;
598 st->codec_info_nb_repeat_frames += st->codec.repeat_pict;
601 if ((st->codec_info_nb_real_frames % 24) == 23) {
602 st->codec_info_nb_repeat_frames += 2;
605 /* stop after 40 frames */
606 if (st->codec_info_nb_real_frames >= 40) {
607 st->r_frame_rate = (st->codec.frame_rate *
608 st->codec_info_nb_real_frames) /
609 (st->codec_info_nb_real_frames +
610 (st->codec_info_nb_repeat_frames >> 1));
615 st->codec_info_state = CSTATE_FOUND;
616 avcodec_close(&st->codec);
627 /* close each codec if there are opened */
628 for(i=0;i<ic->nb_streams;i++) {
630 if (st->codec_info_state == CSTATE_DECODING)
631 avcodec_close(&st->codec);
634 /* set real frame rate info */
635 for(i=0;i<ic->nb_streams;i++) {
637 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
638 if (!st->r_frame_rate)
639 st->r_frame_rate = st->codec.frame_rate;
647 * Close a media file (but not its codecs)
649 * @param s media file handle
651 void av_close_input_file(AVFormatContext *s)
655 if (s->iformat->read_close)
656 s->iformat->read_close(s);
657 for(i=0;i<s->nb_streams;i++) {
658 av_free(s->streams[i]);
660 if (s->packet_buffer) {
661 AVPacketList *p, *p1;
662 p = s->packet_buffer;
665 av_free_packet(&p->pkt);
669 s->packet_buffer = NULL;
671 if (!(s->iformat->flags & AVFMT_NOFILE)) {
674 av_freep(&s->priv_data);
679 * Add a new stream to a media file. Can only be called in the
680 * read_header function. If the flag AVFMT_NOHEADER is in the format
681 * description, then new streams can be added in read_packet too.
684 * @param s media file handle
685 * @param id file format dependent stream id
687 AVStream *av_new_stream(AVFormatContext *s, int id)
691 if (s->nb_streams >= MAX_STREAMS)
694 st = av_mallocz(sizeof(AVStream));
697 st->index = s->nb_streams;
699 s->streams[s->nb_streams++] = st;
703 /************************************************************/
704 /* output media file */
707 * allocate the stream private data and write the stream header to an
710 * @param s media file handle
711 * @return 0 if OK. AVERROR_xxx if error.
713 int av_write_header(AVFormatContext *s)
718 s->priv_data = av_mallocz(s->oformat->priv_data_size);
720 return AVERROR_NOMEM;
721 /* default pts settings is MPEG like */
722 av_set_pts_info(s, 33, 1, 90000);
723 ret = s->oformat->write_header(s);
727 /* init PTS generation */
728 for(i=0;i<s->nb_streams;i++) {
731 switch (st->codec.codec_type) {
732 case CODEC_TYPE_AUDIO:
733 av_frac_init(&st->pts, 0, 0,
734 (INT64)s->pts_num * st->codec.sample_rate);
736 case CODEC_TYPE_VIDEO:
737 av_frac_init(&st->pts, 0, 0,
738 (INT64)s->pts_num * st->codec.frame_rate);
748 * Write a packet to an output media file. The packet shall contain
749 * one audio or video frame.
751 * @param s media file handle
752 * @param stream_index stream index
753 * @param buf buffer containing the frame data
754 * @param size size of buffer
755 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
757 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
764 st = s->streams[stream_index];
765 pts_mask = (1LL << s->pts_wrap_bits) - 1;
766 ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
767 st->pts.val & pts_mask);
772 switch (st->codec.codec_type) {
773 case CODEC_TYPE_AUDIO:
774 if (st->codec.frame_size <= 1) {
775 frame_size = size / st->codec.channels;
776 /* specific hack for pcm codecs because no frame size is provided */
777 switch(st->codec.codec_id) {
778 case CODEC_ID_PCM_S16LE:
779 case CODEC_ID_PCM_S16BE:
780 case CODEC_ID_PCM_U16LE:
781 case CODEC_ID_PCM_U16BE:
788 frame_size = st->codec.frame_size;
790 av_frac_add(&st->pts,
791 (INT64)s->pts_den * frame_size);
793 case CODEC_TYPE_VIDEO:
794 av_frac_add(&st->pts,
795 (INT64)s->pts_den * FRAME_RATE_BASE);
804 * write the stream trailer to an output media file and and free the
807 * @param s media file handle
808 * @return 0 if OK. AVERROR_xxx if error. */
809 int av_write_trailer(AVFormatContext *s)
812 ret = s->oformat->write_trailer(s);
813 av_freep(&s->priv_data);
817 /* "user interface" functions */
819 void dump_format(AVFormatContext *ic,
827 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
828 is_output ? "Output" : "Input",
830 is_output ? ic->oformat->name : ic->iformat->name,
831 is_output ? "to" : "from", url);
832 for(i=0;i<ic->nb_streams;i++) {
833 AVStream *st = ic->streams[i];
834 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
835 fprintf(stderr, " Stream #%d.%d", index, i);
836 /* the pid is an important information, so we display it */
837 /* XXX: add a generic system */
839 flags = ic->oformat->flags;
841 flags = ic->iformat->flags;
842 if (flags & AVFMT_SHOW_IDS) {
843 fprintf(stderr, "[0x%x]", st->id);
845 fprintf(stderr, ": %s\n", buf);
854 static SizeEntry sizes[] = {
855 { "sqcif", 128, 96 },
856 { "qcif", 176, 144 },
858 { "4cif", 704, 576 },
861 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
864 int n = sizeof(sizes) / sizeof(SizeEntry);
866 int frame_width = 0, frame_height = 0;
869 if (!strcmp(sizes[i].str, str)) {
870 frame_width = sizes[i].width;
871 frame_height = sizes[i].height;
877 frame_width = strtol(p, (char **)&p, 10);
880 frame_height = strtol(p, (char **)&p, 10);
882 if (frame_width <= 0 || frame_height <= 0)
884 *width_ptr = frame_width;
885 *height_ptr = frame_height;
889 INT64 av_gettime(void)
894 return ((INT64)tb.time * INT64_C(1000) + (INT64)tb.millitm) * INT64_C(1000);
897 gettimeofday(&tv,NULL);
898 return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
902 static time_t mktimegm(struct tm *tm)
906 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
914 (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
916 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
922 * - If not a duration:
923 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
924 * Time is localtime unless Z is suffixed to the end. In this case GMT
925 * Return the date in micro seconds since 1970
927 * HH[:MM[:SS[.m...]]]
930 INT64 parse_date(const char *datestr, int duration)
936 static const char *date_fmt[] = {
940 static const char *time_fmt[] = {
947 time_t now = time(0);
949 len = strlen(datestr);
951 lastch = datestr[len - 1];
954 is_utc = (lastch == 'z' || lastch == 'Z');
956 memset(&dt, 0, sizeof(dt));
961 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
962 q = strptime(p, date_fmt[i], &dt);
972 dt = *localtime(&now);
974 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
979 if (*p == 'T' || *p == 't' || *p == ' ')
982 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
983 q = strptime(p, time_fmt[i], &dt);
989 q = strptime(p, time_fmt[0], &dt);
991 dt.tm_sec = strtol(p, (char **)&q, 10);
997 /* Now we have all the fields that we can get */
1002 return now * INT64_C(1000000);
1006 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1008 dt.tm_isdst = -1; /* unknown */
1021 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1024 val += n * (*q - '0');
1031 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1033 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1043 while (*p != '\0' && *p != '=' && *p != '&') {
1044 if ((q - tag) < sizeof(tag) - 1)
1052 while (*p != '&' && *p != '\0') {
1053 if ((q - arg) < arg_size - 1) {
1063 if (!strcmp(tag, tag1))
1072 /* Return in 'buf' the path with '%d' replaced by number. Also handles
1073 the '%0nd' format where 'n' is the total number of digits and
1074 '%%'. Return 0 if OK, and -1 if format error */
1075 int get_frame_filename(char *buf, int buf_size,
1076 const char *path, int number)
1080 int nd, len, c, percentd_found;
1091 while (*p >= '0' && *p <= '9') {
1092 nd = nd * 10 + *p++ - '0';
1102 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1104 if ((q - buf + len) > buf_size - 1)
1106 memcpy(q, buf1, len);
1114 if ((q - buf) < buf_size - 1)
1118 if (!percentd_found)
1129 * Print on stdout a nice hexa dump of a buffer
1131 * @param size buffer size
1133 void av_hex_dump(UINT8 *buf, int size)
1137 for(i=0;i<size;i+=16) {
1144 printf(" %02x", buf[i+j]);
1149 for(j=0;j<len;j++) {
1151 if (c < ' ' || c > '~')
1159 void url_split(char *proto, int proto_size,
1160 char *hostname, int hostname_size,
1162 char *path, int path_size,
1173 while (*p != ':' && *p != '\0') {
1174 if ((q - proto) < proto_size - 1)
1183 if (hostname_size > 0)
1193 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1194 if ((q - hostname) < hostname_size - 1)
1198 if (hostname_size > 0)
1202 port = strtoul(p, (char **)&p, 10);
1207 pstrcpy(path, path_size, p);
1211 * Set the pts for a given stream
1213 * @param pts_wrap_bits number of bits effectively used by the pts
1214 * (used for wrap control, 33 is the value for MPEG)
1215 * @param pts_num numerator to convert to seconds (MPEG: 1)
1216 * @param pts_den denominator to convert to seconds (MPEG: 90000)
1218 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1219 int pts_num, int pts_den)
1221 s->pts_wrap_bits = pts_wrap_bits;
1222 s->pts_num = pts_num;
1223 s->pts_den = pts_den;
1226 /* fraction handling */
1229 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1230 * as 0 <= num < den.
1232 * @param f fractional number
1233 * @param val integer value
1234 * @param num must be >= 0
1235 * @param den must be >= 1
1237 void av_frac_init(AVFrac *f, INT64 val, INT64 num, INT64 den)
1249 /* set f to (val + 0.5) */
1250 void av_frac_set(AVFrac *f, INT64 val)
1253 f->num = f->den >> 1;
1257 * Fractionnal addition to f: f = f + (incr / f->den)
1259 * @param f fractional number
1260 * @param incr increment, can be positive or negative
1262 void av_frac_add(AVFrac *f, INT64 incr)
1266 num = f->num + incr;
1269 f->val += num / den;
1275 } else if (num >= den) {
1276 f->val += num / den;