Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
96 | giacomo | 1 | |
2 | /* pngrutil.c - utilities to read a PNG file |
||
3 | * |
||
4 | * libpng 1.2.5 - October 3, 2002 |
||
5 | * For conditions of distribution and use, see copyright notice in png.h |
||
6 | * Copyright (c) 1998-2002 Glenn Randers-Pehrson |
||
7 | * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
||
8 | * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
||
9 | * |
||
10 | * This file contains routines that are only called from within |
||
11 | * libpng itself during the course of reading an image. |
||
12 | */ |
||
13 | |||
14 | #define PNG_INTERNAL |
||
15 | #include "png.h" |
||
16 | |||
17 | #if defined(_WIN32_WCE) |
||
18 | /* strtod() function is not supported on WindowsCE */ |
||
19 | # ifdef PNG_FLOATING_POINT_SUPPORTED |
||
20 | __inline double strtod(const char *nptr, char **endptr) |
||
21 | { |
||
22 | double result = 0; |
||
23 | int len; |
||
24 | wchar_t *str, *end; |
||
25 | |||
26 | len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); |
||
27 | str = (wchar_t *)malloc(len * sizeof(wchar_t)); |
||
28 | if ( NULL != str ) |
||
29 | { |
||
30 | MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); |
||
31 | result = wcstod(str, &end); |
||
32 | len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); |
||
33 | *endptr = (char *)nptr + (png_strlen(nptr) - len + 1); |
||
34 | free(str); |
||
35 | } |
||
36 | return result; |
||
37 | } |
||
38 | # endif |
||
39 | #endif |
||
40 | |||
41 | #ifndef PNG_READ_BIG_ENDIAN_SUPPORTED |
||
42 | /* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ |
||
43 | png_uint_32 /* PRIVATE */ |
||
44 | png_get_uint_32(png_bytep buf) |
||
45 | { |
||
46 | png_uint_32 i = ((png_uint_32)(*buf) << 24) + |
||
47 | ((png_uint_32)(*(buf + 1)) << 16) + |
||
48 | ((png_uint_32)(*(buf + 2)) << 8) + |
||
49 | (png_uint_32)(*(buf + 3)); |
||
50 | |||
51 | return (i); |
||
52 | } |
||
53 | |||
54 | #if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED) |
||
55 | /* Grab a signed 32-bit integer from a buffer in big-endian format. The |
||
56 | * data is stored in the PNG file in two's complement format, and it is |
||
57 | * assumed that the machine format for signed integers is the same. */ |
||
58 | png_int_32 /* PRIVATE */ |
||
59 | png_get_int_32(png_bytep buf) |
||
60 | { |
||
61 | png_int_32 i = ((png_int_32)(*buf) << 24) + |
||
62 | ((png_int_32)(*(buf + 1)) << 16) + |
||
63 | ((png_int_32)(*(buf + 2)) << 8) + |
||
64 | (png_int_32)(*(buf + 3)); |
||
65 | |||
66 | return (i); |
||
67 | } |
||
68 | #endif /* PNG_READ_pCAL_SUPPORTED */ |
||
69 | |||
70 | /* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ |
||
71 | png_uint_16 /* PRIVATE */ |
||
72 | png_get_uint_16(png_bytep buf) |
||
73 | { |
||
74 | png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + |
||
75 | (png_uint_16)(*(buf + 1))); |
||
76 | |||
77 | return (i); |
||
78 | } |
||
79 | #endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ |
||
80 | |||
81 | /* Read data, and (optionally) run it through the CRC. */ |
||
82 | void /* PRIVATE */ |
||
83 | png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) |
||
84 | { |
||
85 | png_read_data(png_ptr, buf, length); |
||
86 | png_calculate_crc(png_ptr, buf, length); |
||
87 | } |
||
88 | |||
89 | /* Optionally skip data and then check the CRC. Depending on whether we |
||
90 | are reading a ancillary or critical chunk, and how the program has set |
||
91 | things up, we may calculate the CRC on the data and print a message. |
||
92 | Returns '1' if there was a CRC error, '0' otherwise. */ |
||
93 | int /* PRIVATE */ |
||
94 | png_crc_finish(png_structp png_ptr, png_uint_32 skip) |
||
95 | { |
||
96 | png_size_t i; |
||
97 | png_size_t istop = png_ptr->zbuf_size; |
||
98 | |||
99 | for (i = (png_size_t)skip; i > istop; i -= istop) |
||
100 | { |
||
101 | png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
||
102 | } |
||
103 | if (i) |
||
104 | { |
||
105 | png_crc_read(png_ptr, png_ptr->zbuf, i); |
||
106 | } |
||
107 | |||
108 | if (png_crc_error(png_ptr)) |
||
109 | { |
||
110 | if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ |
||
111 | !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || |
||
112 | (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ |
||
113 | (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) |
||
114 | { |
||
115 | png_chunk_warning(png_ptr, "CRC error"); |
||
116 | } |
||
117 | else |
||
118 | { |
||
119 | png_chunk_error(png_ptr, "CRC error"); |
||
120 | } |
||
121 | return (1); |
||
122 | } |
||
123 | |||
124 | return (0); |
||
125 | } |
||
126 | |||
127 | /* Compare the CRC stored in the PNG file with that calculated by libpng from |
||
128 | the data it has read thus far. */ |
||
129 | int /* PRIVATE */ |
||
130 | png_crc_error(png_structp png_ptr) |
||
131 | { |
||
132 | png_byte crc_bytes[4]; |
||
133 | png_uint_32 crc; |
||
134 | int need_crc = 1; |
||
135 | |||
136 | if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
||
137 | { |
||
138 | if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
||
139 | (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
||
140 | need_crc = 0; |
||
141 | } |
||
142 | else /* critical */ |
||
143 | { |
||
144 | if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
||
145 | need_crc = 0; |
||
146 | } |
||
147 | |||
148 | png_read_data(png_ptr, crc_bytes, 4); |
||
149 | |||
150 | if (need_crc) |
||
151 | { |
||
152 | crc = png_get_uint_32(crc_bytes); |
||
153 | return ((int)(crc != png_ptr->crc)); |
||
154 | } |
||
155 | else |
||
156 | return (0); |
||
157 | } |
||
158 | |||
159 | #if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ |
||
160 | defined(PNG_READ_iCCP_SUPPORTED) |
||
161 | /* |
||
162 | * Decompress trailing data in a chunk. The assumption is that chunkdata |
||
163 | * points at an allocated area holding the contents of a chunk with a |
||
164 | * trailing compressed part. What we get back is an allocated area |
||
165 | * holding the original prefix part and an uncompressed version of the |
||
166 | * trailing part (the malloc area passed in is freed). |
||
167 | */ |
||
168 | png_charp /* PRIVATE */ |
||
169 | png_decompress_chunk(png_structp png_ptr, int comp_type, |
||
170 | png_charp chunkdata, png_size_t chunklength, |
||
171 | png_size_t prefix_size, png_size_t *newlength) |
||
172 | { |
||
173 | static char msg[] = "Error decoding compressed text"; |
||
174 | png_charp text = NULL; |
||
175 | png_size_t text_size; |
||
176 | |||
177 | if (comp_type == PNG_COMPRESSION_TYPE_BASE) |
||
178 | { |
||
179 | int ret = Z_OK; |
||
180 | png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size); |
||
181 | png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size); |
||
182 | png_ptr->zstream.next_out = png_ptr->zbuf; |
||
183 | png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
||
184 | |||
185 | text_size = 0; |
||
186 | text = NULL; |
||
187 | |||
188 | while (png_ptr->zstream.avail_in) |
||
189 | { |
||
190 | ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
||
191 | if (ret != Z_OK && ret != Z_STREAM_END) |
||
192 | { |
||
193 | if (png_ptr->zstream.msg != NULL) |
||
194 | png_warning(png_ptr, png_ptr->zstream.msg); |
||
195 | else |
||
196 | png_warning(png_ptr, msg); |
||
197 | inflateReset(&png_ptr->zstream); |
||
198 | png_ptr->zstream.avail_in = 0; |
||
199 | |||
200 | if (text == NULL) |
||
201 | { |
||
202 | text_size = prefix_size + sizeof(msg) + 1; |
||
203 | text = (png_charp)png_malloc_warn(png_ptr, text_size); |
||
204 | if (text == NULL) |
||
205 | { |
||
206 | png_free(png_ptr,chunkdata); |
||
207 | png_error(png_ptr,"Not enough memory to decompress chunk"); |
||
208 | } |
||
209 | png_memcpy(text, chunkdata, prefix_size); |
||
210 | } |
||
211 | |||
212 | text[text_size - 1] = 0x00; |
||
213 | |||
214 | /* Copy what we can of the error message into the text chunk */ |
||
215 | text_size = (png_size_t)(chunklength - (text - chunkdata) - 1); |
||
216 | text_size = sizeof(msg) > text_size ? text_size : sizeof(msg); |
||
217 | png_memcpy(text + prefix_size, msg, text_size + 1); |
||
218 | break; |
||
219 | } |
||
220 | if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END) |
||
221 | { |
||
222 | if (text == NULL) |
||
223 | { |
||
224 | text_size = prefix_size + |
||
225 | png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
||
226 | text = (png_charp)png_malloc_warn(png_ptr, text_size + 1); |
||
227 | if (text == NULL) |
||
228 | { |
||
229 | png_free(png_ptr,chunkdata); |
||
230 | png_error(png_ptr,"Not enough memory to decompress chunk."); |
||
231 | } |
||
232 | png_memcpy(text + prefix_size, png_ptr->zbuf, |
||
233 | text_size - prefix_size); |
||
234 | png_memcpy(text, chunkdata, prefix_size); |
||
235 | *(text + text_size) = 0x00; |
||
236 | } |
||
237 | else |
||
238 | { |
||
239 | png_charp tmp; |
||
240 | |||
241 | tmp = text; |
||
242 | text = (png_charp)png_malloc_warn(png_ptr, |
||
243 | (png_uint_32)(text_size + |
||
244 | png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1)); |
||
245 | if (text == NULL) |
||
246 | { |
||
247 | png_free(png_ptr, tmp); |
||
248 | png_free(png_ptr, chunkdata); |
||
249 | png_error(png_ptr,"Not enough memory to decompress chunk.."); |
||
250 | } |
||
251 | png_memcpy(text, tmp, text_size); |
||
252 | png_free(png_ptr, tmp); |
||
253 | png_memcpy(text + text_size, png_ptr->zbuf, |
||
254 | (png_ptr->zbuf_size - png_ptr->zstream.avail_out)); |
||
255 | text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
||
256 | *(text + text_size) = 0x00; |
||
257 | } |
||
258 | if (ret == Z_STREAM_END) |
||
259 | break; |
||
260 | else |
||
261 | { |
||
262 | png_ptr->zstream.next_out = png_ptr->zbuf; |
||
263 | png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
||
264 | } |
||
265 | } |
||
266 | } |
||
267 | if (ret != Z_STREAM_END) |
||
268 | { |
||
269 | #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
||
270 | char umsg[50]; |
||
271 | |||
272 | if (ret == Z_BUF_ERROR) |
||
273 | sprintf(umsg,"Buffer error in compressed datastream in %s chunk", |
||
274 | png_ptr->chunk_name); |
||
275 | else if (ret == Z_DATA_ERROR) |
||
276 | sprintf(umsg,"Data error in compressed datastream in %s chunk", |
||
277 | png_ptr->chunk_name); |
||
278 | else |
||
279 | sprintf(umsg,"Incomplete compressed datastream in %s chunk", |
||
280 | png_ptr->chunk_name); |
||
281 | png_warning(png_ptr, umsg); |
||
282 | #else |
||
283 | png_warning(png_ptr, |
||
284 | "Incomplete compressed datastream in chunk other than IDAT"); |
||
285 | #endif |
||
286 | text_size=prefix_size; |
||
287 | if (text == NULL) |
||
288 | { |
||
289 | text = (png_charp)png_malloc_warn(png_ptr, text_size+1); |
||
290 | if (text == NULL) |
||
291 | { |
||
292 | png_free(png_ptr, chunkdata); |
||
293 | png_error(png_ptr,"Not enough memory for text."); |
||
294 | } |
||
295 | png_memcpy(text, chunkdata, prefix_size); |
||
296 | } |
||
297 | *(text + text_size) = 0x00; |
||
298 | } |
||
299 | |||
300 | inflateReset(&png_ptr->zstream); |
||
301 | png_ptr->zstream.avail_in = 0; |
||
302 | |||
303 | png_free(png_ptr, chunkdata); |
||
304 | chunkdata = text; |
||
305 | *newlength=text_size; |
||
306 | } |
||
307 | else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ |
||
308 | { |
||
309 | #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
||
310 | char umsg[50]; |
||
311 | |||
312 | sprintf(umsg, "Unknown zTXt compression type %d", comp_type); |
||
313 | png_warning(png_ptr, umsg); |
||
314 | #else |
||
315 | png_warning(png_ptr, "Unknown zTXt compression type"); |
||
316 | #endif |
||
317 | |||
318 | *(chunkdata + prefix_size) = 0x00; |
||
319 | *newlength=prefix_size; |
||
320 | } |
||
321 | |||
322 | return chunkdata; |
||
323 | } |
||
324 | #endif |
||
325 | |||
326 | /* read and check the IDHR chunk */ |
||
327 | void /* PRIVATE */ |
||
328 | png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
329 | { |
||
330 | png_byte buf[13]; |
||
331 | png_uint_32 width, height; |
||
332 | int bit_depth, color_type, compression_type, filter_type; |
||
333 | int interlace_type; |
||
334 | |||
335 | png_debug(1, "in png_handle_IHDR\n"); |
||
336 | |||
337 | if (png_ptr->mode & PNG_HAVE_IHDR) |
||
338 | png_error(png_ptr, "Out of place IHDR"); |
||
339 | |||
340 | /* check the length */ |
||
341 | if (length != 13) |
||
342 | png_error(png_ptr, "Invalid IHDR chunk"); |
||
343 | |||
344 | png_ptr->mode |= PNG_HAVE_IHDR; |
||
345 | |||
346 | png_crc_read(png_ptr, buf, 13); |
||
347 | png_crc_finish(png_ptr, 0); |
||
348 | |||
349 | width = png_get_uint_32(buf); |
||
350 | height = png_get_uint_32(buf + 4); |
||
351 | bit_depth = buf[8]; |
||
352 | color_type = buf[9]; |
||
353 | compression_type = buf[10]; |
||
354 | filter_type = buf[11]; |
||
355 | interlace_type = buf[12]; |
||
356 | |||
357 | |||
358 | /* set internal variables */ |
||
359 | png_ptr->width = width; |
||
360 | png_ptr->height = height; |
||
361 | png_ptr->bit_depth = (png_byte)bit_depth; |
||
362 | png_ptr->interlaced = (png_byte)interlace_type; |
||
363 | png_ptr->color_type = (png_byte)color_type; |
||
364 | #if defined(PNG_MNG_FEATURES_SUPPORTED) |
||
365 | png_ptr->filter_type = (png_byte)filter_type; |
||
366 | #endif |
||
367 | |||
368 | /* find number of channels */ |
||
369 | switch (png_ptr->color_type) |
||
370 | { |
||
371 | case PNG_COLOR_TYPE_GRAY: |
||
372 | case PNG_COLOR_TYPE_PALETTE: |
||
373 | png_ptr->channels = 1; |
||
374 | break; |
||
375 | case PNG_COLOR_TYPE_RGB: |
||
376 | png_ptr->channels = 3; |
||
377 | break; |
||
378 | case PNG_COLOR_TYPE_GRAY_ALPHA: |
||
379 | png_ptr->channels = 2; |
||
380 | break; |
||
381 | case PNG_COLOR_TYPE_RGB_ALPHA: |
||
382 | png_ptr->channels = 4; |
||
383 | break; |
||
384 | } |
||
385 | |||
386 | /* set up other useful info */ |
||
387 | png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * |
||
388 | png_ptr->channels); |
||
389 | png_ptr->rowbytes = ((png_ptr->width * |
||
390 | (png_uint_32)png_ptr->pixel_depth + 7) >> 3); |
||
391 | png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth); |
||
392 | png_debug1(3,"channels = %d\n", png_ptr->channels); |
||
393 | png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes); |
||
394 | png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, |
||
395 | color_type, interlace_type, compression_type, filter_type); |
||
396 | } |
||
397 | |||
398 | /* read and check the palette */ |
||
399 | void /* PRIVATE */ |
||
400 | png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
401 | { |
||
402 | png_color palette[PNG_MAX_PALETTE_LENGTH]; |
||
403 | int num, i; |
||
404 | #ifndef PNG_NO_POINTER_INDEXING |
||
405 | png_colorp pal_ptr; |
||
406 | #endif |
||
407 | |||
408 | png_debug(1, "in png_handle_PLTE\n"); |
||
409 | |||
410 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
411 | png_error(png_ptr, "Missing IHDR before PLTE"); |
||
412 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
413 | { |
||
414 | png_warning(png_ptr, "Invalid PLTE after IDAT"); |
||
415 | png_crc_finish(png_ptr, length); |
||
416 | return; |
||
417 | } |
||
418 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
419 | png_error(png_ptr, "Duplicate PLTE chunk"); |
||
420 | |||
421 | png_ptr->mode |= PNG_HAVE_PLTE; |
||
422 | |||
423 | if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
||
424 | { |
||
425 | png_warning(png_ptr, |
||
426 | "Ignoring PLTE chunk in grayscale PNG"); |
||
427 | png_crc_finish(png_ptr, length); |
||
428 | return; |
||
429 | } |
||
430 | #if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
||
431 | if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
||
432 | { |
||
433 | png_crc_finish(png_ptr, length); |
||
434 | return; |
||
435 | } |
||
436 | #endif |
||
437 | |||
438 | if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) |
||
439 | { |
||
440 | if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
||
441 | { |
||
442 | png_warning(png_ptr, "Invalid palette chunk"); |
||
443 | png_crc_finish(png_ptr, length); |
||
444 | return; |
||
445 | } |
||
446 | else |
||
447 | { |
||
448 | png_error(png_ptr, "Invalid palette chunk"); |
||
449 | } |
||
450 | } |
||
451 | |||
452 | num = (int)length / 3; |
||
453 | |||
454 | #ifndef PNG_NO_POINTER_INDEXING |
||
455 | for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) |
||
456 | { |
||
457 | png_byte buf[3]; |
||
458 | |||
459 | png_crc_read(png_ptr, buf, 3); |
||
460 | pal_ptr->red = buf[0]; |
||
461 | pal_ptr->green = buf[1]; |
||
462 | pal_ptr->blue = buf[2]; |
||
463 | } |
||
464 | #else |
||
465 | for (i = 0; i < num; i++) |
||
466 | { |
||
467 | png_byte buf[3]; |
||
468 | |||
469 | png_crc_read(png_ptr, buf, 3); |
||
470 | /* don't depend upon png_color being any order */ |
||
471 | palette[i].red = buf[0]; |
||
472 | palette[i].green = buf[1]; |
||
473 | palette[i].blue = buf[2]; |
||
474 | } |
||
475 | #endif |
||
476 | |||
477 | /* If we actually NEED the PLTE chunk (ie for a paletted image), we do |
||
478 | whatever the normal CRC configuration tells us. However, if we |
||
479 | have an RGB image, the PLTE can be considered ancillary, so |
||
480 | we will act as though it is. */ |
||
481 | #if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
||
482 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
483 | #endif |
||
484 | { |
||
485 | png_crc_finish(png_ptr, 0); |
||
486 | } |
||
487 | #if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
||
488 | else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ |
||
489 | { |
||
490 | /* If we don't want to use the data from an ancillary chunk, |
||
491 | we have two options: an error abort, or a warning and we |
||
492 | ignore the data in this chunk (which should be OK, since |
||
493 | it's considered ancillary for a RGB or RGBA image). */ |
||
494 | if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) |
||
495 | { |
||
496 | if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) |
||
497 | { |
||
498 | png_chunk_error(png_ptr, "CRC error"); |
||
499 | } |
||
500 | else |
||
501 | { |
||
502 | png_chunk_warning(png_ptr, "CRC error"); |
||
503 | return; |
||
504 | } |
||
505 | } |
||
506 | /* Otherwise, we (optionally) emit a warning and use the chunk. */ |
||
507 | else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
||
508 | { |
||
509 | png_chunk_warning(png_ptr, "CRC error"); |
||
510 | } |
||
511 | } |
||
512 | #endif |
||
513 | |||
514 | png_set_PLTE(png_ptr, info_ptr, palette, num); |
||
515 | |||
516 | #if defined(PNG_READ_tRNS_SUPPORTED) |
||
517 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
518 | { |
||
519 | if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
||
520 | { |
||
521 | if (png_ptr->num_trans > (png_uint_16)num) |
||
522 | { |
||
523 | png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); |
||
524 | png_ptr->num_trans = (png_uint_16)num; |
||
525 | } |
||
526 | if (info_ptr->num_trans > (png_uint_16)num) |
||
527 | { |
||
528 | png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); |
||
529 | info_ptr->num_trans = (png_uint_16)num; |
||
530 | } |
||
531 | } |
||
532 | } |
||
533 | #endif |
||
534 | |||
535 | } |
||
536 | |||
537 | void /* PRIVATE */ |
||
538 | png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
539 | { |
||
540 | png_debug(1, "in png_handle_IEND\n"); |
||
541 | |||
542 | if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) |
||
543 | { |
||
544 | png_error(png_ptr, "No image in file"); |
||
545 | |||
546 | info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
||
547 | } |
||
548 | |||
549 | png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); |
||
550 | |||
551 | if (length != 0) |
||
552 | { |
||
553 | png_warning(png_ptr, "Incorrect IEND chunk length"); |
||
554 | } |
||
555 | png_crc_finish(png_ptr, length); |
||
556 | } |
||
557 | |||
558 | #if defined(PNG_READ_gAMA_SUPPORTED) |
||
559 | void /* PRIVATE */ |
||
560 | png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
561 | { |
||
562 | png_fixed_point igamma; |
||
563 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
564 | float file_gamma; |
||
565 | #endif |
||
566 | png_byte buf[4]; |
||
567 | |||
568 | png_debug(1, "in png_handle_gAMA\n"); |
||
569 | |||
570 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
571 | png_error(png_ptr, "Missing IHDR before gAMA"); |
||
572 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
573 | { |
||
574 | png_warning(png_ptr, "Invalid gAMA after IDAT"); |
||
575 | png_crc_finish(png_ptr, length); |
||
576 | return; |
||
577 | } |
||
578 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
579 | /* Should be an error, but we can cope with it */ |
||
580 | png_warning(png_ptr, "Out of place gAMA chunk"); |
||
581 | |||
582 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
||
583 | #if defined(PNG_READ_sRGB_SUPPORTED) |
||
584 | && !(info_ptr->valid & PNG_INFO_sRGB) |
||
585 | #endif |
||
586 | ) |
||
587 | { |
||
588 | png_warning(png_ptr, "Duplicate gAMA chunk"); |
||
589 | png_crc_finish(png_ptr, length); |
||
590 | return; |
||
591 | } |
||
592 | |||
593 | if (length != 4) |
||
594 | { |
||
595 | png_warning(png_ptr, "Incorrect gAMA chunk length"); |
||
596 | png_crc_finish(png_ptr, length); |
||
597 | return; |
||
598 | } |
||
599 | |||
600 | png_crc_read(png_ptr, buf, 4); |
||
601 | if (png_crc_finish(png_ptr, 0)) |
||
602 | return; |
||
603 | |||
604 | igamma = (png_fixed_point)png_get_uint_32(buf); |
||
605 | /* check for zero gamma */ |
||
606 | if (igamma == 0) |
||
607 | { |
||
608 | png_warning(png_ptr, |
||
609 | "Ignoring gAMA chunk with gamma=0"); |
||
610 | return; |
||
611 | } |
||
612 | |||
613 | #if defined(PNG_READ_sRGB_SUPPORTED) |
||
614 | if (info_ptr->valid & PNG_INFO_sRGB) |
||
615 | if(igamma < 45000L || igamma > 46000L) |
||
616 | { |
||
617 | png_warning(png_ptr, |
||
618 | "Ignoring incorrect gAMA value when sRGB is also present"); |
||
619 | #ifndef PNG_NO_CONSOLE_IO |
||
620 | cprintf("gamma = (%d/100000)\n", (int)igamma); |
||
621 | #endif |
||
622 | return; |
||
623 | } |
||
624 | #endif /* PNG_READ_sRGB_SUPPORTED */ |
||
625 | |||
626 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
627 | file_gamma = (float)igamma / (float)100000.0; |
||
628 | # ifdef PNG_READ_GAMMA_SUPPORTED |
||
629 | png_ptr->gamma = file_gamma; |
||
630 | # endif |
||
631 | png_set_gAMA(png_ptr, info_ptr, file_gamma); |
||
632 | #endif |
||
633 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
634 | png_set_gAMA_fixed(png_ptr, info_ptr, igamma); |
||
635 | #endif |
||
636 | } |
||
637 | #endif |
||
638 | |||
639 | #if defined(PNG_READ_sBIT_SUPPORTED) |
||
640 | void /* PRIVATE */ |
||
641 | png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
642 | { |
||
643 | png_size_t truelen; |
||
644 | png_byte buf[4]; |
||
645 | |||
646 | png_debug(1, "in png_handle_sBIT\n"); |
||
647 | |||
648 | buf[0] = buf[1] = buf[2] = buf[3] = 0; |
||
649 | |||
650 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
651 | png_error(png_ptr, "Missing IHDR before sBIT"); |
||
652 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
653 | { |
||
654 | png_warning(png_ptr, "Invalid sBIT after IDAT"); |
||
655 | png_crc_finish(png_ptr, length); |
||
656 | return; |
||
657 | } |
||
658 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
659 | { |
||
660 | /* Should be an error, but we can cope with it */ |
||
661 | png_warning(png_ptr, "Out of place sBIT chunk"); |
||
662 | } |
||
663 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) |
||
664 | { |
||
665 | png_warning(png_ptr, "Duplicate sBIT chunk"); |
||
666 | png_crc_finish(png_ptr, length); |
||
667 | return; |
||
668 | } |
||
669 | |||
670 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
671 | truelen = 3; |
||
672 | else |
||
673 | truelen = (png_size_t)png_ptr->channels; |
||
674 | |||
675 | if (length != truelen) |
||
676 | { |
||
677 | png_warning(png_ptr, "Incorrect sBIT chunk length"); |
||
678 | png_crc_finish(png_ptr, length); |
||
679 | return; |
||
680 | } |
||
681 | |||
682 | png_crc_read(png_ptr, buf, truelen); |
||
683 | if (png_crc_finish(png_ptr, 0)) |
||
684 | return; |
||
685 | |||
686 | if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
||
687 | { |
||
688 | png_ptr->sig_bit.red = buf[0]; |
||
689 | png_ptr->sig_bit.green = buf[1]; |
||
690 | png_ptr->sig_bit.blue = buf[2]; |
||
691 | png_ptr->sig_bit.alpha = buf[3]; |
||
692 | } |
||
693 | else |
||
694 | { |
||
695 | png_ptr->sig_bit.gray = buf[0]; |
||
696 | png_ptr->sig_bit.red = buf[0]; |
||
697 | png_ptr->sig_bit.green = buf[0]; |
||
698 | png_ptr->sig_bit.blue = buf[0]; |
||
699 | png_ptr->sig_bit.alpha = buf[1]; |
||
700 | } |
||
701 | png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); |
||
702 | } |
||
703 | #endif |
||
704 | |||
705 | #if defined(PNG_READ_cHRM_SUPPORTED) |
||
706 | void /* PRIVATE */ |
||
707 | png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
708 | { |
||
709 | png_byte buf[4]; |
||
710 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
711 | float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
||
712 | #endif |
||
713 | png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
||
714 | int_y_green, int_x_blue, int_y_blue; |
||
715 | |||
716 | png_uint_32 uint_x, uint_y; |
||
717 | |||
718 | png_debug(1, "in png_handle_cHRM\n"); |
||
719 | |||
720 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
721 | png_error(png_ptr, "Missing IHDR before cHRM"); |
||
722 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
723 | { |
||
724 | png_warning(png_ptr, "Invalid cHRM after IDAT"); |
||
725 | png_crc_finish(png_ptr, length); |
||
726 | return; |
||
727 | } |
||
728 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
729 | /* Should be an error, but we can cope with it */ |
||
730 | png_warning(png_ptr, "Missing PLTE before cHRM"); |
||
731 | |||
732 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) |
||
733 | #if defined(PNG_READ_sRGB_SUPPORTED) |
||
734 | && !(info_ptr->valid & PNG_INFO_sRGB) |
||
735 | #endif |
||
736 | ) |
||
737 | { |
||
738 | png_warning(png_ptr, "Duplicate cHRM chunk"); |
||
739 | png_crc_finish(png_ptr, length); |
||
740 | return; |
||
741 | } |
||
742 | |||
743 | if (length != 32) |
||
744 | { |
||
745 | png_warning(png_ptr, "Incorrect cHRM chunk length"); |
||
746 | png_crc_finish(png_ptr, length); |
||
747 | return; |
||
748 | } |
||
749 | |||
750 | png_crc_read(png_ptr, buf, 4); |
||
751 | uint_x = png_get_uint_32(buf); |
||
752 | |||
753 | png_crc_read(png_ptr, buf, 4); |
||
754 | uint_y = png_get_uint_32(buf); |
||
755 | |||
756 | if (uint_x > 80000L || uint_y > 80000L || |
||
757 | uint_x + uint_y > 100000L) |
||
758 | { |
||
759 | png_warning(png_ptr, "Invalid cHRM white point"); |
||
760 | png_crc_finish(png_ptr, 24); |
||
761 | return; |
||
762 | } |
||
763 | int_x_white = (png_fixed_point)uint_x; |
||
764 | int_y_white = (png_fixed_point)uint_y; |
||
765 | |||
766 | png_crc_read(png_ptr, buf, 4); |
||
767 | uint_x = png_get_uint_32(buf); |
||
768 | |||
769 | png_crc_read(png_ptr, buf, 4); |
||
770 | uint_y = png_get_uint_32(buf); |
||
771 | |||
772 | if (uint_x > 80000L || uint_y > 80000L || |
||
773 | uint_x + uint_y > 100000L) |
||
774 | { |
||
775 | png_warning(png_ptr, "Invalid cHRM red point"); |
||
776 | png_crc_finish(png_ptr, 16); |
||
777 | return; |
||
778 | } |
||
779 | int_x_red = (png_fixed_point)uint_x; |
||
780 | int_y_red = (png_fixed_point)uint_y; |
||
781 | |||
782 | png_crc_read(png_ptr, buf, 4); |
||
783 | uint_x = png_get_uint_32(buf); |
||
784 | |||
785 | png_crc_read(png_ptr, buf, 4); |
||
786 | uint_y = png_get_uint_32(buf); |
||
787 | |||
788 | if (uint_x > 80000L || uint_y > 80000L || |
||
789 | uint_x + uint_y > 100000L) |
||
790 | { |
||
791 | png_warning(png_ptr, "Invalid cHRM green point"); |
||
792 | png_crc_finish(png_ptr, 8); |
||
793 | return; |
||
794 | } |
||
795 | int_x_green = (png_fixed_point)uint_x; |
||
796 | int_y_green = (png_fixed_point)uint_y; |
||
797 | |||
798 | png_crc_read(png_ptr, buf, 4); |
||
799 | uint_x = png_get_uint_32(buf); |
||
800 | |||
801 | png_crc_read(png_ptr, buf, 4); |
||
802 | uint_y = png_get_uint_32(buf); |
||
803 | |||
804 | if (uint_x > 80000L || uint_y > 80000L || |
||
805 | uint_x + uint_y > 100000L) |
||
806 | { |
||
807 | png_warning(png_ptr, "Invalid cHRM blue point"); |
||
808 | png_crc_finish(png_ptr, 0); |
||
809 | return; |
||
810 | } |
||
811 | int_x_blue = (png_fixed_point)uint_x; |
||
812 | int_y_blue = (png_fixed_point)uint_y; |
||
813 | |||
814 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
815 | white_x = (float)int_x_white / (float)100000.0; |
||
816 | white_y = (float)int_y_white / (float)100000.0; |
||
817 | red_x = (float)int_x_red / (float)100000.0; |
||
818 | red_y = (float)int_y_red / (float)100000.0; |
||
819 | green_x = (float)int_x_green / (float)100000.0; |
||
820 | green_y = (float)int_y_green / (float)100000.0; |
||
821 | blue_x = (float)int_x_blue / (float)100000.0; |
||
822 | blue_y = (float)int_y_blue / (float)100000.0; |
||
823 | #endif |
||
824 | |||
825 | #if defined(PNG_READ_sRGB_SUPPORTED) |
||
826 | if (info_ptr->valid & PNG_INFO_sRGB) |
||
827 | { |
||
828 | if (abs(int_x_white - 31270L) > 1000 || |
||
829 | abs(int_y_white - 32900L) > 1000 || |
||
830 | abs(int_x_red - 64000L) > 1000 || |
||
831 | abs(int_y_red - 33000L) > 1000 || |
||
832 | abs(int_x_green - 30000L) > 1000 || |
||
833 | abs(int_y_green - 60000L) > 1000 || |
||
834 | abs(int_x_blue - 15000L) > 1000 || |
||
835 | abs(int_y_blue - 6000L) > 1000) |
||
836 | { |
||
837 | |||
838 | png_warning(png_ptr, |
||
839 | "Ignoring incorrect cHRM value when sRGB is also present"); |
||
840 | #ifndef PNG_NO_CONSOLE_IO |
||
841 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
842 | cprintf("wx=%f, wy=%f, rx=%f, ry=%f\n", |
||
843 | white_x, white_y, red_x, red_y); |
||
844 | cprintf("gx=%f, gy=%f, bx=%f, by=%f\n", |
||
845 | green_x, green_y, blue_x, blue_y); |
||
846 | #else |
||
847 | cprintf("wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", |
||
848 | int_x_white, int_y_white, int_x_red, int_y_red); |
||
849 | cprintf("gx=%ld, gy=%ld, bx=%ld, by=%ld\n", |
||
850 | int_x_green, int_y_green, int_x_blue, int_y_blue); |
||
851 | #endif |
||
852 | #endif /* PNG_NO_CONSOLE_IO */ |
||
853 | } |
||
854 | png_crc_finish(png_ptr, 0); |
||
855 | return; |
||
856 | } |
||
857 | #endif /* PNG_READ_sRGB_SUPPORTED */ |
||
858 | |||
859 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
860 | png_set_cHRM(png_ptr, info_ptr, |
||
861 | white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); |
||
862 | #endif |
||
863 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
864 | png_set_cHRM_fixed(png_ptr, info_ptr, |
||
865 | int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
||
866 | int_y_green, int_x_blue, int_y_blue); |
||
867 | #endif |
||
868 | if (png_crc_finish(png_ptr, 0)) |
||
869 | return; |
||
870 | } |
||
871 | #endif |
||
872 | |||
873 | #if defined(PNG_READ_sRGB_SUPPORTED) |
||
874 | void /* PRIVATE */ |
||
875 | png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
876 | { |
||
877 | int intent; |
||
878 | png_byte buf[1]; |
||
879 | |||
880 | png_debug(1, "in png_handle_sRGB\n"); |
||
881 | |||
882 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
883 | png_error(png_ptr, "Missing IHDR before sRGB"); |
||
884 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
885 | { |
||
886 | png_warning(png_ptr, "Invalid sRGB after IDAT"); |
||
887 | png_crc_finish(png_ptr, length); |
||
888 | return; |
||
889 | } |
||
890 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
891 | /* Should be an error, but we can cope with it */ |
||
892 | png_warning(png_ptr, "Out of place sRGB chunk"); |
||
893 | |||
894 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
||
895 | { |
||
896 | png_warning(png_ptr, "Duplicate sRGB chunk"); |
||
897 | png_crc_finish(png_ptr, length); |
||
898 | return; |
||
899 | } |
||
900 | |||
901 | if (length != 1) |
||
902 | { |
||
903 | png_warning(png_ptr, "Incorrect sRGB chunk length"); |
||
904 | png_crc_finish(png_ptr, length); |
||
905 | return; |
||
906 | } |
||
907 | |||
908 | png_crc_read(png_ptr, buf, 1); |
||
909 | if (png_crc_finish(png_ptr, 0)) |
||
910 | return; |
||
911 | |||
912 | intent = buf[0]; |
||
913 | /* check for bad intent */ |
||
914 | if (intent >= PNG_sRGB_INTENT_LAST) |
||
915 | { |
||
916 | png_warning(png_ptr, "Unknown sRGB intent"); |
||
917 | return; |
||
918 | } |
||
919 | |||
920 | #if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
||
921 | if ((info_ptr->valid & PNG_INFO_gAMA)) |
||
922 | { |
||
923 | int igamma; |
||
924 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
925 | igamma=(int)info_ptr->int_gamma; |
||
926 | #else |
||
927 | # ifdef PNG_FLOATING_POINT_SUPPORTED |
||
928 | igamma=(int)(info_ptr->gamma * 100000.); |
||
929 | # endif |
||
930 | #endif |
||
931 | if(igamma < 45000L || igamma > 46000L) |
||
932 | { |
||
933 | png_warning(png_ptr, |
||
934 | "Ignoring incorrect gAMA value when sRGB is also present"); |
||
935 | #ifndef PNG_NO_CONSOLE_IO |
||
936 | # ifdef PNG_FIXED_POINT_SUPPORTED |
||
937 | cprintf("incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma); |
||
938 | # else |
||
939 | # ifdef PNG_FLOATING_POINT_SUPPORTED |
||
940 | cprintf("incorrect gamma=%f\n",png_ptr->gamma); |
||
941 | # endif |
||
942 | # endif |
||
943 | #endif |
||
944 | } |
||
945 | } |
||
946 | #endif /* PNG_READ_gAMA_SUPPORTED */ |
||
947 | |||
948 | #ifdef PNG_READ_cHRM_SUPPORTED |
||
949 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
950 | if (info_ptr->valid & PNG_INFO_cHRM) |
||
951 | if (abs(info_ptr->int_x_white - 31270L) > 1000 || |
||
952 | abs(info_ptr->int_y_white - 32900L) > 1000 || |
||
953 | abs(info_ptr->int_x_red - 64000L) > 1000 || |
||
954 | abs(info_ptr->int_y_red - 33000L) > 1000 || |
||
955 | abs(info_ptr->int_x_green - 30000L) > 1000 || |
||
956 | abs(info_ptr->int_y_green - 60000L) > 1000 || |
||
957 | abs(info_ptr->int_x_blue - 15000L) > 1000 || |
||
958 | abs(info_ptr->int_y_blue - 6000L) > 1000) |
||
959 | { |
||
960 | png_warning(png_ptr, |
||
961 | "Ignoring incorrect cHRM value when sRGB is also present"); |
||
962 | } |
||
963 | #endif /* PNG_FIXED_POINT_SUPPORTED */ |
||
964 | #endif /* PNG_READ_cHRM_SUPPORTED */ |
||
965 | |||
966 | png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); |
||
967 | } |
||
968 | #endif /* PNG_READ_sRGB_SUPPORTED */ |
||
969 | |||
970 | #if defined(PNG_READ_iCCP_SUPPORTED) |
||
971 | void /* PRIVATE */ |
||
972 | png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
973 | /* Note: this does not properly handle chunks that are > 64K under DOS */ |
||
974 | { |
||
975 | png_charp chunkdata; |
||
976 | png_byte compression_type; |
||
977 | png_bytep pC; |
||
978 | png_charp profile; |
||
979 | png_uint_32 skip = 0; |
||
980 | png_uint_32 profile_size = 0; |
||
981 | png_uint_32 profile_length = 0; |
||
982 | png_size_t slength, prefix_length, data_length; |
||
983 | |||
984 | png_debug(1, "in png_handle_iCCP\n"); |
||
985 | |||
986 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
987 | png_error(png_ptr, "Missing IHDR before iCCP"); |
||
988 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
989 | { |
||
990 | png_warning(png_ptr, "Invalid iCCP after IDAT"); |
||
991 | png_crc_finish(png_ptr, length); |
||
992 | return; |
||
993 | } |
||
994 | else if (png_ptr->mode & PNG_HAVE_PLTE) |
||
995 | /* Should be an error, but we can cope with it */ |
||
996 | png_warning(png_ptr, "Out of place iCCP chunk"); |
||
997 | |||
998 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) |
||
999 | { |
||
1000 | png_warning(png_ptr, "Duplicate iCCP chunk"); |
||
1001 | png_crc_finish(png_ptr, length); |
||
1002 | return; |
||
1003 | } |
||
1004 | |||
1005 | #ifdef PNG_MAX_MALLOC_64K |
||
1006 | if (length > (png_uint_32)65535L) |
||
1007 | { |
||
1008 | png_warning(png_ptr, "iCCP chunk too large to fit in memory"); |
||
1009 | skip = length - (png_uint_32)65535L; |
||
1010 | length = (png_uint_32)65535L; |
||
1011 | } |
||
1012 | #endif |
||
1013 | |||
1014 | chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
||
1015 | slength = (png_size_t)length; |
||
1016 | png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
||
1017 | |||
1018 | if (png_crc_finish(png_ptr, skip)) |
||
1019 | { |
||
1020 | png_free(png_ptr, chunkdata); |
||
1021 | return; |
||
1022 | } |
||
1023 | |||
1024 | chunkdata[slength] = 0x00; |
||
1025 | |||
1026 | for (profile = chunkdata; *profile; profile++) |
||
1027 | /* empty loop to find end of name */ ; |
||
1028 | |||
1029 | ++profile; |
||
1030 | |||
1031 | /* there should be at least one zero (the compression type byte) |
||
1032 | following the separator, and we should be on it */ |
||
1033 | if ( profile >= chunkdata + slength) |
||
1034 | { |
||
1035 | png_free(png_ptr, chunkdata); |
||
1036 | png_warning(png_ptr, "Malformed iCCP chunk"); |
||
1037 | return; |
||
1038 | } |
||
1039 | |||
1040 | /* compression_type should always be zero */ |
||
1041 | compression_type = *profile++; |
||
1042 | if (compression_type) |
||
1043 | { |
||
1044 | png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); |
||
1045 | compression_type=0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 |
||
1046 | wrote nonzero) */ |
||
1047 | } |
||
1048 | |||
1049 | prefix_length = profile - chunkdata; |
||
1050 | chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata, |
||
1051 | slength, prefix_length, &data_length); |
||
1052 | |||
1053 | profile_length = data_length - prefix_length; |
||
1054 | |||
1055 | if ( prefix_length > data_length || profile_length < 4) |
||
1056 | { |
||
1057 | png_free(png_ptr, chunkdata); |
||
1058 | png_warning(png_ptr, "Profile size field missing from iCCP chunk"); |
||
1059 | return; |
||
1060 | } |
||
1061 | |||
1062 | /* Check the profile_size recorded in the first 32 bits of the ICC profile */ |
||
1063 | pC = (png_bytep)(chunkdata+prefix_length); |
||
1064 | profile_size = ((*(pC ))<<24) | |
||
1065 | ((*(pC+1))<<16) | |
||
1066 | ((*(pC+2))<< 8) | |
||
1067 | ((*(pC+3)) ); |
||
1068 | |||
1069 | if(profile_size < profile_length) |
||
1070 | profile_length = profile_size; |
||
1071 | |||
1072 | if(profile_size > profile_length) |
||
1073 | { |
||
1074 | png_free(png_ptr, chunkdata); |
||
1075 | png_warning(png_ptr, "Ignoring truncated iCCP profile.\n"); |
||
1076 | return; |
||
1077 | } |
||
1078 | |||
1079 | png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type, |
||
1080 | chunkdata + prefix_length, profile_length); |
||
1081 | png_free(png_ptr, chunkdata); |
||
1082 | } |
||
1083 | #endif /* PNG_READ_iCCP_SUPPORTED */ |
||
1084 | |||
1085 | #if defined(PNG_READ_sPLT_SUPPORTED) |
||
1086 | void /* PRIVATE */ |
||
1087 | png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1088 | /* Note: this does not properly handle chunks that are > 64K under DOS */ |
||
1089 | { |
||
1090 | png_bytep chunkdata; |
||
1091 | png_bytep entry_start; |
||
1092 | png_sPLT_t new_palette; |
||
1093 | #ifdef PNG_NO_POINTER_INDEXING |
||
1094 | png_sPLT_entryp pp; |
||
1095 | #endif |
||
1096 | int data_length, entry_size, i; |
||
1097 | png_uint_32 skip = 0; |
||
1098 | png_size_t slength; |
||
1099 | |||
1100 | png_debug(1, "in png_handle_sPLT\n"); |
||
1101 | |||
1102 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1103 | png_error(png_ptr, "Missing IHDR before sPLT"); |
||
1104 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1105 | { |
||
1106 | png_warning(png_ptr, "Invalid sPLT after IDAT"); |
||
1107 | png_crc_finish(png_ptr, length); |
||
1108 | return; |
||
1109 | } |
||
1110 | |||
1111 | #ifdef PNG_MAX_MALLOC_64K |
||
1112 | if (length > (png_uint_32)65535L) |
||
1113 | { |
||
1114 | png_warning(png_ptr, "sPLT chunk too large to fit in memory"); |
||
1115 | skip = length - (png_uint_32)65535L; |
||
1116 | length = (png_uint_32)65535L; |
||
1117 | } |
||
1118 | #endif |
||
1119 | |||
1120 | chunkdata = (png_bytep)png_malloc(png_ptr, length + 1); |
||
1121 | slength = (png_size_t)length; |
||
1122 | png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
||
1123 | |||
1124 | if (png_crc_finish(png_ptr, skip)) |
||
1125 | { |
||
1126 | png_free(png_ptr, chunkdata); |
||
1127 | return; |
||
1128 | } |
||
1129 | |||
1130 | chunkdata[slength] = 0x00; |
||
1131 | |||
1132 | for (entry_start = chunkdata; *entry_start; entry_start++) |
||
1133 | /* empty loop to find end of name */ ; |
||
1134 | ++entry_start; |
||
1135 | |||
1136 | /* a sample depth should follow the separator, and we should be on it */ |
||
1137 | if (entry_start > chunkdata + slength) |
||
1138 | { |
||
1139 | png_free(png_ptr, chunkdata); |
||
1140 | png_warning(png_ptr, "malformed sPLT chunk"); |
||
1141 | return; |
||
1142 | } |
||
1143 | |||
1144 | new_palette.depth = *entry_start++; |
||
1145 | entry_size = (new_palette.depth == 8 ? 6 : 10); |
||
1146 | data_length = (slength - (entry_start - chunkdata)); |
||
1147 | |||
1148 | /* integrity-check the data length */ |
||
1149 | if (data_length % entry_size) |
||
1150 | { |
||
1151 | png_free(png_ptr, chunkdata); |
||
1152 | png_warning(png_ptr, "sPLT chunk has bad length"); |
||
1153 | return; |
||
1154 | } |
||
1155 | |||
1156 | new_palette.nentries = data_length / entry_size; |
||
1157 | new_palette.entries = (png_sPLT_entryp)png_malloc( |
||
1158 | png_ptr, new_palette.nentries * sizeof(png_sPLT_entry)); |
||
1159 | |||
1160 | #ifndef PNG_NO_POINTER_INDEXING |
||
1161 | for (i = 0; i < new_palette.nentries; i++) |
||
1162 | { |
||
1163 | png_sPLT_entryp pp = new_palette.entries + i; |
||
1164 | |||
1165 | if (new_palette.depth == 8) |
||
1166 | { |
||
1167 | pp->red = *entry_start++; |
||
1168 | pp->green = *entry_start++; |
||
1169 | pp->blue = *entry_start++; |
||
1170 | pp->alpha = *entry_start++; |
||
1171 | } |
||
1172 | else |
||
1173 | { |
||
1174 | pp->red = png_get_uint_16(entry_start); entry_start += 2; |
||
1175 | pp->green = png_get_uint_16(entry_start); entry_start += 2; |
||
1176 | pp->blue = png_get_uint_16(entry_start); entry_start += 2; |
||
1177 | pp->alpha = png_get_uint_16(entry_start); entry_start += 2; |
||
1178 | } |
||
1179 | pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
||
1180 | } |
||
1181 | #else |
||
1182 | pp = new_palette.entries; |
||
1183 | for (i = 0; i < new_palette.nentries; i++) |
||
1184 | { |
||
1185 | |||
1186 | if (new_palette.depth == 8) |
||
1187 | { |
||
1188 | pp[i].red = *entry_start++; |
||
1189 | pp[i].green = *entry_start++; |
||
1190 | pp[i].blue = *entry_start++; |
||
1191 | pp[i].alpha = *entry_start++; |
||
1192 | } |
||
1193 | else |
||
1194 | { |
||
1195 | pp[i].red = png_get_uint_16(entry_start); entry_start += 2; |
||
1196 | pp[i].green = png_get_uint_16(entry_start); entry_start += 2; |
||
1197 | pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; |
||
1198 | pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; |
||
1199 | } |
||
1200 | pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
||
1201 | } |
||
1202 | #endif |
||
1203 | |||
1204 | /* discard all chunk data except the name and stash that */ |
||
1205 | new_palette.name = (png_charp)chunkdata; |
||
1206 | |||
1207 | png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); |
||
1208 | |||
1209 | png_free(png_ptr, chunkdata); |
||
1210 | png_free(png_ptr, new_palette.entries); |
||
1211 | } |
||
1212 | #endif /* PNG_READ_sPLT_SUPPORTED */ |
||
1213 | |||
1214 | #if defined(PNG_READ_tRNS_SUPPORTED) |
||
1215 | void /* PRIVATE */ |
||
1216 | png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1217 | { |
||
1218 | png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; |
||
1219 | |||
1220 | png_debug(1, "in png_handle_tRNS\n"); |
||
1221 | |||
1222 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1223 | png_error(png_ptr, "Missing IHDR before tRNS"); |
||
1224 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1225 | { |
||
1226 | png_warning(png_ptr, "Invalid tRNS after IDAT"); |
||
1227 | png_crc_finish(png_ptr, length); |
||
1228 | return; |
||
1229 | } |
||
1230 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
||
1231 | { |
||
1232 | png_warning(png_ptr, "Duplicate tRNS chunk"); |
||
1233 | png_crc_finish(png_ptr, length); |
||
1234 | return; |
||
1235 | } |
||
1236 | |||
1237 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
1238 | { |
||
1239 | if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
||
1240 | { |
||
1241 | /* Should be an error, but we can cope with it */ |
||
1242 | png_warning(png_ptr, "Missing PLTE before tRNS"); |
||
1243 | } |
||
1244 | else if (length > (png_uint_32)png_ptr->num_palette) |
||
1245 | { |
||
1246 | png_warning(png_ptr, "Incorrect tRNS chunk length"); |
||
1247 | png_crc_finish(png_ptr, length); |
||
1248 | return; |
||
1249 | } |
||
1250 | if (length == 0) |
||
1251 | { |
||
1252 | png_warning(png_ptr, "Zero length tRNS chunk"); |
||
1253 | png_crc_finish(png_ptr, length); |
||
1254 | return; |
||
1255 | } |
||
1256 | |||
1257 | png_crc_read(png_ptr, readbuf, (png_size_t)length); |
||
1258 | png_ptr->num_trans = (png_uint_16)length; |
||
1259 | } |
||
1260 | else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
||
1261 | { |
||
1262 | png_byte buf[6]; |
||
1263 | |||
1264 | if (length != 6) |
||
1265 | { |
||
1266 | png_warning(png_ptr, "Incorrect tRNS chunk length"); |
||
1267 | png_crc_finish(png_ptr, length); |
||
1268 | return; |
||
1269 | } |
||
1270 | |||
1271 | png_crc_read(png_ptr, buf, (png_size_t)length); |
||
1272 | png_ptr->num_trans = 1; |
||
1273 | png_ptr->trans_values.red = png_get_uint_16(buf); |
||
1274 | png_ptr->trans_values.green = png_get_uint_16(buf + 2); |
||
1275 | png_ptr->trans_values.blue = png_get_uint_16(buf + 4); |
||
1276 | } |
||
1277 | else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
||
1278 | { |
||
1279 | png_byte buf[6]; |
||
1280 | |||
1281 | if (length != 2) |
||
1282 | { |
||
1283 | png_warning(png_ptr, "Incorrect tRNS chunk length"); |
||
1284 | png_crc_finish(png_ptr, length); |
||
1285 | return; |
||
1286 | } |
||
1287 | |||
1288 | png_crc_read(png_ptr, buf, 2); |
||
1289 | png_ptr->num_trans = 1; |
||
1290 | png_ptr->trans_values.gray = png_get_uint_16(buf); |
||
1291 | } |
||
1292 | else |
||
1293 | { |
||
1294 | png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); |
||
1295 | png_crc_finish(png_ptr, length); |
||
1296 | return; |
||
1297 | } |
||
1298 | |||
1299 | if (png_crc_finish(png_ptr, 0)) |
||
1300 | return; |
||
1301 | |||
1302 | png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, |
||
1303 | &(png_ptr->trans_values)); |
||
1304 | } |
||
1305 | #endif |
||
1306 | |||
1307 | #if defined(PNG_READ_bKGD_SUPPORTED) |
||
1308 | void /* PRIVATE */ |
||
1309 | png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1310 | { |
||
1311 | png_size_t truelen; |
||
1312 | png_byte buf[6]; |
||
1313 | |||
1314 | png_debug(1, "in png_handle_bKGD\n"); |
||
1315 | |||
1316 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1317 | png_error(png_ptr, "Missing IHDR before bKGD"); |
||
1318 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1319 | { |
||
1320 | png_warning(png_ptr, "Invalid bKGD after IDAT"); |
||
1321 | png_crc_finish(png_ptr, length); |
||
1322 | return; |
||
1323 | } |
||
1324 | else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
||
1325 | !(png_ptr->mode & PNG_HAVE_PLTE)) |
||
1326 | { |
||
1327 | png_warning(png_ptr, "Missing PLTE before bKGD"); |
||
1328 | png_crc_finish(png_ptr, length); |
||
1329 | return; |
||
1330 | } |
||
1331 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) |
||
1332 | { |
||
1333 | png_warning(png_ptr, "Duplicate bKGD chunk"); |
||
1334 | png_crc_finish(png_ptr, length); |
||
1335 | return; |
||
1336 | } |
||
1337 | |||
1338 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
1339 | truelen = 1; |
||
1340 | else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
||
1341 | truelen = 6; |
||
1342 | else |
||
1343 | truelen = 2; |
||
1344 | |||
1345 | if (length != truelen) |
||
1346 | { |
||
1347 | png_warning(png_ptr, "Incorrect bKGD chunk length"); |
||
1348 | png_crc_finish(png_ptr, length); |
||
1349 | return; |
||
1350 | } |
||
1351 | |||
1352 | png_crc_read(png_ptr, buf, truelen); |
||
1353 | if (png_crc_finish(png_ptr, 0)) |
||
1354 | return; |
||
1355 | |||
1356 | /* We convert the index value into RGB components so that we can allow |
||
1357 | * arbitrary RGB values for background when we have transparency, and |
||
1358 | * so it is easy to determine the RGB values of the background color |
||
1359 | * from the info_ptr struct. */ |
||
1360 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
1361 | { |
||
1362 | png_ptr->background.index = buf[0]; |
||
1363 | if(info_ptr->num_palette) |
||
1364 | { |
||
1365 | if(buf[0] > info_ptr->num_palette) |
||
1366 | { |
||
1367 | png_warning(png_ptr, "Incorrect bKGD chunk index value"); |
||
1368 | return; |
||
1369 | } |
||
1370 | png_ptr->background.red = |
||
1371 | (png_uint_16)png_ptr->palette[buf[0]].red; |
||
1372 | png_ptr->background.green = |
||
1373 | (png_uint_16)png_ptr->palette[buf[0]].green; |
||
1374 | png_ptr->background.blue = |
||
1375 | (png_uint_16)png_ptr->palette[buf[0]].blue; |
||
1376 | } |
||
1377 | } |
||
1378 | else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ |
||
1379 | { |
||
1380 | png_ptr->background.red = |
||
1381 | png_ptr->background.green = |
||
1382 | png_ptr->background.blue = |
||
1383 | png_ptr->background.gray = png_get_uint_16(buf); |
||
1384 | } |
||
1385 | else |
||
1386 | { |
||
1387 | png_ptr->background.red = png_get_uint_16(buf); |
||
1388 | png_ptr->background.green = png_get_uint_16(buf + 2); |
||
1389 | png_ptr->background.blue = png_get_uint_16(buf + 4); |
||
1390 | } |
||
1391 | |||
1392 | png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); |
||
1393 | } |
||
1394 | #endif |
||
1395 | |||
1396 | #if defined(PNG_READ_hIST_SUPPORTED) |
||
1397 | void /* PRIVATE */ |
||
1398 | png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1399 | { |
||
1400 | int num, i; |
||
1401 | png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; |
||
1402 | |||
1403 | png_debug(1, "in png_handle_hIST\n"); |
||
1404 | |||
1405 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1406 | png_error(png_ptr, "Missing IHDR before hIST"); |
||
1407 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1408 | { |
||
1409 | png_warning(png_ptr, "Invalid hIST after IDAT"); |
||
1410 | png_crc_finish(png_ptr, length); |
||
1411 | return; |
||
1412 | } |
||
1413 | else if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
||
1414 | { |
||
1415 | png_warning(png_ptr, "Missing PLTE before hIST"); |
||
1416 | png_crc_finish(png_ptr, length); |
||
1417 | return; |
||
1418 | } |
||
1419 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) |
||
1420 | { |
||
1421 | png_warning(png_ptr, "Duplicate hIST chunk"); |
||
1422 | png_crc_finish(png_ptr, length); |
||
1423 | return; |
||
1424 | } |
||
1425 | |||
1426 | num = (int)length / 2 ; |
||
1427 | if (num != png_ptr->num_palette) |
||
1428 | { |
||
1429 | png_warning(png_ptr, "Incorrect hIST chunk length"); |
||
1430 | png_crc_finish(png_ptr, length); |
||
1431 | return; |
||
1432 | } |
||
1433 | |||
1434 | for (i = 0; i < num; i++) |
||
1435 | { |
||
1436 | png_byte buf[2]; |
||
1437 | |||
1438 | png_crc_read(png_ptr, buf, 2); |
||
1439 | readbuf[i] = png_get_uint_16(buf); |
||
1440 | } |
||
1441 | |||
1442 | if (png_crc_finish(png_ptr, 0)) |
||
1443 | return; |
||
1444 | |||
1445 | png_set_hIST(png_ptr, info_ptr, readbuf); |
||
1446 | } |
||
1447 | #endif |
||
1448 | |||
1449 | #if defined(PNG_READ_pHYs_SUPPORTED) |
||
1450 | void /* PRIVATE */ |
||
1451 | png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1452 | { |
||
1453 | png_byte buf[9]; |
||
1454 | png_uint_32 res_x, res_y; |
||
1455 | int unit_type; |
||
1456 | |||
1457 | png_debug(1, "in png_handle_pHYs\n"); |
||
1458 | |||
1459 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1460 | png_error(png_ptr, "Missing IHDR before pHYs"); |
||
1461 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1462 | { |
||
1463 | png_warning(png_ptr, "Invalid pHYs after IDAT"); |
||
1464 | png_crc_finish(png_ptr, length); |
||
1465 | return; |
||
1466 | } |
||
1467 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
||
1468 | { |
||
1469 | png_warning(png_ptr, "Duplicate pHYs chunk"); |
||
1470 | png_crc_finish(png_ptr, length); |
||
1471 | return; |
||
1472 | } |
||
1473 | |||
1474 | if (length != 9) |
||
1475 | { |
||
1476 | png_warning(png_ptr, "Incorrect pHYs chunk length"); |
||
1477 | png_crc_finish(png_ptr, length); |
||
1478 | return; |
||
1479 | } |
||
1480 | |||
1481 | png_crc_read(png_ptr, buf, 9); |
||
1482 | if (png_crc_finish(png_ptr, 0)) |
||
1483 | return; |
||
1484 | |||
1485 | res_x = png_get_uint_32(buf); |
||
1486 | res_y = png_get_uint_32(buf + 4); |
||
1487 | unit_type = buf[8]; |
||
1488 | png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); |
||
1489 | } |
||
1490 | #endif |
||
1491 | |||
1492 | #if defined(PNG_READ_oFFs_SUPPORTED) |
||
1493 | void /* PRIVATE */ |
||
1494 | png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1495 | { |
||
1496 | png_byte buf[9]; |
||
1497 | png_int_32 offset_x, offset_y; |
||
1498 | int unit_type; |
||
1499 | |||
1500 | png_debug(1, "in png_handle_oFFs\n"); |
||
1501 | |||
1502 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1503 | png_error(png_ptr, "Missing IHDR before oFFs"); |
||
1504 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1505 | { |
||
1506 | png_warning(png_ptr, "Invalid oFFs after IDAT"); |
||
1507 | png_crc_finish(png_ptr, length); |
||
1508 | return; |
||
1509 | } |
||
1510 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
||
1511 | { |
||
1512 | png_warning(png_ptr, "Duplicate oFFs chunk"); |
||
1513 | png_crc_finish(png_ptr, length); |
||
1514 | return; |
||
1515 | } |
||
1516 | |||
1517 | if (length != 9) |
||
1518 | { |
||
1519 | png_warning(png_ptr, "Incorrect oFFs chunk length"); |
||
1520 | png_crc_finish(png_ptr, length); |
||
1521 | return; |
||
1522 | } |
||
1523 | |||
1524 | png_crc_read(png_ptr, buf, 9); |
||
1525 | if (png_crc_finish(png_ptr, 0)) |
||
1526 | return; |
||
1527 | |||
1528 | offset_x = png_get_int_32(buf); |
||
1529 | offset_y = png_get_int_32(buf + 4); |
||
1530 | unit_type = buf[8]; |
||
1531 | png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); |
||
1532 | } |
||
1533 | #endif |
||
1534 | |||
1535 | #if defined(PNG_READ_pCAL_SUPPORTED) |
||
1536 | /* read the pCAL chunk (described in the PNG Extensions document) */ |
||
1537 | void /* PRIVATE */ |
||
1538 | png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1539 | { |
||
1540 | png_charp purpose; |
||
1541 | png_int_32 X0, X1; |
||
1542 | png_byte type, nparams; |
||
1543 | png_charp buf, units, endptr; |
||
1544 | png_charpp params; |
||
1545 | png_size_t slength; |
||
1546 | int i; |
||
1547 | |||
1548 | png_debug(1, "in png_handle_pCAL\n"); |
||
1549 | |||
1550 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1551 | png_error(png_ptr, "Missing IHDR before pCAL"); |
||
1552 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1553 | { |
||
1554 | png_warning(png_ptr, "Invalid pCAL after IDAT"); |
||
1555 | png_crc_finish(png_ptr, length); |
||
1556 | return; |
||
1557 | } |
||
1558 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) |
||
1559 | { |
||
1560 | png_warning(png_ptr, "Duplicate pCAL chunk"); |
||
1561 | png_crc_finish(png_ptr, length); |
||
1562 | return; |
||
1563 | } |
||
1564 | |||
1565 | png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n", |
||
1566 | length + 1); |
||
1567 | purpose = (png_charp)png_malloc_warn(png_ptr, length + 1); |
||
1568 | if (purpose == NULL) |
||
1569 | { |
||
1570 | png_warning(png_ptr, "No memory for pCAL purpose."); |
||
1571 | return; |
||
1572 | } |
||
1573 | slength = (png_size_t)length; |
||
1574 | png_crc_read(png_ptr, (png_bytep)purpose, slength); |
||
1575 | |||
1576 | if (png_crc_finish(png_ptr, 0)) |
||
1577 | { |
||
1578 | png_free(png_ptr, purpose); |
||
1579 | return; |
||
1580 | } |
||
1581 | |||
1582 | purpose[slength] = 0x00; /* null terminate the last string */ |
||
1583 | |||
1584 | png_debug(3, "Finding end of pCAL purpose string\n"); |
||
1585 | for (buf = purpose; *buf; buf++) |
||
1586 | /* empty loop */ ; |
||
1587 | |||
1588 | endptr = purpose + slength; |
||
1589 | |||
1590 | /* We need to have at least 12 bytes after the purpose string |
||
1591 | in order to get the parameter information. */ |
||
1592 | if (endptr <= buf + 12) |
||
1593 | { |
||
1594 | png_warning(png_ptr, "Invalid pCAL data"); |
||
1595 | png_free(png_ptr, purpose); |
||
1596 | return; |
||
1597 | } |
||
1598 | |||
1599 | png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n"); |
||
1600 | X0 = png_get_int_32((png_bytep)buf+1); |
||
1601 | X1 = png_get_int_32((png_bytep)buf+5); |
||
1602 | type = buf[9]; |
||
1603 | nparams = buf[10]; |
||
1604 | units = buf + 11; |
||
1605 | |||
1606 | png_debug(3, "Checking pCAL equation type and number of parameters\n"); |
||
1607 | /* Check that we have the right number of parameters for known |
||
1608 | equation types. */ |
||
1609 | if ((type == PNG_EQUATION_LINEAR && nparams != 2) || |
||
1610 | (type == PNG_EQUATION_BASE_E && nparams != 3) || |
||
1611 | (type == PNG_EQUATION_ARBITRARY && nparams != 3) || |
||
1612 | (type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) |
||
1613 | { |
||
1614 | png_warning(png_ptr, "Invalid pCAL parameters for equation type"); |
||
1615 | png_free(png_ptr, purpose); |
||
1616 | return; |
||
1617 | } |
||
1618 | else if (type >= PNG_EQUATION_LAST) |
||
1619 | { |
||
1620 | png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
||
1621 | } |
||
1622 | |||
1623 | for (buf = units; *buf; buf++) |
||
1624 | /* Empty loop to move past the units string. */ ; |
||
1625 | |||
1626 | png_debug(3, "Allocating pCAL parameters array\n"); |
||
1627 | params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams |
||
1628 | *sizeof(png_charp))) ; |
||
1629 | if (params == NULL) |
||
1630 | { |
||
1631 | png_free(png_ptr, purpose); |
||
1632 | png_warning(png_ptr, "No memory for pCAL params."); |
||
1633 | return; |
||
1634 | } |
||
1635 | |||
1636 | /* Get pointers to the start of each parameter string. */ |
||
1637 | for (i = 0; i < (int)nparams; i++) |
||
1638 | { |
||
1639 | buf++; /* Skip the null string terminator from previous parameter. */ |
||
1640 | |||
1641 | png_debug1(3, "Reading pCAL parameter %d\n", i); |
||
1642 | for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++) |
||
1643 | /* Empty loop to move past each parameter string */ ; |
||
1644 | |||
1645 | /* Make sure we haven't run out of data yet */ |
||
1646 | if (buf > endptr) |
||
1647 | { |
||
1648 | png_warning(png_ptr, "Invalid pCAL data"); |
||
1649 | png_free(png_ptr, purpose); |
||
1650 | png_free(png_ptr, params); |
||
1651 | return; |
||
1652 | } |
||
1653 | } |
||
1654 | |||
1655 | png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams, |
||
1656 | units, params); |
||
1657 | |||
1658 | png_free(png_ptr, purpose); |
||
1659 | png_free(png_ptr, params); |
||
1660 | } |
||
1661 | #endif |
||
1662 | |||
1663 | #if defined(PNG_READ_sCAL_SUPPORTED) |
||
1664 | /* read the sCAL chunk */ |
||
1665 | void /* PRIVATE */ |
||
1666 | png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1667 | { |
||
1668 | png_charp buffer, ep; |
||
1669 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
1670 | double width, height; |
||
1671 | png_charp vp; |
||
1672 | #else |
||
1673 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
1674 | png_charp swidth, sheight; |
||
1675 | #endif |
||
1676 | #endif |
||
1677 | png_size_t slength; |
||
1678 | |||
1679 | png_debug(1, "in png_handle_sCAL\n"); |
||
1680 | |||
1681 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1682 | png_error(png_ptr, "Missing IHDR before sCAL"); |
||
1683 | else if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1684 | { |
||
1685 | png_warning(png_ptr, "Invalid sCAL after IDAT"); |
||
1686 | png_crc_finish(png_ptr, length); |
||
1687 | return; |
||
1688 | } |
||
1689 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) |
||
1690 | { |
||
1691 | png_warning(png_ptr, "Duplicate sCAL chunk"); |
||
1692 | png_crc_finish(png_ptr, length); |
||
1693 | return; |
||
1694 | } |
||
1695 | |||
1696 | png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n", |
||
1697 | length + 1); |
||
1698 | buffer = (png_charp)png_malloc_warn(png_ptr, length + 1); |
||
1699 | if (buffer == NULL) |
||
1700 | { |
||
1701 | png_warning(png_ptr, "Out of memory while processing sCAL chunk"); |
||
1702 | return; |
||
1703 | } |
||
1704 | slength = (png_size_t)length; |
||
1705 | png_crc_read(png_ptr, (png_bytep)buffer, slength); |
||
1706 | |||
1707 | if (png_crc_finish(png_ptr, 0)) |
||
1708 | { |
||
1709 | png_free(png_ptr, buffer); |
||
1710 | return; |
||
1711 | } |
||
1712 | |||
1713 | buffer[slength] = 0x00; /* null terminate the last string */ |
||
1714 | |||
1715 | ep = buffer + 1; /* skip unit byte */ |
||
1716 | |||
1717 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
1718 | width = strtod(ep, &vp); |
||
1719 | if (*vp) |
||
1720 | { |
||
1721 | png_warning(png_ptr, "malformed width string in sCAL chunk"); |
||
1722 | return; |
||
1723 | } |
||
1724 | #else |
||
1725 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
1726 | swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
||
1727 | if (swidth == NULL) |
||
1728 | { |
||
1729 | png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); |
||
1730 | return; |
||
1731 | } |
||
1732 | png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); |
||
1733 | #endif |
||
1734 | #endif |
||
1735 | |||
1736 | for (ep = buffer; *ep; ep++) |
||
1737 | /* empty loop */ ; |
||
1738 | ep++; |
||
1739 | |||
1740 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
1741 | height = strtod(ep, &vp); |
||
1742 | if (*vp) |
||
1743 | { |
||
1744 | png_warning(png_ptr, "malformed height string in sCAL chunk"); |
||
1745 | return; |
||
1746 | } |
||
1747 | #else |
||
1748 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
1749 | sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
||
1750 | if (swidth == NULL) |
||
1751 | { |
||
1752 | png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); |
||
1753 | return; |
||
1754 | } |
||
1755 | png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); |
||
1756 | #endif |
||
1757 | #endif |
||
1758 | |||
1759 | if (buffer + slength < ep |
||
1760 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
1761 | || width <= 0. || height <= 0. |
||
1762 | #endif |
||
1763 | ) |
||
1764 | { |
||
1765 | png_warning(png_ptr, "Invalid sCAL data"); |
||
1766 | png_free(png_ptr, buffer); |
||
1767 | #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
||
1768 | png_free(png_ptr, swidth); |
||
1769 | png_free(png_ptr, sheight); |
||
1770 | #endif |
||
1771 | return; |
||
1772 | } |
||
1773 | |||
1774 | |||
1775 | #ifdef PNG_FLOATING_POINT_SUPPORTED |
||
1776 | png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height); |
||
1777 | #else |
||
1778 | #ifdef PNG_FIXED_POINT_SUPPORTED |
||
1779 | png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight); |
||
1780 | #endif |
||
1781 | #endif |
||
1782 | |||
1783 | png_free(png_ptr, buffer); |
||
1784 | #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
||
1785 | png_free(png_ptr, swidth); |
||
1786 | png_free(png_ptr, sheight); |
||
1787 | #endif |
||
1788 | } |
||
1789 | #endif |
||
1790 | |||
1791 | #if defined(PNG_READ_tIME_SUPPORTED) |
||
1792 | void /* PRIVATE */ |
||
1793 | png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1794 | { |
||
1795 | png_byte buf[7]; |
||
1796 | png_time mod_time; |
||
1797 | |||
1798 | png_debug(1, "in png_handle_tIME\n"); |
||
1799 | |||
1800 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1801 | png_error(png_ptr, "Out of place tIME chunk"); |
||
1802 | else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) |
||
1803 | { |
||
1804 | png_warning(png_ptr, "Duplicate tIME chunk"); |
||
1805 | png_crc_finish(png_ptr, length); |
||
1806 | return; |
||
1807 | } |
||
1808 | |||
1809 | if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1810 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
1811 | |||
1812 | if (length != 7) |
||
1813 | { |
||
1814 | png_warning(png_ptr, "Incorrect tIME chunk length"); |
||
1815 | png_crc_finish(png_ptr, length); |
||
1816 | return; |
||
1817 | } |
||
1818 | |||
1819 | png_crc_read(png_ptr, buf, 7); |
||
1820 | if (png_crc_finish(png_ptr, 0)) |
||
1821 | return; |
||
1822 | |||
1823 | mod_time.second = buf[6]; |
||
1824 | mod_time.minute = buf[5]; |
||
1825 | mod_time.hour = buf[4]; |
||
1826 | mod_time.day = buf[3]; |
||
1827 | mod_time.month = buf[2]; |
||
1828 | mod_time.year = png_get_uint_16(buf); |
||
1829 | |||
1830 | png_set_tIME(png_ptr, info_ptr, &mod_time); |
||
1831 | } |
||
1832 | #endif |
||
1833 | |||
1834 | #if defined(PNG_READ_tEXt_SUPPORTED) |
||
1835 | /* Note: this does not properly handle chunks that are > 64K under DOS */ |
||
1836 | void /* PRIVATE */ |
||
1837 | png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1838 | { |
||
1839 | png_textp text_ptr; |
||
1840 | png_charp key; |
||
1841 | png_charp text; |
||
1842 | png_uint_32 skip = 0; |
||
1843 | png_size_t slength; |
||
1844 | int ret; |
||
1845 | |||
1846 | png_debug(1, "in png_handle_tEXt\n"); |
||
1847 | |||
1848 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1849 | png_error(png_ptr, "Missing IHDR before tEXt"); |
||
1850 | |||
1851 | if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1852 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
1853 | |||
1854 | #ifdef PNG_MAX_MALLOC_64K |
||
1855 | if (length > (png_uint_32)65535L) |
||
1856 | { |
||
1857 | png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
||
1858 | skip = length - (png_uint_32)65535L; |
||
1859 | length = (png_uint_32)65535L; |
||
1860 | } |
||
1861 | #endif |
||
1862 | |||
1863 | key = (png_charp)png_malloc_warn(png_ptr, length + 1); |
||
1864 | if (key == NULL) |
||
1865 | { |
||
1866 | png_warning(png_ptr, "No memory to process text chunk."); |
||
1867 | return; |
||
1868 | } |
||
1869 | slength = (png_size_t)length; |
||
1870 | png_crc_read(png_ptr, (png_bytep)key, slength); |
||
1871 | |||
1872 | if (png_crc_finish(png_ptr, skip)) |
||
1873 | { |
||
1874 | png_free(png_ptr, key); |
||
1875 | return; |
||
1876 | } |
||
1877 | |||
1878 | key[slength] = 0x00; |
||
1879 | |||
1880 | for (text = key; *text; text++) |
||
1881 | /* empty loop to find end of key */ ; |
||
1882 | |||
1883 | if (text != key + slength) |
||
1884 | text++; |
||
1885 | |||
1886 | text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
||
1887 | if (text_ptr == NULL) |
||
1888 | { |
||
1889 | png_warning(png_ptr, "Not enough memory to process text chunk."); |
||
1890 | png_free(png_ptr, key); |
||
1891 | return; |
||
1892 | } |
||
1893 | text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
||
1894 | text_ptr->key = key; |
||
1895 | #ifdef PNG_iTXt_SUPPORTED |
||
1896 | text_ptr->lang = NULL; |
||
1897 | text_ptr->lang_key = NULL; |
||
1898 | text_ptr->itxt_length = 0; |
||
1899 | #endif |
||
1900 | text_ptr->text = text; |
||
1901 | text_ptr->text_length = png_strlen(text); |
||
1902 | |||
1903 | ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
||
1904 | |||
1905 | png_free(png_ptr, key); |
||
1906 | png_free(png_ptr, text_ptr); |
||
1907 | if (ret) |
||
1908 | png_warning(png_ptr, "Insufficient memory to process text chunk."); |
||
1909 | } |
||
1910 | #endif |
||
1911 | |||
1912 | #if defined(PNG_READ_zTXt_SUPPORTED) |
||
1913 | /* note: this does not correctly handle chunks that are > 64K under DOS */ |
||
1914 | void /* PRIVATE */ |
||
1915 | png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
1916 | { |
||
1917 | png_textp text_ptr; |
||
1918 | png_charp chunkdata; |
||
1919 | png_charp text; |
||
1920 | int comp_type; |
||
1921 | int ret; |
||
1922 | png_size_t slength, prefix_len, data_len; |
||
1923 | |||
1924 | png_debug(1, "in png_handle_zTXt\n"); |
||
1925 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
1926 | png_error(png_ptr, "Missing IHDR before zTXt"); |
||
1927 | |||
1928 | if (png_ptr->mode & PNG_HAVE_IDAT) |
||
1929 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
1930 | |||
1931 | #ifdef PNG_MAX_MALLOC_64K |
||
1932 | /* We will no doubt have problems with chunks even half this size, but |
||
1933 | there is no hard and fast rule to tell us where to stop. */ |
||
1934 | if (length > (png_uint_32)65535L) |
||
1935 | { |
||
1936 | png_warning(png_ptr,"zTXt chunk too large to fit in memory"); |
||
1937 | png_crc_finish(png_ptr, length); |
||
1938 | return; |
||
1939 | } |
||
1940 | #endif |
||
1941 | |||
1942 | chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
||
1943 | if (chunkdata == NULL) |
||
1944 | { |
||
1945 | png_warning(png_ptr,"Out of memory processing zTXt chunk."); |
||
1946 | return; |
||
1947 | } |
||
1948 | slength = (png_size_t)length; |
||
1949 | png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
||
1950 | if (png_crc_finish(png_ptr, 0)) |
||
1951 | { |
||
1952 | png_free(png_ptr, chunkdata); |
||
1953 | return; |
||
1954 | } |
||
1955 | |||
1956 | chunkdata[slength] = 0x00; |
||
1957 | |||
1958 | for (text = chunkdata; *text; text++) |
||
1959 | /* empty loop */ ; |
||
1960 | |||
1961 | /* zTXt must have some text after the chunkdataword */ |
||
1962 | if (text == chunkdata + slength) |
||
1963 | { |
||
1964 | comp_type = PNG_TEXT_COMPRESSION_NONE; |
||
1965 | png_warning(png_ptr, "Zero length zTXt chunk"); |
||
1966 | } |
||
1967 | else |
||
1968 | { |
||
1969 | comp_type = *(++text); |
||
1970 | if (comp_type != PNG_TEXT_COMPRESSION_zTXt) |
||
1971 | { |
||
1972 | png_warning(png_ptr, "Unknown compression type in zTXt chunk"); |
||
1973 | comp_type = PNG_TEXT_COMPRESSION_zTXt; |
||
1974 | } |
||
1975 | text++; /* skip the compression_method byte */ |
||
1976 | } |
||
1977 | prefix_len = text - chunkdata; |
||
1978 | |||
1979 | chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata, |
||
1980 | (png_size_t)length, prefix_len, &data_len); |
||
1981 | |||
1982 | text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
||
1983 | if (text_ptr == NULL) |
||
1984 | { |
||
1985 | png_warning(png_ptr,"Not enough memory to process zTXt chunk."); |
||
1986 | png_free(png_ptr, chunkdata); |
||
1987 | return; |
||
1988 | } |
||
1989 | text_ptr->compression = comp_type; |
||
1990 | text_ptr->key = chunkdata; |
||
1991 | #ifdef PNG_iTXt_SUPPORTED |
||
1992 | text_ptr->lang = NULL; |
||
1993 | text_ptr->lang_key = NULL; |
||
1994 | text_ptr->itxt_length = 0; |
||
1995 | #endif |
||
1996 | text_ptr->text = chunkdata + prefix_len; |
||
1997 | text_ptr->text_length = data_len; |
||
1998 | |||
1999 | ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
||
2000 | |||
2001 | png_free(png_ptr, text_ptr); |
||
2002 | png_free(png_ptr, chunkdata); |
||
2003 | if (ret) |
||
2004 | png_error(png_ptr, "Insufficient memory to store zTXt chunk."); |
||
2005 | } |
||
2006 | #endif |
||
2007 | |||
2008 | #if defined(PNG_READ_iTXt_SUPPORTED) |
||
2009 | /* note: this does not correctly handle chunks that are > 64K under DOS */ |
||
2010 | void /* PRIVATE */ |
||
2011 | png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
2012 | { |
||
2013 | png_textp text_ptr; |
||
2014 | png_charp chunkdata; |
||
2015 | png_charp key, lang, text, lang_key; |
||
2016 | int comp_flag; |
||
2017 | int comp_type = 0; |
||
2018 | int ret; |
||
2019 | png_size_t slength, prefix_len, data_len; |
||
2020 | |||
2021 | png_debug(1, "in png_handle_iTXt\n"); |
||
2022 | |||
2023 | if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
||
2024 | png_error(png_ptr, "Missing IHDR before iTXt"); |
||
2025 | |||
2026 | if (png_ptr->mode & PNG_HAVE_IDAT) |
||
2027 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
2028 | |||
2029 | #ifdef PNG_MAX_MALLOC_64K |
||
2030 | /* We will no doubt have problems with chunks even half this size, but |
||
2031 | there is no hard and fast rule to tell us where to stop. */ |
||
2032 | if (length > (png_uint_32)65535L) |
||
2033 | { |
||
2034 | png_warning(png_ptr,"iTXt chunk too large to fit in memory"); |
||
2035 | png_crc_finish(png_ptr, length); |
||
2036 | return; |
||
2037 | } |
||
2038 | #endif |
||
2039 | |||
2040 | chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
||
2041 | if (chunkdata == NULL) |
||
2042 | { |
||
2043 | png_warning(png_ptr, "No memory to process iTXt chunk."); |
||
2044 | return; |
||
2045 | } |
||
2046 | slength = (png_size_t)length; |
||
2047 | png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
||
2048 | if (png_crc_finish(png_ptr, 0)) |
||
2049 | { |
||
2050 | png_free(png_ptr, chunkdata); |
||
2051 | return; |
||
2052 | } |
||
2053 | |||
2054 | chunkdata[slength] = 0x00; |
||
2055 | |||
2056 | for (lang = chunkdata; *lang; lang++) |
||
2057 | /* empty loop */ ; |
||
2058 | lang++; /* skip NUL separator */ |
||
2059 | |||
2060 | /* iTXt must have a language tag (possibly empty), two compression bytes, |
||
2061 | translated keyword (possibly empty), and possibly some text after the |
||
2062 | keyword */ |
||
2063 | |||
2064 | if (lang >= chunkdata + slength) |
||
2065 | { |
||
2066 | comp_flag = PNG_TEXT_COMPRESSION_NONE; |
||
2067 | png_warning(png_ptr, "Zero length iTXt chunk"); |
||
2068 | } |
||
2069 | else |
||
2070 | { |
||
2071 | comp_flag = *lang++; |
||
2072 | comp_type = *lang++; |
||
2073 | } |
||
2074 | |||
2075 | for (lang_key = lang; *lang_key; lang_key++) |
||
2076 | /* empty loop */ ; |
||
2077 | lang_key++; /* skip NUL separator */ |
||
2078 | |||
2079 | for (text = lang_key; *text; text++) |
||
2080 | /* empty loop */ ; |
||
2081 | text++; /* skip NUL separator */ |
||
2082 | |||
2083 | prefix_len = text - chunkdata; |
||
2084 | |||
2085 | key=chunkdata; |
||
2086 | if (comp_flag) |
||
2087 | chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata, |
||
2088 | (size_t)length, prefix_len, &data_len); |
||
2089 | else |
||
2090 | data_len=png_strlen(chunkdata + prefix_len); |
||
2091 | text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
||
2092 | if (text_ptr == NULL) |
||
2093 | { |
||
2094 | png_warning(png_ptr,"Not enough memory to process iTXt chunk."); |
||
2095 | png_free(png_ptr, chunkdata); |
||
2096 | return; |
||
2097 | } |
||
2098 | text_ptr->compression = (int)comp_flag + 1; |
||
2099 | text_ptr->lang_key = chunkdata+(lang_key-key); |
||
2100 | text_ptr->lang = chunkdata+(lang-key); |
||
2101 | text_ptr->itxt_length = data_len; |
||
2102 | text_ptr->text_length = 0; |
||
2103 | text_ptr->key = chunkdata; |
||
2104 | text_ptr->text = chunkdata + prefix_len; |
||
2105 | |||
2106 | ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
||
2107 | |||
2108 | png_free(png_ptr, text_ptr); |
||
2109 | png_free(png_ptr, chunkdata); |
||
2110 | if (ret) |
||
2111 | png_error(png_ptr, "Insufficient memory to store iTXt chunk."); |
||
2112 | } |
||
2113 | #endif |
||
2114 | |||
2115 | /* This function is called when we haven't found a handler for a |
||
2116 | chunk. If there isn't a problem with the chunk itself (ie bad |
||
2117 | chunk name, CRC, or a critical chunk), the chunk is silently ignored |
||
2118 | -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which |
||
2119 | case it will be saved away to be written out later. */ |
||
2120 | void /* PRIVATE */ |
||
2121 | png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
||
2122 | { |
||
2123 | png_uint_32 skip = 0; |
||
2124 | |||
2125 | png_debug(1, "in png_handle_unknown\n"); |
||
2126 | |||
2127 | if (png_ptr->mode & PNG_HAVE_IDAT) |
||
2128 | { |
||
2129 | #ifdef PNG_USE_LOCAL_ARRAYS |
||
2130 | PNG_IDAT; |
||
2131 | #endif |
||
2132 | if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ |
||
2133 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
2134 | } |
||
2135 | |||
2136 | png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
||
2137 | |||
2138 | if (!(png_ptr->chunk_name[0] & 0x20)) |
||
2139 | { |
||
2140 | #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
||
2141 | if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
||
2142 | HANDLE_CHUNK_ALWAYS |
||
2143 | #if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
||
2144 | && png_ptr->read_user_chunk_fn == NULL |
||
2145 | #endif |
||
2146 | ) |
||
2147 | #endif |
||
2148 | png_chunk_error(png_ptr, "unknown critical chunk"); |
||
2149 | } |
||
2150 | |||
2151 | #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
||
2152 | if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
||
2153 | { |
||
2154 | png_unknown_chunk chunk; |
||
2155 | |||
2156 | #ifdef PNG_MAX_MALLOC_64K |
||
2157 | if (length > (png_uint_32)65535L) |
||
2158 | { |
||
2159 | png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
||
2160 | skip = length - (png_uint_32)65535L; |
||
2161 | length = (png_uint_32)65535L; |
||
2162 | } |
||
2163 | #endif |
||
2164 | png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); |
||
2165 | chunk.data = (png_bytep)png_malloc(png_ptr, length); |
||
2166 | chunk.size = (png_size_t)length; |
||
2167 | png_crc_read(png_ptr, (png_bytep)chunk.data, length); |
||
2168 | #if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
||
2169 | if(png_ptr->read_user_chunk_fn != NULL) |
||
2170 | { |
||
2171 | /* callback to user unknown chunk handler */ |
||
2172 | if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) |
||
2173 | { |
||
2174 | if (!(png_ptr->chunk_name[0] & 0x20)) |
||
2175 | if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
||
2176 | HANDLE_CHUNK_ALWAYS) |
||
2177 | { |
||
2178 | png_free(png_ptr, chunk.data); |
||
2179 | png_chunk_error(png_ptr, "unknown critical chunk"); |
||
2180 | } |
||
2181 | png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
||
2182 | } |
||
2183 | } |
||
2184 | else |
||
2185 | #endif |
||
2186 | png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
||
2187 | png_free(png_ptr, chunk.data); |
||
2188 | } |
||
2189 | else |
||
2190 | #endif |
||
2191 | skip = length; |
||
2192 | |||
2193 | png_crc_finish(png_ptr, skip); |
||
2194 | |||
2195 | #if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
||
2196 | info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
||
2197 | #endif |
||
2198 | } |
||
2199 | |||
2200 | /* This function is called to verify that a chunk name is valid. |
||
2201 | This function can't have the "critical chunk check" incorporated |
||
2202 | into it, since in the future we will need to be able to call user |
||
2203 | functions to handle unknown critical chunks after we check that |
||
2204 | the chunk name itself is valid. */ |
||
2205 | |||
2206 | #define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97)) |
||
2207 | |||
2208 | void /* PRIVATE */ |
||
2209 | png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) |
||
2210 | { |
||
2211 | png_debug(1, "in png_check_chunk_name\n"); |
||
2212 | if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || |
||
2213 | isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) |
||
2214 | { |
||
2215 | png_chunk_error(png_ptr, "invalid chunk type"); |
||
2216 | } |
||
2217 | } |
||
2218 | |||
2219 | /* Combines the row recently read in with the existing pixels in the |
||
2220 | row. This routine takes care of alpha and transparency if requested. |
||
2221 | This routine also handles the two methods of progressive display |
||
2222 | of interlaced images, depending on the mask value. |
||
2223 | The mask value describes which pixels are to be combined with |
||
2224 | the row. The pattern always repeats every 8 pixels, so just 8 |
||
2225 | bits are needed. A one indicates the pixel is to be combined, |
||
2226 | a zero indicates the pixel is to be skipped. This is in addition |
||
2227 | to any alpha or transparency value associated with the pixel. If |
||
2228 | you want all pixels to be combined, pass 0xff (255) in mask. */ |
||
2229 | #ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
||
2230 | void /* PRIVATE */ |
||
2231 | png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
||
2232 | { |
||
2233 | png_debug(1,"in png_combine_row\n"); |
||
2234 | if (mask == 0xff) |
||
2235 | { |
||
2236 | png_memcpy(row, png_ptr->row_buf + 1, |
||
2237 | (png_size_t)((png_ptr->width * |
||
2238 | png_ptr->row_info.pixel_depth + 7) >> 3)); |
||
2239 | } |
||
2240 | else |
||
2241 | { |
||
2242 | switch (png_ptr->row_info.pixel_depth) |
||
2243 | { |
||
2244 | case 1: |
||
2245 | { |
||
2246 | png_bytep sp = png_ptr->row_buf + 1; |
||
2247 | png_bytep dp = row; |
||
2248 | int s_inc, s_start, s_end; |
||
2249 | int m = 0x80; |
||
2250 | int shift; |
||
2251 | png_uint_32 i; |
||
2252 | png_uint_32 row_width = png_ptr->width; |
||
2253 | |||
2254 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2255 | if (png_ptr->transformations & PNG_PACKSWAP) |
||
2256 | { |
||
2257 | s_start = 0; |
||
2258 | s_end = 7; |
||
2259 | s_inc = 1; |
||
2260 | } |
||
2261 | else |
||
2262 | #endif |
||
2263 | { |
||
2264 | s_start = 7; |
||
2265 | s_end = 0; |
||
2266 | s_inc = -1; |
||
2267 | } |
||
2268 | |||
2269 | shift = s_start; |
||
2270 | |||
2271 | for (i = 0; i < row_width; i++) |
||
2272 | { |
||
2273 | if (m & mask) |
||
2274 | { |
||
2275 | int value; |
||
2276 | |||
2277 | value = (*sp >> shift) & 0x01; |
||
2278 | *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
||
2279 | *dp |= (png_byte)(value << shift); |
||
2280 | } |
||
2281 | |||
2282 | if (shift == s_end) |
||
2283 | { |
||
2284 | shift = s_start; |
||
2285 | sp++; |
||
2286 | dp++; |
||
2287 | } |
||
2288 | else |
||
2289 | shift += s_inc; |
||
2290 | |||
2291 | if (m == 1) |
||
2292 | m = 0x80; |
||
2293 | else |
||
2294 | m >>= 1; |
||
2295 | } |
||
2296 | break; |
||
2297 | } |
||
2298 | case 2: |
||
2299 | { |
||
2300 | png_bytep sp = png_ptr->row_buf + 1; |
||
2301 | png_bytep dp = row; |
||
2302 | int s_start, s_end, s_inc; |
||
2303 | int m = 0x80; |
||
2304 | int shift; |
||
2305 | png_uint_32 i; |
||
2306 | png_uint_32 row_width = png_ptr->width; |
||
2307 | int value; |
||
2308 | |||
2309 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2310 | if (png_ptr->transformations & PNG_PACKSWAP) |
||
2311 | { |
||
2312 | s_start = 0; |
||
2313 | s_end = 6; |
||
2314 | s_inc = 2; |
||
2315 | } |
||
2316 | else |
||
2317 | #endif |
||
2318 | { |
||
2319 | s_start = 6; |
||
2320 | s_end = 0; |
||
2321 | s_inc = -2; |
||
2322 | } |
||
2323 | |||
2324 | shift = s_start; |
||
2325 | |||
2326 | for (i = 0; i < row_width; i++) |
||
2327 | { |
||
2328 | if (m & mask) |
||
2329 | { |
||
2330 | value = (*sp >> shift) & 0x03; |
||
2331 | *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
||
2332 | *dp |= (png_byte)(value << shift); |
||
2333 | } |
||
2334 | |||
2335 | if (shift == s_end) |
||
2336 | { |
||
2337 | shift = s_start; |
||
2338 | sp++; |
||
2339 | dp++; |
||
2340 | } |
||
2341 | else |
||
2342 | shift += s_inc; |
||
2343 | if (m == 1) |
||
2344 | m = 0x80; |
||
2345 | else |
||
2346 | m >>= 1; |
||
2347 | } |
||
2348 | break; |
||
2349 | } |
||
2350 | case 4: |
||
2351 | { |
||
2352 | png_bytep sp = png_ptr->row_buf + 1; |
||
2353 | png_bytep dp = row; |
||
2354 | int s_start, s_end, s_inc; |
||
2355 | int m = 0x80; |
||
2356 | int shift; |
||
2357 | png_uint_32 i; |
||
2358 | png_uint_32 row_width = png_ptr->width; |
||
2359 | int value; |
||
2360 | |||
2361 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2362 | if (png_ptr->transformations & PNG_PACKSWAP) |
||
2363 | { |
||
2364 | s_start = 0; |
||
2365 | s_end = 4; |
||
2366 | s_inc = 4; |
||
2367 | } |
||
2368 | else |
||
2369 | #endif |
||
2370 | { |
||
2371 | s_start = 4; |
||
2372 | s_end = 0; |
||
2373 | s_inc = -4; |
||
2374 | } |
||
2375 | shift = s_start; |
||
2376 | |||
2377 | for (i = 0; i < row_width; i++) |
||
2378 | { |
||
2379 | if (m & mask) |
||
2380 | { |
||
2381 | value = (*sp >> shift) & 0xf; |
||
2382 | *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
||
2383 | *dp |= (png_byte)(value << shift); |
||
2384 | } |
||
2385 | |||
2386 | if (shift == s_end) |
||
2387 | { |
||
2388 | shift = s_start; |
||
2389 | sp++; |
||
2390 | dp++; |
||
2391 | } |
||
2392 | else |
||
2393 | shift += s_inc; |
||
2394 | if (m == 1) |
||
2395 | m = 0x80; |
||
2396 | else |
||
2397 | m >>= 1; |
||
2398 | } |
||
2399 | break; |
||
2400 | } |
||
2401 | default: |
||
2402 | { |
||
2403 | png_bytep sp = png_ptr->row_buf + 1; |
||
2404 | png_bytep dp = row; |
||
2405 | png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
||
2406 | png_uint_32 i; |
||
2407 | png_uint_32 row_width = png_ptr->width; |
||
2408 | png_byte m = 0x80; |
||
2409 | |||
2410 | |||
2411 | for (i = 0; i < row_width; i++) |
||
2412 | { |
||
2413 | if (m & mask) |
||
2414 | { |
||
2415 | png_memcpy(dp, sp, pixel_bytes); |
||
2416 | } |
||
2417 | |||
2418 | sp += pixel_bytes; |
||
2419 | dp += pixel_bytes; |
||
2420 | |||
2421 | if (m == 1) |
||
2422 | m = 0x80; |
||
2423 | else |
||
2424 | m >>= 1; |
||
2425 | } |
||
2426 | break; |
||
2427 | } |
||
2428 | } |
||
2429 | } |
||
2430 | } |
||
2431 | #endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */ |
||
2432 | |||
2433 | #ifdef PNG_READ_INTERLACING_SUPPORTED |
||
2434 | #ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE /* else in pngvcrd.c, pnggccrd.c */ |
||
2435 | /* OLD pre-1.0.9 interface: |
||
2436 | void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, |
||
2437 | png_uint_32 transformations) |
||
2438 | */ |
||
2439 | void /* PRIVATE */ |
||
2440 | png_do_read_interlace(png_structp png_ptr) |
||
2441 | { |
||
2442 | png_row_infop row_info = &(png_ptr->row_info); |
||
2443 | png_bytep row = png_ptr->row_buf + 1; |
||
2444 | int pass = png_ptr->pass; |
||
2445 | png_uint_32 transformations = png_ptr->transformations; |
||
2446 | #ifdef PNG_USE_LOCAL_ARRAYS |
||
2447 | /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
||
2448 | /* offset to next interlace block */ |
||
2449 | const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
||
2450 | #endif |
||
2451 | |||
2452 | png_debug(1,"in png_do_read_interlace (stock C version)\n"); |
||
2453 | if (row != NULL && row_info != NULL) |
||
2454 | { |
||
2455 | png_uint_32 final_width; |
||
2456 | |||
2457 | final_width = row_info->width * png_pass_inc[pass]; |
||
2458 | |||
2459 | switch (row_info->pixel_depth) |
||
2460 | { |
||
2461 | case 1: |
||
2462 | { |
||
2463 | png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); |
||
2464 | png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); |
||
2465 | int sshift, dshift; |
||
2466 | int s_start, s_end, s_inc; |
||
2467 | int jstop = png_pass_inc[pass]; |
||
2468 | png_byte v; |
||
2469 | png_uint_32 i; |
||
2470 | int j; |
||
2471 | |||
2472 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2473 | if (transformations & PNG_PACKSWAP) |
||
2474 | { |
||
2475 | sshift = (int)((row_info->width + 7) & 0x07); |
||
2476 | dshift = (int)((final_width + 7) & 0x07); |
||
2477 | s_start = 7; |
||
2478 | s_end = 0; |
||
2479 | s_inc = -1; |
||
2480 | } |
||
2481 | else |
||
2482 | #endif |
||
2483 | { |
||
2484 | sshift = 7 - (int)((row_info->width + 7) & 0x07); |
||
2485 | dshift = 7 - (int)((final_width + 7) & 0x07); |
||
2486 | s_start = 0; |
||
2487 | s_end = 7; |
||
2488 | s_inc = 1; |
||
2489 | } |
||
2490 | |||
2491 | for (i = 0; i < row_info->width; i++) |
||
2492 | { |
||
2493 | v = (png_byte)((*sp >> sshift) & 0x01); |
||
2494 | for (j = 0; j < jstop; j++) |
||
2495 | { |
||
2496 | *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
||
2497 | *dp |= (png_byte)(v << dshift); |
||
2498 | if (dshift == s_end) |
||
2499 | { |
||
2500 | dshift = s_start; |
||
2501 | dp--; |
||
2502 | } |
||
2503 | else |
||
2504 | dshift += s_inc; |
||
2505 | } |
||
2506 | if (sshift == s_end) |
||
2507 | { |
||
2508 | sshift = s_start; |
||
2509 | sp--; |
||
2510 | } |
||
2511 | else |
||
2512 | sshift += s_inc; |
||
2513 | } |
||
2514 | break; |
||
2515 | } |
||
2516 | case 2: |
||
2517 | { |
||
2518 | png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); |
||
2519 | png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); |
||
2520 | int sshift, dshift; |
||
2521 | int s_start, s_end, s_inc; |
||
2522 | int jstop = png_pass_inc[pass]; |
||
2523 | png_uint_32 i; |
||
2524 | |||
2525 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2526 | if (transformations & PNG_PACKSWAP) |
||
2527 | { |
||
2528 | sshift = (int)(((row_info->width + 3) & 0x03) << 1); |
||
2529 | dshift = (int)(((final_width + 3) & 0x03) << 1); |
||
2530 | s_start = 6; |
||
2531 | s_end = 0; |
||
2532 | s_inc = -2; |
||
2533 | } |
||
2534 | else |
||
2535 | #endif |
||
2536 | { |
||
2537 | sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); |
||
2538 | dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); |
||
2539 | s_start = 0; |
||
2540 | s_end = 6; |
||
2541 | s_inc = 2; |
||
2542 | } |
||
2543 | |||
2544 | for (i = 0; i < row_info->width; i++) |
||
2545 | { |
||
2546 | png_byte v; |
||
2547 | int j; |
||
2548 | |||
2549 | v = (png_byte)((*sp >> sshift) & 0x03); |
||
2550 | for (j = 0; j < jstop; j++) |
||
2551 | { |
||
2552 | *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
||
2553 | *dp |= (png_byte)(v << dshift); |
||
2554 | if (dshift == s_end) |
||
2555 | { |
||
2556 | dshift = s_start; |
||
2557 | dp--; |
||
2558 | } |
||
2559 | else |
||
2560 | dshift += s_inc; |
||
2561 | } |
||
2562 | if (sshift == s_end) |
||
2563 | { |
||
2564 | sshift = s_start; |
||
2565 | sp--; |
||
2566 | } |
||
2567 | else |
||
2568 | sshift += s_inc; |
||
2569 | } |
||
2570 | break; |
||
2571 | } |
||
2572 | case 4: |
||
2573 | { |
||
2574 | png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); |
||
2575 | png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); |
||
2576 | int sshift, dshift; |
||
2577 | int s_start, s_end, s_inc; |
||
2578 | png_uint_32 i; |
||
2579 | int jstop = png_pass_inc[pass]; |
||
2580 | |||
2581 | #if defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2582 | if (transformations & PNG_PACKSWAP) |
||
2583 | { |
||
2584 | sshift = (int)(((row_info->width + 1) & 0x01) << 2); |
||
2585 | dshift = (int)(((final_width + 1) & 0x01) << 2); |
||
2586 | s_start = 4; |
||
2587 | s_end = 0; |
||
2588 | s_inc = -4; |
||
2589 | } |
||
2590 | else |
||
2591 | #endif |
||
2592 | { |
||
2593 | sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); |
||
2594 | dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); |
||
2595 | s_start = 0; |
||
2596 | s_end = 4; |
||
2597 | s_inc = 4; |
||
2598 | } |
||
2599 | |||
2600 | for (i = 0; i < row_info->width; i++) |
||
2601 | { |
||
2602 | png_byte v = (png_byte)((*sp >> sshift) & 0xf); |
||
2603 | int j; |
||
2604 | |||
2605 | for (j = 0; j < jstop; j++) |
||
2606 | { |
||
2607 | *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
||
2608 | *dp |= (png_byte)(v << dshift); |
||
2609 | if (dshift == s_end) |
||
2610 | { |
||
2611 | dshift = s_start; |
||
2612 | dp--; |
||
2613 | } |
||
2614 | else |
||
2615 | dshift += s_inc; |
||
2616 | } |
||
2617 | if (sshift == s_end) |
||
2618 | { |
||
2619 | sshift = s_start; |
||
2620 | sp--; |
||
2621 | } |
||
2622 | else |
||
2623 | sshift += s_inc; |
||
2624 | } |
||
2625 | break; |
||
2626 | } |
||
2627 | default: |
||
2628 | { |
||
2629 | png_size_t pixel_bytes = (row_info->pixel_depth >> 3); |
||
2630 | png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes; |
||
2631 | png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; |
||
2632 | |||
2633 | int jstop = png_pass_inc[pass]; |
||
2634 | png_uint_32 i; |
||
2635 | |||
2636 | for (i = 0; i < row_info->width; i++) |
||
2637 | { |
||
2638 | png_byte v[8]; |
||
2639 | int j; |
||
2640 | |||
2641 | png_memcpy(v, sp, pixel_bytes); |
||
2642 | for (j = 0; j < jstop; j++) |
||
2643 | { |
||
2644 | png_memcpy(dp, v, pixel_bytes); |
||
2645 | dp -= pixel_bytes; |
||
2646 | } |
||
2647 | sp -= pixel_bytes; |
||
2648 | } |
||
2649 | break; |
||
2650 | } |
||
2651 | } |
||
2652 | row_info->width = final_width; |
||
2653 | row_info->rowbytes = ((final_width * |
||
2654 | (png_uint_32)row_info->pixel_depth + 7) >> 3); |
||
2655 | } |
||
2656 | #if !defined(PNG_READ_PACKSWAP_SUPPORTED) |
||
2657 | transformations = transformations; /* silence compiler warning */ |
||
2658 | #endif |
||
2659 | } |
||
2660 | #endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */ |
||
2661 | #endif /* PNG_READ_INTERLACING_SUPPORTED */ |
||
2662 | |||
2663 | #ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
||
2664 | void /* PRIVATE */ |
||
2665 | png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, |
||
2666 | png_bytep prev_row, int filter) |
||
2667 | { |
||
2668 | png_debug(1, "in png_read_filter_row\n"); |
||
2669 | png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter); |
||
2670 | switch (filter) |
||
2671 | { |
||
2672 | case PNG_FILTER_VALUE_NONE: |
||
2673 | break; |
||
2674 | case PNG_FILTER_VALUE_SUB: |
||
2675 | { |
||
2676 | png_uint_32 i; |
||
2677 | png_uint_32 istop = row_info->rowbytes; |
||
2678 | png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
||
2679 | png_bytep rp = row + bpp; |
||
2680 | png_bytep lp = row; |
||
2681 | |||
2682 | for (i = bpp; i < istop; i++) |
||
2683 | { |
||
2684 | *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
||
2685 | rp++; |
||
2686 | } |
||
2687 | break; |
||
2688 | } |
||
2689 | case PNG_FILTER_VALUE_UP: |
||
2690 | { |
||
2691 | png_uint_32 i; |
||
2692 | png_uint_32 istop = row_info->rowbytes; |
||
2693 | png_bytep rp = row; |
||
2694 | png_bytep pp = prev_row; |
||
2695 | |||
2696 | for (i = 0; i < istop; i++) |
||
2697 | { |
||
2698 | *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
||
2699 | rp++; |
||
2700 | } |
||
2701 | break; |
||
2702 | } |
||
2703 | case PNG_FILTER_VALUE_AVG: |
||
2704 | { |
||
2705 | png_uint_32 i; |
||
2706 | png_bytep rp = row; |
||
2707 | png_bytep pp = prev_row; |
||
2708 | png_bytep lp = row; |
||
2709 | png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
||
2710 | png_uint_32 istop = row_info->rowbytes - bpp; |
||
2711 | |||
2712 | for (i = 0; i < bpp; i++) |
||
2713 | { |
||
2714 | *rp = (png_byte)(((int)(*rp) + |
||
2715 | ((int)(*pp++) / 2 )) & 0xff); |
||
2716 | rp++; |
||
2717 | } |
||
2718 | |||
2719 | for (i = 0; i < istop; i++) |
||
2720 | { |
||
2721 | *rp = (png_byte)(((int)(*rp) + |
||
2722 | (int)(*pp++ + *lp++) / 2 ) & 0xff); |
||
2723 | rp++; |
||
2724 | } |
||
2725 | break; |
||
2726 | } |
||
2727 | case PNG_FILTER_VALUE_PAETH: |
||
2728 | { |
||
2729 | png_uint_32 i; |
||
2730 | png_bytep rp = row; |
||
2731 | png_bytep pp = prev_row; |
||
2732 | png_bytep lp = row; |
||
2733 | png_bytep cp = prev_row; |
||
2734 | png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
||
2735 | png_uint_32 istop=row_info->rowbytes - bpp; |
||
2736 | |||
2737 | for (i = 0; i < bpp; i++) |
||
2738 | { |
||
2739 | *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
||
2740 | rp++; |
||
2741 | } |
||
2742 | |||
2743 | for (i = 0; i < istop; i++) /* use leftover rp,pp */ |
||
2744 | { |
||
2745 | int a, b, c, pa, pb, pc, p; |
||
2746 | |||
2747 | a = *lp++; |
||
2748 | b = *pp++; |
||
2749 | c = *cp++; |
||
2750 | |||
2751 | p = b - c; |
||
2752 | pc = a - c; |
||
2753 | |||
2754 | #ifdef PNG_USE_ABS |
||
2755 | pa = abs(p); |
||
2756 | pb = abs(pc); |
||
2757 | pc = abs(p + pc); |
||
2758 | #else |
||
2759 | pa = p < 0 ? -p : p; |
||
2760 | pb = pc < 0 ? -pc : pc; |
||
2761 | pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
||
2762 | #endif |
||
2763 | |||
2764 | /* |
||
2765 | if (pa <= pb && pa <= pc) |
||
2766 | p = a; |
||
2767 | else if (pb <= pc) |
||
2768 | p = b; |
||
2769 | else |
||
2770 | p = c; |
||
2771 | */ |
||
2772 | |||
2773 | p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
||
2774 | |||
2775 | *rp = (png_byte)(((int)(*rp) + p) & 0xff); |
||
2776 | rp++; |
||
2777 | } |
||
2778 | break; |
||
2779 | } |
||
2780 | default: |
||
2781 | png_warning(png_ptr, "Ignoring bad adaptive filter type"); |
||
2782 | *row=0; |
||
2783 | break; |
||
2784 | } |
||
2785 | } |
||
2786 | #endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ |
||
2787 | |||
2788 | void /* PRIVATE */ |
||
2789 | png_read_finish_row(png_structp png_ptr) |
||
2790 | { |
||
2791 | #ifdef PNG_USE_LOCAL_ARRAYS |
||
2792 | /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
||
2793 | |||
2794 | /* start of interlace block */ |
||
2795 | const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
||
2796 | |||
2797 | /* offset to next interlace block */ |
||
2798 | const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
||
2799 | |||
2800 | /* start of interlace block in the y direction */ |
||
2801 | const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
||
2802 | |||
2803 | /* offset to next interlace block in the y direction */ |
||
2804 | const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
||
2805 | #endif |
||
2806 | |||
2807 | png_debug(1, "in png_read_finish_row\n"); |
||
2808 | png_ptr->row_number++; |
||
2809 | if (png_ptr->row_number < png_ptr->num_rows) |
||
2810 | return; |
||
2811 | |||
2812 | if (png_ptr->interlaced) |
||
2813 | { |
||
2814 | png_ptr->row_number = 0; |
||
2815 | png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
||
2816 | do |
||
2817 | { |
||
2818 | png_ptr->pass++; |
||
2819 | if (png_ptr->pass >= 7) |
||
2820 | break; |
||
2821 | png_ptr->iwidth = (png_ptr->width + |
||
2822 | png_pass_inc[png_ptr->pass] - 1 - |
||
2823 | png_pass_start[png_ptr->pass]) / |
||
2824 | png_pass_inc[png_ptr->pass]; |
||
2825 | png_ptr->irowbytes = ((png_ptr->iwidth * |
||
2826 | (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
||
2827 | |||
2828 | if (!(png_ptr->transformations & PNG_INTERLACE)) |
||
2829 | { |
||
2830 | png_ptr->num_rows = (png_ptr->height + |
||
2831 | png_pass_yinc[png_ptr->pass] - 1 - |
||
2832 | png_pass_ystart[png_ptr->pass]) / |
||
2833 | png_pass_yinc[png_ptr->pass]; |
||
2834 | if (!(png_ptr->num_rows)) |
||
2835 | continue; |
||
2836 | } |
||
2837 | else /* if (png_ptr->transformations & PNG_INTERLACE) */ |
||
2838 | break; |
||
2839 | } while (png_ptr->iwidth == 0); |
||
2840 | |||
2841 | if (png_ptr->pass < 7) |
||
2842 | return; |
||
2843 | } |
||
2844 | |||
2845 | if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
||
2846 | { |
||
2847 | #ifdef PNG_USE_LOCAL_ARRAYS |
||
2848 | PNG_IDAT; |
||
2849 | #endif |
||
2850 | char extra; |
||
2851 | int ret; |
||
2852 | |||
2853 | png_ptr->zstream.next_out = (Byte *)&extra; |
||
2854 | png_ptr->zstream.avail_out = (uInt)1; |
||
2855 | for(;;) |
||
2856 | { |
||
2857 | if (!(png_ptr->zstream.avail_in)) |
||
2858 | { |
||
2859 | while (!png_ptr->idat_size) |
||
2860 | { |
||
2861 | png_byte chunk_length[4]; |
||
2862 | |||
2863 | png_crc_finish(png_ptr, 0); |
||
2864 | |||
2865 | png_read_data(png_ptr, chunk_length, 4); |
||
2866 | png_ptr->idat_size = png_get_uint_32(chunk_length); |
||
2867 | |||
2868 | png_reset_crc(png_ptr); |
||
2869 | png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
||
2870 | if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
||
2871 | png_error(png_ptr, "Not enough image data"); |
||
2872 | |||
2873 | } |
||
2874 | png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
||
2875 | png_ptr->zstream.next_in = png_ptr->zbuf; |
||
2876 | if (png_ptr->zbuf_size > png_ptr->idat_size) |
||
2877 | png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
||
2878 | png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); |
||
2879 | png_ptr->idat_size -= png_ptr->zstream.avail_in; |
||
2880 | } |
||
2881 | ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
||
2882 | if (ret == Z_STREAM_END) |
||
2883 | { |
||
2884 | if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || |
||
2885 | png_ptr->idat_size) |
||
2886 | png_warning(png_ptr, "Extra compressed data"); |
||
2887 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
2888 | png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
||
2889 | break; |
||
2890 | } |
||
2891 | if (ret != Z_OK) |
||
2892 | png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
||
2893 | "Decompression Error"); |
||
2894 | |||
2895 | if (!(png_ptr->zstream.avail_out)) |
||
2896 | { |
||
2897 | png_warning(png_ptr, "Extra compressed data."); |
||
2898 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
2899 | png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
||
2900 | break; |
||
2901 | } |
||
2902 | |||
2903 | } |
||
2904 | png_ptr->zstream.avail_out = 0; |
||
2905 | } |
||
2906 | |||
2907 | if (png_ptr->idat_size || png_ptr->zstream.avail_in) |
||
2908 | png_warning(png_ptr, "Extra compression data"); |
||
2909 | |||
2910 | inflateReset(&png_ptr->zstream); |
||
2911 | |||
2912 | png_ptr->mode |= PNG_AFTER_IDAT; |
||
2913 | } |
||
2914 | |||
2915 | void /* PRIVATE */ |
||
2916 | png_read_start_row(png_structp png_ptr) |
||
2917 | { |
||
2918 | #ifdef PNG_USE_LOCAL_ARRAYS |
||
2919 | /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
||
2920 | |||
2921 | /* start of interlace block */ |
||
2922 | const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
||
2923 | |||
2924 | /* offset to next interlace block */ |
||
2925 | const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
||
2926 | |||
2927 | /* start of interlace block in the y direction */ |
||
2928 | const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
||
2929 | |||
2930 | /* offset to next interlace block in the y direction */ |
||
2931 | const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
||
2932 | #endif |
||
2933 | |||
2934 | int max_pixel_depth; |
||
2935 | png_uint_32 row_bytes; |
||
2936 | |||
2937 | png_debug(1, "in png_read_start_row\n"); |
||
2938 | png_ptr->zstream.avail_in = 0; |
||
2939 | png_init_read_transformations(png_ptr); |
||
2940 | if (png_ptr->interlaced) |
||
2941 | { |
||
2942 | if (!(png_ptr->transformations & PNG_INTERLACE)) |
||
2943 | png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - |
||
2944 | png_pass_ystart[0]) / png_pass_yinc[0]; |
||
2945 | else |
||
2946 | png_ptr->num_rows = png_ptr->height; |
||
2947 | |||
2948 | png_ptr->iwidth = (png_ptr->width + |
||
2949 | png_pass_inc[png_ptr->pass] - 1 - |
||
2950 | png_pass_start[png_ptr->pass]) / |
||
2951 | png_pass_inc[png_ptr->pass]; |
||
2952 | |||
2953 | row_bytes = ((png_ptr->iwidth * |
||
2954 | (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
||
2955 | png_ptr->irowbytes = (png_size_t)row_bytes; |
||
2956 | if((png_uint_32)png_ptr->irowbytes != row_bytes) |
||
2957 | png_error(png_ptr, "Rowbytes overflow in png_read_start_row"); |
||
2958 | } |
||
2959 | else |
||
2960 | { |
||
2961 | png_ptr->num_rows = png_ptr->height; |
||
2962 | png_ptr->iwidth = png_ptr->width; |
||
2963 | png_ptr->irowbytes = png_ptr->rowbytes + 1; |
||
2964 | } |
||
2965 | max_pixel_depth = png_ptr->pixel_depth; |
||
2966 | |||
2967 | #if defined(PNG_READ_PACK_SUPPORTED) |
||
2968 | if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) |
||
2969 | max_pixel_depth = 8; |
||
2970 | #endif |
||
2971 | |||
2972 | #if defined(PNG_READ_EXPAND_SUPPORTED) |
||
2973 | if (png_ptr->transformations & PNG_EXPAND) |
||
2974 | { |
||
2975 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
2976 | { |
||
2977 | if (png_ptr->num_trans) |
||
2978 | max_pixel_depth = 32; |
||
2979 | else |
||
2980 | max_pixel_depth = 24; |
||
2981 | } |
||
2982 | else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
||
2983 | { |
||
2984 | if (max_pixel_depth < 8) |
||
2985 | max_pixel_depth = 8; |
||
2986 | if (png_ptr->num_trans) |
||
2987 | max_pixel_depth *= 2; |
||
2988 | } |
||
2989 | else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
||
2990 | { |
||
2991 | if (png_ptr->num_trans) |
||
2992 | { |
||
2993 | max_pixel_depth *= 4; |
||
2994 | max_pixel_depth /= 3; |
||
2995 | } |
||
2996 | } |
||
2997 | } |
||
2998 | #endif |
||
2999 | |||
3000 | #if defined(PNG_READ_FILLER_SUPPORTED) |
||
3001 | if (png_ptr->transformations & (PNG_FILLER)) |
||
3002 | { |
||
3003 | if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
||
3004 | max_pixel_depth = 32; |
||
3005 | else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
||
3006 | { |
||
3007 | if (max_pixel_depth <= 8) |
||
3008 | max_pixel_depth = 16; |
||
3009 | else |
||
3010 | max_pixel_depth = 32; |
||
3011 | } |
||
3012 | else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
||
3013 | { |
||
3014 | if (max_pixel_depth <= 32) |
||
3015 | max_pixel_depth = 32; |
||
3016 | else |
||
3017 | max_pixel_depth = 64; |
||
3018 | } |
||
3019 | } |
||
3020 | #endif |
||
3021 | |||
3022 | #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
||
3023 | if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
||
3024 | { |
||
3025 | if ( |
||
3026 | #if defined(PNG_READ_EXPAND_SUPPORTED) |
||
3027 | (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || |
||
3028 | #endif |
||
3029 | #if defined(PNG_READ_FILLER_SUPPORTED) |
||
3030 | (png_ptr->transformations & (PNG_FILLER)) || |
||
3031 | #endif |
||
3032 | png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
||
3033 | { |
||
3034 | if (max_pixel_depth <= 16) |
||
3035 | max_pixel_depth = 32; |
||
3036 | else |
||
3037 | max_pixel_depth = 64; |
||
3038 | } |
||
3039 | else |
||
3040 | { |
||
3041 | if (max_pixel_depth <= 8) |
||
3042 | { |
||
3043 | if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
||
3044 | max_pixel_depth = 32; |
||
3045 | else |
||
3046 | max_pixel_depth = 24; |
||
3047 | } |
||
3048 | else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
||
3049 | max_pixel_depth = 64; |
||
3050 | else |
||
3051 | max_pixel_depth = 48; |
||
3052 | } |
||
3053 | } |
||
3054 | #endif |
||
3055 | |||
3056 | #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ |
||
3057 | defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
||
3058 | if(png_ptr->transformations & PNG_USER_TRANSFORM) |
||
3059 | { |
||
3060 | int user_pixel_depth=png_ptr->user_transform_depth* |
||
3061 | png_ptr->user_transform_channels; |
||
3062 | if(user_pixel_depth > max_pixel_depth) |
||
3063 | max_pixel_depth=user_pixel_depth; |
||
3064 | } |
||
3065 | #endif |
||
3066 | |||
3067 | /* align the width on the next larger 8 pixels. Mainly used |
||
3068 | for interlacing */ |
||
3069 | row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); |
||
3070 | /* calculate the maximum bytes needed, adding a byte and a pixel |
||
3071 | for safety's sake */ |
||
3072 | row_bytes = ((row_bytes * (png_uint_32)max_pixel_depth + 7) >> 3) + |
||
3073 | 1 + ((max_pixel_depth + 7) >> 3); |
||
3074 | #ifdef PNG_MAX_MALLOC_64K |
||
3075 | if (row_bytes > (png_uint_32)65536L) |
||
3076 | png_error(png_ptr, "This image requires a row greater than 64KB"); |
||
3077 | #endif |
||
3078 | png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); |
||
3079 | png_ptr->row_buf = png_ptr->big_row_buf+32; |
||
3080 | #if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) |
||
3081 | png_ptr->row_buf_size = row_bytes; |
||
3082 | #endif |
||
3083 | |||
3084 | #ifdef PNG_MAX_MALLOC_64K |
||
3085 | if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) |
||
3086 | png_error(png_ptr, "This image requires a row greater than 64KB"); |
||
3087 | #endif |
||
3088 | png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( |
||
3089 | png_ptr->rowbytes + 1)); |
||
3090 | |||
3091 | png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
||
3092 | |||
3093 | png_debug1(3, "width = %lu,\n", png_ptr->width); |
||
3094 | png_debug1(3, "height = %lu,\n", png_ptr->height); |
||
3095 | png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth); |
||
3096 | png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows); |
||
3097 | png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes); |
||
3098 | png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes); |
||
3099 | |||
3100 | png_ptr->flags |= PNG_FLAG_ROW_INIT; |
||
3101 | } |