]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/png/pngread.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ignore files produced by CodeWarrior
[wxWidgets.git] / src / png / pngread.c
... / ...
CommitLineData
1
2/* pngread.c - read a PNG file
3 *
4 * libpng 1.0.3 - January 14, 1999
5 * For conditions of distribution and use, see copyright notice in png.h
6 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
7 * Copyright (c) 1996, 1997 Andreas Dilger
8 * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
9 *
10 * This file contains routines that an application calls directly to
11 * read a PNG file or stream.
12 */
13
14#define PNG_INTERNAL
15#include "png.h"
16
17/* Create a PNG structure for reading, and allocate any memory needed. */
18png_structp
19png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
20 png_error_ptr error_fn, png_error_ptr warn_fn)
21{
22
23#ifdef PNG_USER_MEM_SUPPORTED
24 return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
25 warn_fn, NULL, NULL, NULL));
26}
27
28/* Alternate create PNG structure for reading, and allocate any memory needed. */
29png_structp
30png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
31 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
32 png_malloc_ptr malloc_fn, png_free_ptr free_fn)
33{
34#endif /* PNG_USER_MEM_SUPPORTED */
35
36 png_structp png_ptr;
37#ifdef USE_FAR_KEYWORD
38 jmp_buf jmpbuf;
39#endif
40 png_debug(1, "in png_create_read_struct\n");
41#ifdef PNG_USER_MEM_SUPPORTED
42 if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
43 (png_malloc_ptr)malloc_fn)) == NULL)
44#else
45 if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
46#endif
47 {
48 return (png_structp)NULL;
49 }
50#ifdef USE_FAR_KEYWORD
51 if (setjmp(jmpbuf))
52#else
53 if (setjmp(png_ptr->jmpbuf))
54#endif
55 {
56 png_free(png_ptr, png_ptr->zbuf);
57 png_destroy_struct(png_ptr);
58 return (png_structp)NULL;
59 }
60#ifdef USE_FAR_KEYWORD
61 png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
62#endif
63
64#ifdef PNG_USER_MEM_SUPPORTED
65 png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
66#endif /* PNG_USER_MEM_SUPPORTED */
67
68 png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
69
70 /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
71 * we must recompile any applications that use any older library version.
72 * For versions after libpng 1.0, we will be compatible, so we need
73 * only check the first digit.
74 */
75 if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
76 (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
77 {
78 png_error(png_ptr,
79 "Incompatible libpng version in application and library");
80 }
81
82 /* initialize zbuf - compression buffer */
83 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
84 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
85 (png_uint_32)png_ptr->zbuf_size);
86 png_ptr->zstream.zalloc = png_zalloc;
87 png_ptr->zstream.zfree = png_zfree;
88 png_ptr->zstream.opaque = (voidpf)png_ptr;
89
90 switch (inflateInit(&png_ptr->zstream))
91 {
92 case Z_OK: /* Do nothing */ break;
93 case Z_MEM_ERROR:
94 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
95 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
96 default: png_error(png_ptr, "Unknown zlib error");
97 }
98
99 png_ptr->zstream.next_out = png_ptr->zbuf;
100 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
101
102 png_set_read_fn(png_ptr, NULL, NULL);
103
104 return (png_ptr);
105}
106
107/* Initialize PNG structure for reading, and allocate any memory needed.
108 This interface is deprecated in favour of the png_create_read_struct(),
109 and it will eventually disappear. */
110void
111png_read_init(png_structp png_ptr)
112{
113 jmp_buf tmp_jmp; /* to save current jump buffer */
114
115 png_debug(1, "in png_read_init\n");
116 /* save jump buffer and error functions */
117 png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
118
119 /* reset all variables to 0 */
120 png_memset(png_ptr, 0, sizeof (png_struct));
121
122 /* restore jump buffer */
123 png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
124
125 /* initialize zbuf - compression buffer */
126 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
127 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
128 (png_uint_32)png_ptr->zbuf_size);
129 png_ptr->zstream.zalloc = png_zalloc;
130 png_ptr->zstream.zfree = png_zfree;
131 png_ptr->zstream.opaque = (voidpf)png_ptr;
132
133 switch (inflateInit(&png_ptr->zstream))
134 {
135 case Z_OK: /* Do nothing */ break;
136 case Z_MEM_ERROR:
137 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
138 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
139 default: png_error(png_ptr, "Unknown zlib error");
140 }
141
142 png_ptr->zstream.next_out = png_ptr->zbuf;
143 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
144
145 png_set_read_fn(png_ptr, NULL, NULL);
146}
147
148/* Read the information before the actual image data. This has been
149 * changed in v0.90 to allow reading a file that already has the magic
150 * bytes read from the stream. You can tell libpng how many bytes have
151 * been read from the beginning of the stream (up to the maximum of 8)
152 * via png_set_sig_bytes(), and we will only check the remaining bytes
153 * here. The application can then have access to the signature bytes we
154 * read if it is determined that this isn't a valid PNG file.
155 */
156void
157png_read_info(png_structp png_ptr, png_infop info_ptr)
158{
159 png_debug(1, "in png_read_info\n");
160 /* save jump buffer and error functions */
161 /* If we haven't checked all of the PNG signature bytes, do so now. */
162 if (png_ptr->sig_bytes < 8)
163 {
164 png_size_t num_checked = png_ptr->sig_bytes,
165 num_to_check = 8 - num_checked;
166
167 png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
168 png_ptr->sig_bytes = 8;
169
170 if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
171 {
172 if (num_checked < 4 &&
173 png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
174 png_error(png_ptr, "Not a PNG file");
175 else
176 png_error(png_ptr, "PNG file corrupted by ASCII conversion");
177 }
178 }
179
180 for(;;)
181 {
182 png_byte chunk_length[4];
183 png_uint_32 length;
184
185 png_read_data(png_ptr, chunk_length, 4);
186 length = png_get_uint_32(chunk_length);
187
188 png_reset_crc(png_ptr);
189 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
190
191 png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);
192
193 /* This should be a binary subdivision search or a hash for
194 * matching the chunk name rather than a linear search.
195 */
196 if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
197 png_handle_IHDR(png_ptr, info_ptr, length);
198 else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
199 png_handle_PLTE(png_ptr, info_ptr, length);
200 else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
201 png_handle_IEND(png_ptr, info_ptr, length);
202 else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
203 {
204 if (!(png_ptr->mode & PNG_HAVE_IHDR))
205 png_error(png_ptr, "Missing IHDR before IDAT");
206 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
207 !(png_ptr->mode & PNG_HAVE_PLTE))
208 png_error(png_ptr, "Missing PLTE before IDAT");
209
210 png_ptr->idat_size = length;
211 png_ptr->mode |= PNG_HAVE_IDAT;
212 break;
213 }
214#if defined(PNG_READ_bKGD_SUPPORTED)
215 else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
216 png_handle_bKGD(png_ptr, info_ptr, length);
217#endif
218#if defined(PNG_READ_cHRM_SUPPORTED)
219 else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
220 png_handle_cHRM(png_ptr, info_ptr, length);
221#endif
222#if defined(PNG_READ_gAMA_SUPPORTED)
223 else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
224 png_handle_gAMA(png_ptr, info_ptr, length);
225#endif
226#if defined(PNG_READ_hIST_SUPPORTED)
227 else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
228 png_handle_hIST(png_ptr, info_ptr, length);
229#endif
230#if defined(PNG_READ_oFFs_SUPPORTED)
231 else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
232 png_handle_oFFs(png_ptr, info_ptr, length);
233#endif
234#if defined(PNG_READ_pCAL_SUPPORTED)
235 else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
236 png_handle_pCAL(png_ptr, info_ptr, length);
237#endif
238#if defined(PNG_READ_pHYs_SUPPORTED)
239 else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
240 png_handle_pHYs(png_ptr, info_ptr, length);
241#endif
242#if defined(PNG_READ_sBIT_SUPPORTED)
243 else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
244 png_handle_sBIT(png_ptr, info_ptr, length);
245#endif
246#if defined(PNG_READ_sRGB_SUPPORTED)
247 else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
248 png_handle_sRGB(png_ptr, info_ptr, length);
249#endif
250#if defined(PNG_READ_tEXt_SUPPORTED)
251 else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
252 png_handle_tEXt(png_ptr, info_ptr, length);
253#endif
254#if defined(PNG_READ_tIME_SUPPORTED)
255 else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
256 png_handle_tIME(png_ptr, info_ptr, length);
257#endif
258#if defined(PNG_READ_tRNS_SUPPORTED)
259 else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
260 png_handle_tRNS(png_ptr, info_ptr, length);
261#endif
262#if defined(PNG_READ_zTXt_SUPPORTED)
263 else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
264 png_handle_zTXt(png_ptr, info_ptr, length);
265#endif
266 else
267 png_handle_unknown(png_ptr, info_ptr, length);
268 }
269}
270
271/* optional call to update the users info_ptr structure */
272void
273png_read_update_info(png_structp png_ptr, png_infop info_ptr)
274{
275 png_debug(1, "in png_read_update_info\n");
276 /* save jump buffer and error functions */
277 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
278 png_read_start_row(png_ptr);
279 png_read_transform_info(png_ptr, info_ptr);
280}
281
282/* Initialize palette, background, etc, after transformations
283 * are set, but before any reading takes place. This allows
284 * the user to obtain a gamma-corrected palette, for example.
285 * If the user doesn't call this, we will do it ourselves.
286 */
287void
288png_start_read_image(png_structp png_ptr)
289{
290 png_debug(1, "in png_start_read_image\n");
291 /* save jump buffer and error functions */
292 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
293 png_read_start_row(png_ptr);
294}
295
296void
297png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
298{
299 int ret;
300 png_debug2(1, "in png_read_row (row %d, pass %d)\n",
301 png_ptr->row_number, png_ptr->pass);
302 /* save jump buffer and error functions */
303 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
304 png_read_start_row(png_ptr);
305 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
306 {
307 /* check for transforms that have been set but were defined out */
308#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
309 if (png_ptr->transformations & PNG_INVERT_MONO)
310 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
311#endif
312#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
313 if (png_ptr->transformations & PNG_FILLER)
314 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");
315#endif
316#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)
317 if (png_ptr->transformations & PNG_PACKSWAP)
318 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");
319#endif
320#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
321 if (png_ptr->transformations & PNG_PACK)
322 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");
323#endif
324#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
325 if (png_ptr->transformations & PNG_SHIFT)
326 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");
327#endif
328#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
329 if (png_ptr->transformations & PNG_BGR)
330 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");
331#endif
332#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
333 if (png_ptr->transformations & PNG_SWAP_BYTES)
334 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");
335#endif
336 }
337
338#if defined(PNG_READ_INTERLACING_SUPPORTED)
339 /* if interlaced and we do not need a new row, combine row and return */
340 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
341 {
342 switch (png_ptr->pass)
343 {
344 case 0:
345 if (png_ptr->row_number & 7)
346 {
347 if (dsp_row != NULL)
348 png_combine_row(png_ptr, dsp_row,
349 png_pass_dsp_mask[png_ptr->pass]);
350 png_read_finish_row(png_ptr);
351 return;
352 }
353 break;
354 case 1:
355 if ((png_ptr->row_number & 7) || png_ptr->width < 5)
356 {
357 if (dsp_row != NULL)
358 png_combine_row(png_ptr, dsp_row,
359 png_pass_dsp_mask[png_ptr->pass]);
360 png_read_finish_row(png_ptr);
361 return;
362 }
363 break;
364 case 2:
365 if ((png_ptr->row_number & 7) != 4)
366 {
367 if (dsp_row != NULL && (png_ptr->row_number & 4))
368 png_combine_row(png_ptr, dsp_row,
369 png_pass_dsp_mask[png_ptr->pass]);
370 png_read_finish_row(png_ptr);
371 return;
372 }
373 break;
374 case 3:
375 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
376 {
377 if (dsp_row != NULL)
378 png_combine_row(png_ptr, dsp_row,
379 png_pass_dsp_mask[png_ptr->pass]);
380 png_read_finish_row(png_ptr);
381 return;
382 }
383 break;
384 case 4:
385 if ((png_ptr->row_number & 3) != 2)
386 {
387 if (dsp_row != NULL && (png_ptr->row_number & 2))
388 png_combine_row(png_ptr, dsp_row,
389 png_pass_dsp_mask[png_ptr->pass]);
390 png_read_finish_row(png_ptr);
391 return;
392 }
393 break;
394 case 5:
395 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
396 {
397 if (dsp_row != NULL)
398 png_combine_row(png_ptr, dsp_row,
399 png_pass_dsp_mask[png_ptr->pass]);
400 png_read_finish_row(png_ptr);
401 return;
402 }
403 break;
404 case 6:
405 if (!(png_ptr->row_number & 1))
406 {
407 png_read_finish_row(png_ptr);
408 return;
409 }
410 break;
411 }
412 }
413#endif
414
415 if (!(png_ptr->mode & PNG_HAVE_IDAT))
416 png_error(png_ptr, "Invalid attempt to read row data");
417
418 png_ptr->zstream.next_out = png_ptr->row_buf;
419 png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
420 do
421 {
422 if (!(png_ptr->zstream.avail_in))
423 {
424 while (!png_ptr->idat_size)
425 {
426 png_byte chunk_length[4];
427
428 png_crc_finish(png_ptr, 0);
429
430 png_read_data(png_ptr, chunk_length, 4);
431 png_ptr->idat_size = png_get_uint_32(chunk_length);
432
433 png_reset_crc(png_ptr);
434 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
435 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
436 png_error(png_ptr, "Not enough image data");
437 }
438 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
439 png_ptr->zstream.next_in = png_ptr->zbuf;
440 if (png_ptr->zbuf_size > png_ptr->idat_size)
441 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
442 png_crc_read(png_ptr, png_ptr->zbuf,
443 (png_size_t)png_ptr->zstream.avail_in);
444 png_ptr->idat_size -= png_ptr->zstream.avail_in;
445 }
446 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
447 if (ret == Z_STREAM_END)
448 {
449 if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
450 png_ptr->idat_size)
451 png_error(png_ptr, "Extra compressed data");
452 png_ptr->mode |= PNG_AFTER_IDAT;
453 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
454 break;
455 }
456 if (ret != Z_OK)
457 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
458 "Decompression error");
459
460 } while (png_ptr->zstream.avail_out);
461
462 png_ptr->row_info.color_type = png_ptr->color_type;
463 png_ptr->row_info.width = png_ptr->iwidth;
464 png_ptr->row_info.channels = png_ptr->channels;
465 png_ptr->row_info.bit_depth = png_ptr->bit_depth;
466 png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
467 {
468 png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
469 (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
470 }
471
472 png_read_filter_row(png_ptr, &(png_ptr->row_info),
473 png_ptr->row_buf + 1, png_ptr->prev_row + 1,
474 (int)(png_ptr->row_buf[0]));
475
476 png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,
477 png_ptr->rowbytes + 1);
478
479 if (png_ptr->transformations)
480 png_do_read_transformations(png_ptr);
481
482#if defined(PNG_READ_INTERLACING_SUPPORTED)
483 /* blow up interlaced rows to full size */
484 if (png_ptr->interlaced &&
485 (png_ptr->transformations & PNG_INTERLACE))
486 {
487 if (png_ptr->pass < 6)
488 png_do_read_interlace(&(png_ptr->row_info),
489 png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
490
491 if (dsp_row != NULL)
492 png_combine_row(png_ptr, dsp_row,
493 png_pass_dsp_mask[png_ptr->pass]);
494 if (row != NULL)
495 png_combine_row(png_ptr, row,
496 png_pass_mask[png_ptr->pass]);
497 }
498 else
499#endif
500 {
501 if (row != NULL)
502 png_combine_row(png_ptr, row, 0xff);
503 if (dsp_row != NULL)
504 png_combine_row(png_ptr, dsp_row, 0xff);
505 }
506 png_read_finish_row(png_ptr);
507
508 if (png_ptr->read_row_fn != NULL)
509 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
510}
511
512/* Read one or more rows of image data. If the image is interlaced,
513 * and png_set_interlace_handling() has been called, the rows need to
514 * contain the contents of the rows from the previous pass. If the
515 * image has alpha or transparency, and png_handle_alpha()[*] has been
516 * called, the rows contents must be initialized to the contents of the
517 * screen.
518 *
519 * "row" holds the actual image, and pixels are placed in it
520 * as they arrive. If the image is displayed after each pass, it will
521 * appear to "sparkle" in. "display_row" can be used to display a
522 * "chunky" progressive image, with finer detail added as it becomes
523 * available. If you do not want this "chunky" display, you may pass
524 * NULL for display_row. If you do not want the sparkle display, and
525 * you have not called png_handle_alpha(), you may pass NULL for rows.
526 * If you have called png_handle_alpha(), and the image has either an
527 * alpha channel or a transparency chunk, you must provide a buffer for
528 * rows. In this case, you do not have to provide a display_row buffer
529 * also, but you may. If the image is not interlaced, or if you have
530 * not called png_set_interlace_handling(), the display_row buffer will
531 * be ignored, so pass NULL to it.
532 *
533 * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.3.
534 */
535
536void
537png_read_rows(png_structp png_ptr, png_bytepp row,
538 png_bytepp display_row, png_uint_32 num_rows)
539{
540 png_uint_32 i;
541 png_bytepp rp;
542 png_bytepp dp;
543
544 png_debug(1, "in png_read_rows\n");
545 /* save jump buffer and error functions */
546 rp = row;
547 dp = display_row;
548 if (rp != NULL && dp != NULL)
549 for (i = 0; i < num_rows; i++)
550 {
551 png_bytep rptr = *rp++;
552 png_bytep dptr = *dp++;
553
554 png_read_row(png_ptr, rptr, dptr);
555 }
556 else if(rp != NULL)
557 for (i = 0; i < num_rows; i++)
558 {
559 png_bytep rptr = *rp;
560 png_read_row(png_ptr, rptr, NULL);
561 rp++;
562 }
563 else if(dp != NULL)
564 for (i = 0; i < num_rows; i++)
565 {
566 png_bytep dptr = *dp;
567 png_read_row(png_ptr, NULL, dptr);
568 dp++;
569 }
570}
571
572/* Read the entire image. If the image has an alpha channel or a tRNS
573 * chunk, and you have called png_handle_alpha()[*], you will need to
574 * initialize the image to the current image that PNG will be overlaying.
575 * We set the num_rows again here, in case it was incorrectly set in
576 * png_read_start_row() by a call to png_read_update_info() or
577 * png_start_read_image() if png_set_interlace_handling() wasn't called
578 * prior to either of these functions like it should have been. You can
579 * only call this function once. If you desire to have an image for
580 * each pass of a interlaced image, use png_read_rows() instead.
581 *
582 * [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.3.
583 */
584void
585png_read_image(png_structp png_ptr, png_bytepp image)
586{
587 png_uint_32 i,image_height;
588 int pass, j;
589 png_bytepp rp;
590
591 png_debug(1, "in png_read_image\n");
592 /* save jump buffer and error functions */
593 pass = png_set_interlace_handling(png_ptr);
594
595 image_height=png_ptr->height;
596 png_ptr->num_rows = image_height; /* Make sure this is set correctly */
597
598 for (j = 0; j < pass; j++)
599 {
600 rp = image;
601 for (i = 0; i < image_height; i++)
602 {
603 png_read_row(png_ptr, *rp, NULL);
604 rp++;
605 }
606 }
607}
608
609/* Read the end of the PNG file. Will not read past the end of the
610 * file, will verify the end is accurate, and will read any comments
611 * or time information at the end of the file, if info is not NULL.
612 */
613void
614png_read_end(png_structp png_ptr, png_infop info_ptr)
615{
616 png_byte chunk_length[4];
617 png_uint_32 length;
618
619 png_debug(1, "in png_read_end\n");
620 /* save jump buffer and error functions */
621 png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
622
623 do
624 {
625 png_read_data(png_ptr, chunk_length, 4);
626 length = png_get_uint_32(chunk_length);
627
628 png_reset_crc(png_ptr);
629 png_crc_read(png_ptr, png_ptr->chunk_name, 4);
630
631 png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);
632
633 if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
634 png_handle_IHDR(png_ptr, info_ptr, length);
635 else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
636 {
637 /* Zero length IDATs are legal after the last IDAT has been
638 * read, but not after other chunks have been read.
639 */
640 if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
641 png_error(png_ptr, "Too many IDAT's found");
642 else
643 png_crc_finish(png_ptr, 0);
644 }
645 else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
646 png_handle_PLTE(png_ptr, info_ptr, length);
647 else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
648 png_handle_IEND(png_ptr, info_ptr, length);
649#if defined(PNG_READ_bKGD_SUPPORTED)
650 else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
651 png_handle_bKGD(png_ptr, info_ptr, length);
652#endif
653#if defined(PNG_READ_cHRM_SUPPORTED)
654 else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
655 png_handle_cHRM(png_ptr, info_ptr, length);
656#endif
657#if defined(PNG_READ_gAMA_SUPPORTED)
658 else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
659 png_handle_gAMA(png_ptr, info_ptr, length);
660#endif
661#if defined(PNG_READ_hIST_SUPPORTED)
662 else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
663 png_handle_hIST(png_ptr, info_ptr, length);
664#endif
665#if defined(PNG_READ_oFFs_SUPPORTED)
666 else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
667 png_handle_oFFs(png_ptr, info_ptr, length);
668#endif
669#if defined(PNG_READ_pCAL_SUPPORTED)
670 else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
671 png_handle_pCAL(png_ptr, info_ptr, length);
672#endif
673#if defined(PNG_READ_pHYs_SUPPORTED)
674 else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
675 png_handle_pHYs(png_ptr, info_ptr, length);
676#endif
677#if defined(PNG_READ_sBIT_SUPPORTED)
678 else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
679 png_handle_sBIT(png_ptr, info_ptr, length);
680#endif
681#if defined(PNG_READ_sRGB_SUPPORTED)
682 else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
683 png_handle_sRGB(png_ptr, info_ptr, length);
684#endif
685#if defined(PNG_READ_tEXt_SUPPORTED)
686 else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
687 png_handle_tEXt(png_ptr, info_ptr, length);
688#endif
689#if defined(PNG_READ_tIME_SUPPORTED)
690 else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
691 png_handle_tIME(png_ptr, info_ptr, length);
692#endif
693#if defined(PNG_READ_tRNS_SUPPORTED)
694 else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
695 png_handle_tRNS(png_ptr, info_ptr, length);
696#endif
697#if defined(PNG_READ_zTXt_SUPPORTED)
698 else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
699 png_handle_zTXt(png_ptr, info_ptr, length);
700#endif
701 else
702 png_handle_unknown(png_ptr, info_ptr, length);
703 } while (!(png_ptr->mode & PNG_HAVE_IEND));
704}
705
706/* free all memory used by the read */
707void
708png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
709 png_infopp end_info_ptr_ptr)
710{
711 png_structp png_ptr = NULL;
712 png_infop info_ptr = NULL, end_info_ptr = NULL;
713#ifdef PNG_USER_MEM_SUPPORTED
714 png_free_ptr free_fn = NULL;
715#endif /* PNG_USER_MEM_SUPPORTED */
716
717 png_debug(1, "in png_destroy_read_struct\n");
718 /* save jump buffer and error functions */
719 if (png_ptr_ptr != NULL)
720 png_ptr = *png_ptr_ptr;
721
722 if (info_ptr_ptr != NULL)
723 info_ptr = *info_ptr_ptr;
724
725 if (end_info_ptr_ptr != NULL)
726 end_info_ptr = *end_info_ptr_ptr;
727
728#ifdef PNG_USER_MEM_SUPPORTED
729 free_fn = png_ptr->free_fn;
730#endif
731
732 png_read_destroy(png_ptr, info_ptr, end_info_ptr);
733
734 if (info_ptr != NULL)
735 {
736#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
737 png_free(png_ptr, info_ptr->text);
738#endif
739
740#ifdef PNG_USER_MEM_SUPPORTED
741 png_destroy_struct_2((png_voidp)info_ptr, free_fn);
742#else
743 png_destroy_struct((png_voidp)info_ptr);
744#endif
745 *info_ptr_ptr = (png_infop)NULL;
746 }
747
748 if (end_info_ptr != NULL)
749 {
750#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
751 png_free(png_ptr, end_info_ptr->text);
752#endif
753#ifdef PNG_USER_MEM_SUPPORTED
754 png_destroy_struct_2((png_voidp)end_info_ptr, free_fn);
755#else
756 png_destroy_struct((png_voidp)end_info_ptr);
757#endif
758 *end_info_ptr_ptr = (png_infop)NULL;
759 }
760
761 if (png_ptr != NULL)
762 {
763#ifdef PNG_USER_MEM_SUPPORTED
764 png_destroy_struct_2((png_voidp)png_ptr, free_fn);
765#else
766 png_destroy_struct((png_voidp)png_ptr);
767#endif
768 *png_ptr_ptr = (png_structp)NULL;
769 }
770}
771
772/* free all memory used by the read (old method) */
773void
774png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
775{
776 jmp_buf tmp_jmp;
777 png_error_ptr error_fn;
778 png_error_ptr warning_fn;
779 png_voidp error_ptr;
780#ifdef PNG_USER_MEM_SUPPORTED
781 png_free_ptr free_fn;
782#endif
783
784 png_debug(1, "in png_read_destroy\n");
785 /* save jump buffer and error functions */
786 if (info_ptr != NULL)
787 png_info_destroy(png_ptr, info_ptr);
788
789 if (end_info_ptr != NULL)
790 png_info_destroy(png_ptr, end_info_ptr);
791
792 png_free(png_ptr, png_ptr->zbuf);
793 png_free(png_ptr, png_ptr->row_buf);
794 png_free(png_ptr, png_ptr->prev_row);
795#if defined(PNG_READ_DITHER_SUPPORTED)
796 png_free(png_ptr, png_ptr->palette_lookup);
797 png_free(png_ptr, png_ptr->dither_index);
798#endif
799#if defined(PNG_READ_GAMMA_SUPPORTED)
800 png_free(png_ptr, png_ptr->gamma_table);
801#endif
802#if defined(PNG_READ_BACKGROUND_SUPPORTED)
803 png_free(png_ptr, png_ptr->gamma_from_1);
804 png_free(png_ptr, png_ptr->gamma_to_1);
805#endif
806 if (png_ptr->flags & PNG_FLAG_FREE_PALETTE)
807 png_zfree(png_ptr, png_ptr->palette);
808 if (png_ptr->flags & PNG_FLAG_FREE_TRANS)
809 png_free(png_ptr, png_ptr->trans);
810#if defined(PNG_READ_hIST_SUPPORTED)
811 if (png_ptr->flags & PNG_FLAG_FREE_HIST)
812 png_free(png_ptr, png_ptr->hist);
813#endif
814#if defined(PNG_READ_GAMMA_SUPPORTED)
815 if (png_ptr->gamma_16_table != NULL)
816 {
817 int i;
818 int istop = (1 << (8 - png_ptr->gamma_shift));
819 for (i = 0; i < istop; i++)
820 {
821 png_free(png_ptr, png_ptr->gamma_16_table[i]);
822 }
823 png_free(png_ptr, png_ptr->gamma_16_table);
824 }
825#if defined(PNG_READ_BACKGROUND_SUPPORTED)
826 if (png_ptr->gamma_16_from_1 != NULL)
827 {
828 int i;
829 int istop = (1 << (8 - png_ptr->gamma_shift));
830 for (i = 0; i < istop; i++)
831 {
832 png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
833 }
834 png_free(png_ptr, png_ptr->gamma_16_from_1);
835 }
836 if (png_ptr->gamma_16_to_1 != NULL)
837 {
838 int i;
839 int istop = (1 << (8 - png_ptr->gamma_shift));
840 for (i = 0; i < istop; i++)
841 {
842 png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
843 }
844 png_free(png_ptr, png_ptr->gamma_16_to_1);
845 }
846#endif
847#endif
848#if defined(PNG_TIME_RFC1123_SUPPORTED)
849 png_free(png_ptr, png_ptr->time_buffer);
850#endif /* PNG_TIME_RFC1123_SUPPORTED */
851
852 inflateEnd(&png_ptr->zstream);
853#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
854 png_free(png_ptr, png_ptr->save_buffer);
855#endif
856
857 /* Save the important info out of the png_struct, in case it is
858 * being used again.
859 */
860 png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
861
862 error_fn = png_ptr->error_fn;
863 warning_fn = png_ptr->warning_fn;
864 error_ptr = png_ptr->error_ptr;
865#ifdef PNG_USER_MEM_SUPPORTED
866 free_fn = png_ptr->free_fn;
867#endif
868
869 png_memset(png_ptr, 0, sizeof (png_struct));
870
871 png_ptr->error_fn = error_fn;
872 png_ptr->warning_fn = warning_fn;
873 png_ptr->error_ptr = error_ptr;
874#ifdef PNG_USER_MEM_SUPPORTED
875 png_ptr->free_fn = free_fn;
876#endif
877
878 png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
879}
880
881void
882png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
883{
884 png_ptr->read_row_fn = read_row_fn;
885}
wxWidgets (Impactor)