added basic png handling
[libav.git] / libavformat / png.c
1 /*
2 * PNG image format
3 * Copyright (c) 2003 Fabrice Bellard.
4 *
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.
9 *
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.
14 *
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
18 */
19 #include "avformat.h"
20
21 #include "libpng/png.h"
22
23 extern const uint8_t png_sig[];
24
25 static int png_probe(AVProbeData *pd)
26 {
27 if (pd->buf_size >= 8 &&
28 memcmp(pd->buf, png_sig, 8) == 0)
29 return AVPROBE_SCORE_MAX;
30 else
31 return 0;
32 }
33
34 png_voidp PNGAPI
35 png_memset_check (png_structp png_ptr, png_voidp s1, int value,
36 png_uint_32 length)
37 {
38 png_size_t size;
39
40 size = (png_size_t)length;
41 if ((png_uint_32)size != length)
42 png_error(png_ptr,"Overflow in png_memset_check.");
43
44 return (png_memset (s1, value, size));
45
46 }
47
48 png_voidp PNGAPI
49 png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
50 png_uint_32 length)
51 {
52 png_size_t size;
53
54 size = (png_size_t)length;
55 if ((png_uint_32)size != length)
56 png_error(png_ptr,"Overflow in png_memcpy_check.");
57
58 return(png_memcpy (s1, s2, size));
59 }
60
61 void png_error (png_struct *png_ptr, const char *message)
62 {
63 longjmp(png_ptr->jmpbuf, 0);
64 }
65
66 void png_warning (png_struct *png_ptr, const char *message)
67 {
68 }
69
70 void PNGAPI
71 png_chunk_error(png_structp png_ptr, png_const_charp error_message)
72 {
73 char msg[18+64];
74 // png_format_buffer(png_ptr, msg, error_message);
75 png_error(png_ptr, msg);
76 }
77
78 void PNGAPI
79 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
80 {
81 char msg[18+64];
82 // png_format_buffer(png_ptr, msg, warning_message);
83 png_warning(png_ptr, msg);
84 }
85
86 void png_read_data (png_struct *png_ptr, png_byte *data, png_uint_32 length)
87 {
88 int ret;
89
90 ret = get_buffer(png_ptr->io_ptr, data, length);
91 if (ret != length)
92 png_error (png_ptr, "Read Error");
93 }
94
95 void *png_malloc (png_struct *png_ptr, png_uint_32 size)
96 {
97 return av_malloc(size);
98 }
99
100 void png_free (png_struct *png_ptr, void *ptr)
101 {
102 return av_free(ptr);
103 }
104
105 static int png_read(ByteIOContext *f,
106 int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)
107 {
108 png_struct png_struct1, *png_ptr;
109 png_info png_info1, png_info2, *info_ptr, *end_info;
110 AVImageInfo info1, *info = &info1;
111 int y, height, ret, row_size;
112 uint8_t *ptr;
113
114 png_ptr = &png_struct1;
115 png_read_init(png_ptr);
116
117 info_ptr = &png_info1;
118 end_info = &png_info2;
119
120 png_info_init(info_ptr);
121 png_info_init(end_info);
122
123 png_ptr->io_ptr = f;
124
125 if (setjmp(png_jmpbuf(png_ptr))) {
126 png_read_destroy (png_ptr, info_ptr, NULL);
127 return -1;
128 }
129
130 png_read_info (png_ptr, info_ptr);
131
132 /* init image info */
133 info->width = info_ptr->width;
134 info->height = info_ptr->height;
135
136 if (info_ptr->bit_depth == 8 &&
137 info_ptr->color_type == PNG_COLOR_TYPE_RGB) {
138 info->pix_fmt = PIX_FMT_RGB24;
139 row_size = info_ptr->width * 3;
140 } else if (info_ptr->bit_depth == 8 &&
141 info_ptr->color_type == PNG_COLOR_TYPE_GRAY) {
142 info->pix_fmt = PIX_FMT_GRAY8;
143 row_size = info_ptr->width;
144 } else if (info_ptr->bit_depth == 1 &&
145 info_ptr->color_type == PNG_COLOR_TYPE_GRAY) {
146 info->pix_fmt = PIX_FMT_MONOBLACK;
147 row_size = (info_ptr->width + 7) >> 3;
148 } else {
149 png_read_destroy (png_ptr, info_ptr, NULL);
150 return -1;
151 }
152 ret = alloc_cb(opaque, info);
153 if (ret) {
154 png_read_destroy (png_ptr, info_ptr, NULL);
155 return ret;
156 }
157
158 /* now read the whole image */
159 png_start_read_image (png_ptr);
160
161 height = info->height;
162 ptr = info->pict.data[0];
163 for (y = 0; y < height; y++) {
164 png_read_row (png_ptr, NULL, NULL);
165 memcpy(ptr, png_ptr->row_buf + 1, row_size);
166 ptr += info->pict.linesize[0];
167 }
168
169 png_read_destroy (png_ptr, info_ptr, NULL);
170 return 0;
171 }
172
173 void
174 png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
175 {
176 put_buffer(png_ptr->io_ptr, data, length);
177 }
178
179 static int png_write(ByteIOContext *pb, AVImageInfo *info)
180 {
181 png_struct png_struct1, *png_ptr;
182 png_info png_info1, *info_ptr;
183 int w, h, y;
184 uint8_t *ptr;
185
186 png_ptr = &png_struct1;
187 info_ptr = &png_info1;
188
189 png_write_init(png_ptr);
190 png_info_init(info_ptr);
191
192 png_ptr->io_ptr = pb;
193
194 if (setjmp(png_ptr->jmpbuf)) {
195 png_write_destroy(png_ptr);
196 return -1;
197 }
198
199 w = info->width;
200 h = info->height;
201
202 info_ptr->width = w;
203 info_ptr->height = h;
204 switch(info->pix_fmt) {
205 case PIX_FMT_RGB24:
206 info_ptr->bit_depth = 8;
207 info_ptr->color_type = PNG_COLOR_TYPE_RGB;
208 break;
209 case PIX_FMT_GRAY8:
210 info_ptr->bit_depth = 8;
211 info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
212 break;
213 case PIX_FMT_MONOBLACK:
214 info_ptr->bit_depth = 1;
215 info_ptr->color_type = PNG_COLOR_TYPE_GRAY;
216 break;
217 default:
218 return -1;
219 }
220 png_write_info(png_ptr, info_ptr);
221
222 ptr = info->pict.data[0];
223 for(y=0;y<h;y++) {
224 png_write_row(png_ptr, ptr);
225 ptr += info->pict.linesize[0];
226 }
227 png_write_end(png_ptr, info_ptr);
228 png_write_destroy(png_ptr);
229 put_flush_packet(pb);
230 return 0;
231 }
232
233 AVImageFormat png_image_format = {
234 "png",
235 "png",
236 png_probe,
237 png_read,
238 (1 << PIX_FMT_RGB24) | (1 << PIX_FMT_GRAY8) | (1 << PIX_FMT_MONOBLACK),
239 png_write,
240 };