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
22 #define strcasecmp _stricmp
23 #include <sys/types.h>
24 #include <sys/timeb.h>
25 #elif defined(CONFIG_OS2)
27 #define strcasecmp stricmp
40 AVInputFormat *first_iformat;
41 AVOutputFormat *first_oformat;
42 AVImageFormat *first_image_format;
44 void av_register_input_format(AVInputFormat *format)
48 while (*p != NULL) p = &(*p)->next;
53 void av_register_output_format(AVOutputFormat *format)
57 while (*p != NULL) p = &(*p)->next;
62 int match_ext(const char *filename, const char *extensions)
67 ext = strrchr(filename, '.');
73 while (*p != '\0' && *p != ',')
76 if (!strcasecmp(ext1, ext))
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
89 AVOutputFormat *fmt, *fmt_found;
92 /* specific test for image sequences */
93 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);
141 AVInputFormat *av_find_input_format(const char *short_name)
144 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
145 if (!strcmp(fmt->name, short_name))
151 /* memory handling */
154 * Allocate the payload of a packet and intialized its fields to default values.
157 * @param size wanted payload size
158 * @return 0 if OK. AVERROR_xxx otherwise.
160 int av_new_packet(AVPacket *pkt, int size)
163 pkt->data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
165 return AVERROR_NOMEM;
168 pkt->pts = AV_NOPTS_VALUE;
169 pkt->stream_index = 0;
172 for(i=0; i<FF_INPUT_BUFFER_PADDING_SIZE; i++)
173 pkt->data[size+i]= 0;
181 * @param pkt packet to free
183 void av_free_packet(AVPacket *pkt)
185 av_freep(&pkt->data);
192 int fifo_init(FifoBuffer *f, int size)
194 f->buffer = av_malloc(size);
197 f->end = f->buffer + size;
198 f->wptr = f->rptr = f->buffer;
202 void fifo_free(FifoBuffer *f)
207 int fifo_size(FifoBuffer *f, UINT8 *rptr)
211 if (f->wptr >= rptr) {
212 size = f->wptr - rptr;
214 size = (f->end - rptr) + (f->wptr - f->buffer);
219 /* get data from the fifo (return -1 if not enough data) */
220 int fifo_read(FifoBuffer *f, UINT8 *buf, int buf_size, UINT8 **rptr_ptr)
222 UINT8 *rptr = *rptr_ptr;
225 if (f->wptr >= rptr) {
226 size = f->wptr - rptr;
228 size = (f->end - rptr) + (f->wptr - f->buffer);
233 while (buf_size > 0) {
237 memcpy(buf, rptr, len);
248 void fifo_write(FifoBuffer *f, UINT8 *buf, int size, UINT8 **wptr_ptr)
257 memcpy(wptr, buf, len);
267 int filename_number_test(const char *filename)
270 return get_frame_filename(buf, sizeof(buf), filename, 1);
273 /* guess file format */
274 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
276 AVInputFormat *fmt1, *fmt;
277 int score, score_max;
281 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
282 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
285 if (fmt1->read_probe) {
286 score = fmt1->read_probe(pd);
287 } else if (fmt1->extensions) {
288 if (match_ext(pd->filename, fmt1->extensions)) {
292 if (score > score_max) {
300 /************************************************************/
301 /* input media file */
303 #define PROBE_BUF_SIZE 2048
306 * Open a media file as input. The codec are not opened. Only the file
307 * header (if present) is read.
309 * @param ic_ptr the opened media file handle is put here
310 * @param filename filename to open.
311 * @param fmt if non NULL, force the file format to use
312 * @param buf_size optional buffer size (zero if default is OK)
313 * @param ap additionnal parameters needed when opening the file (NULL if default)
314 * @return 0 if OK. AVERROR_xxx otherwise.
316 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
319 AVFormatParameters *ap)
321 AVFormatContext *ic = NULL;
323 char buf[PROBE_BUF_SIZE];
324 AVProbeData probe_data, *pd = &probe_data;
326 ic = av_mallocz(sizeof(AVFormatContext));
331 pstrcpy(ic->filename, sizeof(ic->filename), filename);
332 pd->filename = ic->filename;
337 /* guess format if no file can be opened */
338 fmt = av_probe_input_format(pd, 0);
341 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
342 /* if no file needed do not try to open one */
343 if (url_fopen(&ic->pb, filename, URL_RDONLY) < 0) {
348 url_setbufsize(&ic->pb, buf_size);
351 /* read probe data */
352 pd->buf_size = get_buffer(&ic->pb, buf, PROBE_BUF_SIZE);
353 url_fseek(&ic->pb, 0, SEEK_SET);
357 /* guess file format */
359 fmt = av_probe_input_format(pd, 1);
362 /* if still no format found, error */
368 /* XXX: suppress this hack for redirectors */
369 #ifdef CONFIG_NETWORK
370 if (fmt == &redir_demux) {
371 err = redir_open(ic_ptr, &ic->pb);
380 /* check filename in case of an image number is expected */
381 if (ic->iformat->flags & AVFMT_NEEDNUMBER) {
382 if (filename_number_test(ic->filename) < 0) {
383 err = AVERROR_NUMEXPECTED;
388 /* allocate private data */
389 ic->priv_data = av_mallocz(fmt->priv_data_size);
390 if (!ic->priv_data) {
395 /* default pts settings is MPEG like */
396 av_set_pts_info(ic, 33, 1, 90000);
398 err = ic->iformat->read_header(ic, ap);
404 if (!(fmt->flags & AVFMT_NOFILE)) {
409 av_freep(&ic->priv_data);
417 * Read a packet from a media file
418 * @param s media file handle
419 * @param pkt is filled
420 * @return 0 if OK. AVERROR_xxx if error.
422 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
426 pktl = s->packet_buffer;
428 /* read packet from packet buffer, if there is data */
430 s->packet_buffer = pktl->next;
434 return s->iformat->read_packet(s, pkt);
438 /* state for codec information */
439 #define CSTATE_NOTFOUND 0
440 #define CSTATE_DECODING 1
441 #define CSTATE_FOUND 2
443 static int has_codec_parameters(AVCodecContext *enc)
446 switch(enc->codec_type) {
447 case CODEC_TYPE_AUDIO:
448 val = enc->sample_rate;
450 case CODEC_TYPE_VIDEO:
461 * Read the beginning of a media file to get stream information. This
462 * is useful for file formats with no headers such as MPEG. This
463 * function also compute the real frame rate in case of mpeg2 repeat
466 * @param ic media file handle
467 * @return >=0 if OK. AVERROR_xxx if error.
469 int av_find_stream_info(AVFormatContext *ic)
471 int i, count, ret, got_picture, size, read_size;
476 AVPacketList *pktl=NULL, **ppktl;
477 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
479 int min_read_size, max_read_size;
481 /* typical mpeg ts rate is 40 Mbits. DVD rate is about 10
482 Mbits. We read at most 0.1 second of file to find all streams */
484 /* XXX: base it on stream bitrate when possible */
485 if (ic->iformat == &mpegts_demux) {
486 /* maximum number of bytes we accept to read to find all the streams
488 min_read_size = 3000000;
490 min_read_size = 125000;
492 /* max read size is 2 seconds of video max */
493 max_read_size = min_read_size * 20;
495 /* set initial codec state */
496 for(i=0;i<ic->nb_streams;i++) {
498 if (has_codec_parameters(&st->codec))
499 st->codec_info_state = CSTATE_FOUND;
501 st->codec_info_state = CSTATE_NOTFOUND;
502 st->codec_info_nb_repeat_frames = 0;
503 st->codec_info_nb_real_frames = 0;
508 ppktl = &ic->packet_buffer;
510 /* check if one codec still needs to be handled */
511 for(i=0;i<ic->nb_streams;i++) {
513 if (st->codec_info_state != CSTATE_FOUND)
516 if (i == ic->nb_streams) {
517 /* NOTE: if the format has no header, then we need to read
518 some packets to get most of the streams, so we cannot
520 if (!(ic->iformat->flags & AVFMT_NOHEADER) ||
521 read_size >= min_read_size) {
522 /* if we found the info for all the codecs, we can stop */
527 /* we did not get all the codec info, but we read too much data */
528 if (read_size >= max_read_size) {
534 pktl = av_mallocz(sizeof(AVPacketList));
540 /* add the packet in the buffered packet list */
544 /* NOTE: a new stream can be added there if no header in file
547 if (ic->iformat->read_packet(ic, pkt) < 0) {
549 ret = -1; /* we could not have all the codec parameters before EOF */
550 if ((ic->iformat->flags & AVFMT_NOHEADER) &&
555 read_size += pkt->size;
557 /* open new codecs */
558 for(i=0;i<ic->nb_streams;i++) {
560 if (st->codec_info_state == CSTATE_NOTFOUND) {
561 /* set to found in case of error */
562 st->codec_info_state = CSTATE_FOUND;
563 codec = avcodec_find_decoder(st->codec.codec_id);
565 if(codec->capabilities & CODEC_CAP_TRUNCATED)
566 st->codec.flags |= CODEC_FLAG_TRUNCATED;
568 ret = avcodec_open(&st->codec, codec);
570 st->codec_info_state = CSTATE_DECODING;
575 st = ic->streams[pkt->stream_index];
576 if (st->codec_info_state == CSTATE_DECODING) {
577 /* decode the data and update codec parameters */
581 switch(st->codec.codec_type) {
582 case CODEC_TYPE_VIDEO:
583 ret = avcodec_decode_video(&st->codec, &picture,
584 &got_picture, ptr, size);
586 case CODEC_TYPE_AUDIO:
587 ret = avcodec_decode_audio(&st->codec, samples,
588 &got_picture, ptr, size);
595 /* if error, simply ignore because another packet
600 /* we got the parameters - now we can stop
601 examining this stream */
602 /* XXX: add a codec info so that we can decide if
603 the codec can repeat frames */
604 if (st->codec.codec_id == CODEC_ID_MPEG1VIDEO &&
605 ic->iformat != &mpegts_demux &&
606 st->codec.sub_id == 2) {
607 /* for mpeg2 video, we want to know the real
608 frame rate, so we decode 40 frames. In mpeg
609 TS case we do not do it because it would be
611 st->codec_info_nb_real_frames++;
612 st->codec_info_nb_repeat_frames += st->codec.repeat_pict;
615 if ((st->codec_info_nb_real_frames % 24) == 23) {
616 st->codec_info_nb_repeat_frames += 2;
619 /* stop after 40 frames */
620 if (st->codec_info_nb_real_frames >= 40) {
621 st->r_frame_rate = (st->codec.frame_rate *
622 st->codec_info_nb_real_frames) /
623 (st->codec_info_nb_real_frames +
624 (st->codec_info_nb_repeat_frames >> 1));
629 st->codec_info_state = CSTATE_FOUND;
630 avcodec_close(&st->codec);
641 /* close each codec if there are opened */
642 for(i=0;i<ic->nb_streams;i++) {
644 if (st->codec_info_state == CSTATE_DECODING)
645 avcodec_close(&st->codec);
648 /* set real frame rate info */
649 for(i=0;i<ic->nb_streams;i++) {
651 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
652 if (!st->r_frame_rate)
653 st->r_frame_rate = st->codec.frame_rate;
661 * Close a media file (but not its codecs)
663 * @param s media file handle
665 void av_close_input_file(AVFormatContext *s)
669 if (s->iformat->read_close)
670 s->iformat->read_close(s);
671 for(i=0;i<s->nb_streams;i++) {
672 av_free(s->streams[i]);
674 if (s->packet_buffer) {
675 AVPacketList *p, *p1;
676 p = s->packet_buffer;
679 av_free_packet(&p->pkt);
683 s->packet_buffer = NULL;
685 if (!(s->iformat->flags & AVFMT_NOFILE)) {
688 av_freep(&s->priv_data);
693 * Add a new stream to a media file. Can only be called in the
694 * read_header function. If the flag AVFMT_NOHEADER is in the format
695 * description, then new streams can be added in read_packet too.
698 * @param s media file handle
699 * @param id file format dependent stream id
701 AVStream *av_new_stream(AVFormatContext *s, int id)
705 if (s->nb_streams >= MAX_STREAMS)
708 st = av_mallocz(sizeof(AVStream));
711 avcodec_get_context_defaults(&st->codec);
713 st->index = s->nb_streams;
715 s->streams[s->nb_streams++] = st;
719 /************************************************************/
720 /* output media file */
722 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
726 s->priv_data = av_mallocz(s->oformat->priv_data_size);
728 return AVERROR_NOMEM;
729 if (s->oformat->set_parameters) {
730 ret = s->oformat->set_parameters(s, ap);
738 * allocate the stream private data and write the stream header to an
741 * @param s media file handle
742 * @return 0 if OK. AVERROR_xxx if error.
744 int av_write_header(AVFormatContext *s)
749 /* default pts settings is MPEG like */
750 av_set_pts_info(s, 33, 1, 90000);
751 ret = s->oformat->write_header(s);
755 /* init PTS generation */
756 for(i=0;i<s->nb_streams;i++) {
759 switch (st->codec.codec_type) {
760 case CODEC_TYPE_AUDIO:
761 av_frac_init(&st->pts, 0, 0,
762 (INT64)s->pts_num * st->codec.sample_rate);
764 case CODEC_TYPE_VIDEO:
765 av_frac_init(&st->pts, 0, 0,
766 (INT64)s->pts_num * st->codec.frame_rate);
776 * Write a packet to an output media file. The packet shall contain
777 * one audio or video frame.
779 * @param s media file handle
780 * @param stream_index stream index
781 * @param buf buffer containing the frame data
782 * @param size size of buffer
783 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
785 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
792 st = s->streams[stream_index];
793 pts_mask = (1LL << s->pts_wrap_bits) - 1;
794 ret = s->oformat->write_packet(s, stream_index, (uint8_t *)buf, size,
795 st->pts.val & pts_mask);
800 switch (st->codec.codec_type) {
801 case CODEC_TYPE_AUDIO:
802 if (st->codec.frame_size <= 1) {
803 frame_size = size / st->codec.channels;
804 /* specific hack for pcm codecs because no frame size is provided */
805 switch(st->codec.codec_id) {
806 case CODEC_ID_PCM_S16LE:
807 case CODEC_ID_PCM_S16BE:
808 case CODEC_ID_PCM_U16LE:
809 case CODEC_ID_PCM_U16BE:
816 frame_size = st->codec.frame_size;
818 av_frac_add(&st->pts,
819 (INT64)s->pts_den * frame_size);
821 case CODEC_TYPE_VIDEO:
822 av_frac_add(&st->pts,
823 (INT64)s->pts_den * FRAME_RATE_BASE);
832 * write the stream trailer to an output media file and and free the
835 * @param s media file handle
836 * @return 0 if OK. AVERROR_xxx if error. */
837 int av_write_trailer(AVFormatContext *s)
840 ret = s->oformat->write_trailer(s);
841 av_freep(&s->priv_data);
845 /* "user interface" functions */
847 void dump_format(AVFormatContext *ic,
855 fprintf(stderr, "%s #%d, %s, %s '%s':\n",
856 is_output ? "Output" : "Input",
858 is_output ? ic->oformat->name : ic->iformat->name,
859 is_output ? "to" : "from", url);
860 for(i=0;i<ic->nb_streams;i++) {
861 AVStream *st = ic->streams[i];
862 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
863 fprintf(stderr, " Stream #%d.%d", index, i);
864 /* the pid is an important information, so we display it */
865 /* XXX: add a generic system */
867 flags = ic->oformat->flags;
869 flags = ic->iformat->flags;
870 if (flags & AVFMT_SHOW_IDS) {
871 fprintf(stderr, "[0x%x]", st->id);
873 fprintf(stderr, ": %s\n", buf);
882 static SizeEntry sizes[] = {
883 { "sqcif", 128, 96 },
884 { "qcif", 176, 144 },
886 { "4cif", 704, 576 },
889 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
892 int n = sizeof(sizes) / sizeof(SizeEntry);
894 int frame_width = 0, frame_height = 0;
897 if (!strcmp(sizes[i].str, str)) {
898 frame_width = sizes[i].width;
899 frame_height = sizes[i].height;
905 frame_width = strtol(p, (char **)&p, 10);
908 frame_height = strtol(p, (char **)&p, 10);
910 if (frame_width <= 0 || frame_height <= 0)
912 *width_ptr = frame_width;
913 *height_ptr = frame_height;
917 INT64 av_gettime(void)
922 return ((INT64)tb.time * INT64_C(1000) + (INT64)tb.millitm) * INT64_C(1000);
925 gettimeofday(&tv,NULL);
926 return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
930 static time_t mktimegm(struct tm *tm)
934 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
942 (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
944 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
950 * - If not a duration:
951 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
952 * Time is localtime unless Z is suffixed to the end. In this case GMT
953 * Return the date in micro seconds since 1970
955 * HH[:MM[:SS[.m...]]]
958 INT64 parse_date(const char *datestr, int duration)
964 static const char *date_fmt[] = {
968 static const char *time_fmt[] = {
975 time_t now = time(0);
977 len = strlen(datestr);
979 lastch = datestr[len - 1];
982 is_utc = (lastch == 'z' || lastch == 'Z');
984 memset(&dt, 0, sizeof(dt));
989 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
990 q = strptime(p, date_fmt[i], &dt);
1000 dt = *localtime(&now);
1002 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1007 if (*p == 'T' || *p == 't' || *p == ' ')
1010 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1011 q = strptime(p, time_fmt[i], &dt);
1017 q = strptime(p, time_fmt[0], &dt);
1019 dt.tm_sec = strtol(p, (char **)&q, 10);
1025 /* Now we have all the fields that we can get */
1030 return now * INT64_C(1000000);
1034 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1036 dt.tm_isdst = -1; /* unknown */
1049 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1052 val += n * (*q - '0');
1059 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1061 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1071 while (*p != '\0' && *p != '=' && *p != '&') {
1072 if ((q - tag) < sizeof(tag) - 1)
1080 while (*p != '&' && *p != '\0') {
1081 if ((q - arg) < arg_size - 1) {
1091 if (!strcmp(tag, tag1))
1100 /* Return in 'buf' the path with '%d' replaced by number. Also handles
1101 the '%0nd' format where 'n' is the total number of digits and
1102 '%%'. Return 0 if OK, and -1 if format error */
1103 int get_frame_filename(char *buf, int buf_size,
1104 const char *path, int number)
1108 int nd, len, c, percentd_found;
1120 while (isdigit(*p)) {
1121 nd = nd * 10 + *p++ - '0';
1124 if (c == '*' && nd > 0) {
1125 // The nd field is actually the modulus
1126 number = number % nd;
1130 } while (isdigit(c));
1139 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
1141 if ((q - buf + len) > buf_size - 1)
1143 memcpy(q, buf1, len);
1151 if ((q - buf) < buf_size - 1)
1155 if (!percentd_found)
1166 * Print on stdout a nice hexa dump of a buffer
1168 * @param size buffer size
1170 void av_hex_dump(UINT8 *buf, int size)
1174 for(i=0;i<size;i+=16) {
1181 printf(" %02x", buf[i+j]);
1186 for(j=0;j<len;j++) {
1188 if (c < ' ' || c > '~')
1196 void url_split(char *proto, int proto_size,
1197 char *hostname, int hostname_size,
1199 char *path, int path_size,
1210 while (*p != ':' && *p != '\0') {
1211 if ((q - proto) < proto_size - 1)
1220 if (hostname_size > 0)
1230 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
1231 if ((q - hostname) < hostname_size - 1)
1235 if (hostname_size > 0)
1239 port = strtoul(p, (char **)&p, 10);
1244 pstrcpy(path, path_size, p);
1248 * Set the pts for a given stream
1250 * @param pts_wrap_bits number of bits effectively used by the pts
1251 * (used for wrap control, 33 is the value for MPEG)
1252 * @param pts_num numerator to convert to seconds (MPEG: 1)
1253 * @param pts_den denominator to convert to seconds (MPEG: 90000)
1255 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
1256 int pts_num, int pts_den)
1258 s->pts_wrap_bits = pts_wrap_bits;
1259 s->pts_num = pts_num;
1260 s->pts_den = pts_den;
1263 /* fraction handling */
1266 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
1267 * as 0 <= num < den.
1269 * @param f fractional number
1270 * @param val integer value
1271 * @param num must be >= 0
1272 * @param den must be >= 1
1274 void av_frac_init(AVFrac *f, INT64 val, INT64 num, INT64 den)
1286 /* set f to (val + 0.5) */
1287 void av_frac_set(AVFrac *f, INT64 val)
1290 f->num = f->den >> 1;
1294 * Fractionnal addition to f: f = f + (incr / f->den)
1296 * @param f fractional number
1297 * @param incr increment, can be positive or negative
1299 void av_frac_add(AVFrac *f, INT64 incr)
1303 num = f->num + incr;
1306 f->val += num / den;
1312 } else if (num >= den) {
1313 f->val += num / den;
1320 * register a new image format
1321 * @param img_fmt Image format descriptor
1323 void av_register_image_format(AVImageFormat *img_fmt)
1327 p = &first_image_format;
1328 while (*p != NULL) p = &(*p)->next;
1330 img_fmt->next = NULL;
1333 /* guess image format */
1334 AVImageFormat *av_probe_image_format(AVProbeData *pd)
1336 AVImageFormat *fmt1, *fmt;
1337 int score, score_max;
1341 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1342 if (fmt1->img_probe) {
1343 score = fmt1->img_probe(pd);
1344 if (score > score_max) {
1353 AVImageFormat *guess_image_format(const char *filename)
1355 AVImageFormat *fmt1;
1357 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
1358 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
1365 * Read an image from a stream.
1366 * @param gb byte stream containing the image
1367 * @param fmt image format, NULL if probing is required
1369 int av_read_image(ByteIOContext *pb, const char *filename,
1371 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
1373 char buf[PROBE_BUF_SIZE];
1374 AVProbeData probe_data, *pd = &probe_data;
1379 pd->filename = (char *)filename;
1381 pos = url_ftell(pb);
1382 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
1383 url_fseek(pb, pos, SEEK_SET);
1384 fmt = av_probe_image_format(pd);
1387 return AVERROR_NOFMT;
1388 ret = fmt->img_read(pb, alloc_cb, opaque);
1393 * Write an image to a stream.
1394 * @param pb byte stream for the image output
1395 * @param fmt image format
1396 * @param img image data and informations
1398 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
1400 return fmt->img_write(pb, img);