[DINPUT]
[reactos.git] / reactos / dll / 3rdparty / libpng / pngread.c
1
2 /* pngread.c - read a PNG file
3 *
4 * Last changed in libpng 1.5.10 [March 8, 2012]
5 * Copyright (c) 1998-2012 Glenn Randers-Pehrson
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8 *
9 * This code is released under the libpng license.
10 * For conditions of distribution and use, see the disclaimer
11 * and license in png.h
12 *
13 * This file contains routines that an application calls directly to
14 * read a PNG file or stream.
15 */
16
17 #include "pngpriv.h"
18
19 #ifdef PNG_READ_SUPPORTED
20
21 /* Create a PNG structure for reading, and allocate any memory needed. */
22 PNG_FUNCTION(png_structp,PNGAPI
23 png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
24 png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
25 {
26
27 #ifdef PNG_USER_MEM_SUPPORTED
28 return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
29 warn_fn, NULL, NULL, NULL));
30 }
31
32 /* Alternate create PNG structure for reading, and allocate any memory
33 * needed.
34 */
35 PNG_FUNCTION(png_structp,PNGAPI
36 png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
37 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
38 png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
39 {
40 #endif /* PNG_USER_MEM_SUPPORTED */
41
42 #ifdef PNG_SETJMP_SUPPORTED
43 volatile
44 #endif
45 png_structp png_ptr;
46 volatile int png_cleanup_needed = 0;
47
48 #ifdef PNG_SETJMP_SUPPORTED
49 #ifdef USE_FAR_KEYWORD
50 jmp_buf tmp_jmpbuf;
51 #endif
52 #endif
53
54 png_debug(1, "in png_create_read_struct");
55
56 #ifdef PNG_USER_MEM_SUPPORTED
57 png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
58 malloc_fn, mem_ptr);
59 #else
60 png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
61 #endif
62 if (png_ptr == NULL)
63 return (NULL);
64
65 /* Added at libpng-1.2.6 */
66 #ifdef PNG_USER_LIMITS_SUPPORTED
67 png_ptr->user_width_max = PNG_USER_WIDTH_MAX;
68 png_ptr->user_height_max = PNG_USER_HEIGHT_MAX;
69
70 /* Added at libpng-1.2.43 and 1.4.0 */
71 png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
72
73 /* Added at libpng-1.2.43 and 1.4.1 */
74 png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
75 #endif
76
77 #ifdef PNG_SETJMP_SUPPORTED
78 /* Applications that neglect to set up their own setjmp() and then
79 * encounter a png_error() will longjmp here. Since the jmpbuf is
80 * then meaningless we abort instead of returning.
81 */
82 #ifdef USE_FAR_KEYWORD
83 if (setjmp(tmp_jmpbuf))
84 #else
85 if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */
86 #endif
87 PNG_ABORT();
88 #ifdef USE_FAR_KEYWORD
89 png_memcpy(png_jmpbuf(png_ptr), tmp_jmpbuf, png_sizeof(jmp_buf));
90 #endif
91 #endif /* PNG_SETJMP_SUPPORTED */
92
93 #ifdef PNG_USER_MEM_SUPPORTED
94 png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
95 #endif
96
97 png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
98
99 /* Call the general version checker (shared with read and write code): */
100 if (!png_user_version_check(png_ptr, user_png_ver))
101 png_cleanup_needed = 1;
102
103 if (!png_cleanup_needed)
104 {
105 /* Initialize zbuf - compression buffer */
106 png_ptr->zbuf_size = PNG_ZBUF_SIZE;
107 png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf_size);
108
109 if (png_ptr->zbuf == NULL)
110 png_cleanup_needed = 1;
111 }
112
113 png_ptr->zstream.zalloc = png_zalloc;
114 png_ptr->zstream.zfree = png_zfree;
115 png_ptr->zstream.opaque = (voidpf)png_ptr;
116
117 if (!png_cleanup_needed)
118 {
119 switch (inflateInit(&png_ptr->zstream))
120 {
121 case Z_OK:
122 break; /* Do nothing */
123
124 case Z_MEM_ERROR:
125 png_warning(png_ptr, "zlib memory error");
126 png_cleanup_needed = 1;
127 break;
128
129 case Z_STREAM_ERROR:
130 png_warning(png_ptr, "zlib stream error");
131 png_cleanup_needed = 1;
132 break;
133
134 case Z_VERSION_ERROR:
135 png_warning(png_ptr, "zlib version error");
136 png_cleanup_needed = 1;
137 break;
138
139 default: png_warning(png_ptr, "Unknown zlib error");
140 png_cleanup_needed = 1;
141 }
142 }
143
144 if (png_cleanup_needed)
145 {
146 /* Clean up PNG structure and deallocate any memory. */
147 png_free(png_ptr, png_ptr->zbuf);
148 png_ptr->zbuf = NULL;
149 #ifdef PNG_USER_MEM_SUPPORTED
150 png_destroy_struct_2((png_voidp)png_ptr,
151 (png_free_ptr)free_fn, (png_voidp)mem_ptr);
152 #else
153 png_destroy_struct((png_voidp)png_ptr);
154 #endif
155 return (NULL);
156 }
157
158 png_ptr->zstream.next_out = png_ptr->zbuf;
159 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
160
161 png_set_read_fn(png_ptr, NULL, NULL);
162
163
164 return (png_ptr);
165 }
166
167
168 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
169 /* Read the information before the actual image data. This has been
170 * changed in v0.90 to allow reading a file that already has the magic
171 * bytes read from the stream. You can tell libpng how many bytes have
172 * been read from the beginning of the stream (up to the maximum of 8)
173 * via png_set_sig_bytes(), and we will only check the remaining bytes
174 * here. The application can then have access to the signature bytes we
175 * read if it is determined that this isn't a valid PNG file.
176 */
177 void PNGAPI
178 png_read_info(png_structp png_ptr, png_infop info_ptr)
179 {
180 png_debug(1, "in png_read_info");
181
182 if (png_ptr == NULL || info_ptr == NULL)
183 return;
184
185 /* Read and check the PNG file signature. */
186 png_read_sig(png_ptr, info_ptr);
187
188 for (;;)
189 {
190 png_uint_32 length = png_read_chunk_header(png_ptr);
191 png_uint_32 chunk_name = 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 (chunk_name == png_IDAT)
197 if (png_ptr->mode & PNG_AFTER_IDAT)
198 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
199
200 if (chunk_name == png_IHDR)
201 png_handle_IHDR(png_ptr, info_ptr, length);
202
203 else if (chunk_name == png_IEND)
204 png_handle_IEND(png_ptr, info_ptr, length);
205
206 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
207 else if (png_chunk_unknown_handling(png_ptr, chunk_name) !=
208 PNG_HANDLE_CHUNK_AS_DEFAULT)
209 {
210 if (chunk_name == png_IDAT)
211 png_ptr->mode |= PNG_HAVE_IDAT;
212
213 png_handle_unknown(png_ptr, info_ptr, length);
214
215 if (chunk_name == png_PLTE)
216 png_ptr->mode |= PNG_HAVE_PLTE;
217
218 else if (chunk_name == png_IDAT)
219 {
220 if (!(png_ptr->mode & PNG_HAVE_IHDR))
221 png_error(png_ptr, "Missing IHDR before IDAT");
222
223 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
224 !(png_ptr->mode & PNG_HAVE_PLTE))
225 png_error(png_ptr, "Missing PLTE before IDAT");
226
227 break;
228 }
229 }
230 #endif
231 else if (chunk_name == png_PLTE)
232 png_handle_PLTE(png_ptr, info_ptr, length);
233
234 else if (chunk_name == png_IDAT)
235 {
236 if (!(png_ptr->mode & PNG_HAVE_IHDR))
237 png_error(png_ptr, "Missing IHDR before IDAT");
238
239 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
240 !(png_ptr->mode & PNG_HAVE_PLTE))
241 png_error(png_ptr, "Missing PLTE before IDAT");
242
243 png_ptr->idat_size = length;
244 png_ptr->mode |= PNG_HAVE_IDAT;
245 break;
246 }
247
248 #ifdef PNG_READ_bKGD_SUPPORTED
249 else if (chunk_name == png_bKGD)
250 png_handle_bKGD(png_ptr, info_ptr, length);
251 #endif
252
253 #ifdef PNG_READ_cHRM_SUPPORTED
254 else if (chunk_name == png_cHRM)
255 png_handle_cHRM(png_ptr, info_ptr, length);
256 #endif
257
258 #ifdef PNG_READ_gAMA_SUPPORTED
259 else if (chunk_name == png_gAMA)
260 png_handle_gAMA(png_ptr, info_ptr, length);
261 #endif
262
263 #ifdef PNG_READ_hIST_SUPPORTED
264 else if (chunk_name == png_hIST)
265 png_handle_hIST(png_ptr, info_ptr, length);
266 #endif
267
268 #ifdef PNG_READ_oFFs_SUPPORTED
269 else if (chunk_name == png_oFFs)
270 png_handle_oFFs(png_ptr, info_ptr, length);
271 #endif
272
273 #ifdef PNG_READ_pCAL_SUPPORTED
274 else if (chunk_name == png_pCAL)
275 png_handle_pCAL(png_ptr, info_ptr, length);
276 #endif
277
278 #ifdef PNG_READ_sCAL_SUPPORTED
279 else if (chunk_name == png_sCAL)
280 png_handle_sCAL(png_ptr, info_ptr, length);
281 #endif
282
283 #ifdef PNG_READ_pHYs_SUPPORTED
284 else if (chunk_name == png_pHYs)
285 png_handle_pHYs(png_ptr, info_ptr, length);
286 #endif
287
288 #ifdef PNG_READ_sBIT_SUPPORTED
289 else if (chunk_name == png_sBIT)
290 png_handle_sBIT(png_ptr, info_ptr, length);
291 #endif
292
293 #ifdef PNG_READ_sRGB_SUPPORTED
294 else if (chunk_name == png_sRGB)
295 png_handle_sRGB(png_ptr, info_ptr, length);
296 #endif
297
298 #ifdef PNG_READ_iCCP_SUPPORTED
299 else if (chunk_name == png_iCCP)
300 png_handle_iCCP(png_ptr, info_ptr, length);
301 #endif
302
303 #ifdef PNG_READ_sPLT_SUPPORTED
304 else if (chunk_name == png_sPLT)
305 png_handle_sPLT(png_ptr, info_ptr, length);
306 #endif
307
308 #ifdef PNG_READ_tEXt_SUPPORTED
309 else if (chunk_name == png_tEXt)
310 png_handle_tEXt(png_ptr, info_ptr, length);
311 #endif
312
313 #ifdef PNG_READ_tIME_SUPPORTED
314 else if (chunk_name == png_tIME)
315 png_handle_tIME(png_ptr, info_ptr, length);
316 #endif
317
318 #ifdef PNG_READ_tRNS_SUPPORTED
319 else if (chunk_name == png_tRNS)
320 png_handle_tRNS(png_ptr, info_ptr, length);
321 #endif
322
323 #ifdef PNG_READ_zTXt_SUPPORTED
324 else if (chunk_name == png_zTXt)
325 png_handle_zTXt(png_ptr, info_ptr, length);
326 #endif
327
328 #ifdef PNG_READ_iTXt_SUPPORTED
329 else if (chunk_name == png_iTXt)
330 png_handle_iTXt(png_ptr, info_ptr, length);
331 #endif
332
333 else
334 png_handle_unknown(png_ptr, info_ptr, length);
335 }
336 }
337 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
338
339 /* Optional call to update the users info_ptr structure */
340 void PNGAPI
341 png_read_update_info(png_structp png_ptr, png_infop info_ptr)
342 {
343 png_debug(1, "in png_read_update_info");
344
345 if (png_ptr == NULL)
346 return;
347
348 png_read_start_row(png_ptr);
349
350 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
351 png_read_transform_info(png_ptr, info_ptr);
352 #else
353 PNG_UNUSED(info_ptr)
354 #endif
355 }
356
357 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
358 /* Initialize palette, background, etc, after transformations
359 * are set, but before any reading takes place. This allows
360 * the user to obtain a gamma-corrected palette, for example.
361 * If the user doesn't call this, we will do it ourselves.
362 */
363 void PNGAPI
364 png_start_read_image(png_structp png_ptr)
365 {
366 png_debug(1, "in png_start_read_image");
367
368 if (png_ptr != NULL)
369 png_read_start_row(png_ptr);
370 }
371 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
372
373 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
374 void PNGAPI
375 png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
376 {
377 int ret;
378
379 png_row_info row_info;
380
381 if (png_ptr == NULL)
382 return;
383
384 png_debug2(1, "in png_read_row (row %lu, pass %d)",
385 (unsigned long)png_ptr->row_number, png_ptr->pass);
386
387 /* png_read_start_row sets the information (in particular iwidth) for this
388 * interlace pass.
389 */
390 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
391 png_read_start_row(png_ptr);
392
393 /* 1.5.6: row_info moved out of png_struct to a local here. */
394 row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
395 row_info.color_type = png_ptr->color_type;
396 row_info.bit_depth = png_ptr->bit_depth;
397 row_info.channels = png_ptr->channels;
398 row_info.pixel_depth = png_ptr->pixel_depth;
399 row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
400
401 if (png_ptr->row_number == 0 && png_ptr->pass == 0)
402 {
403 /* Check for transforms that have been set but were defined out */
404 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
405 if (png_ptr->transformations & PNG_INVERT_MONO)
406 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
407 #endif
408
409 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
410 if (png_ptr->transformations & PNG_FILLER)
411 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
412 #endif
413
414 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
415 !defined(PNG_READ_PACKSWAP_SUPPORTED)
416 if (png_ptr->transformations & PNG_PACKSWAP)
417 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
418 #endif
419
420 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
421 if (png_ptr->transformations & PNG_PACK)
422 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
423 #endif
424
425 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
426 if (png_ptr->transformations & PNG_SHIFT)
427 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
428 #endif
429
430 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
431 if (png_ptr->transformations & PNG_BGR)
432 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
433 #endif
434
435 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
436 if (png_ptr->transformations & PNG_SWAP_BYTES)
437 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
438 #endif
439 }
440
441 #ifdef PNG_READ_INTERLACING_SUPPORTED
442 /* If interlaced and we do not need a new row, combine row and return.
443 * Notice that the pixels we have from previous rows have been transformed
444 * already; we can only combine like with like (transformed or
445 * untransformed) and, because of the libpng API for interlaced images, this
446 * means we must transform before de-interlacing.
447 */
448 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
449 {
450 switch (png_ptr->pass)
451 {
452 case 0:
453 if (png_ptr->row_number & 0x07)
454 {
455 if (dsp_row != NULL)
456 png_combine_row(png_ptr, dsp_row, 1/*display*/);
457 png_read_finish_row(png_ptr);
458 return;
459 }
460 break;
461
462 case 1:
463 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
464 {
465 if (dsp_row != NULL)
466 png_combine_row(png_ptr, dsp_row, 1/*display*/);
467
468 png_read_finish_row(png_ptr);
469 return;
470 }
471 break;
472
473 case 2:
474 if ((png_ptr->row_number & 0x07) != 4)
475 {
476 if (dsp_row != NULL && (png_ptr->row_number & 4))
477 png_combine_row(png_ptr, dsp_row, 1/*display*/);
478
479 png_read_finish_row(png_ptr);
480 return;
481 }
482 break;
483
484 case 3:
485 if ((png_ptr->row_number & 3) || png_ptr->width < 3)
486 {
487 if (dsp_row != NULL)
488 png_combine_row(png_ptr, dsp_row, 1/*display*/);
489
490 png_read_finish_row(png_ptr);
491 return;
492 }
493 break;
494
495 case 4:
496 if ((png_ptr->row_number & 3) != 2)
497 {
498 if (dsp_row != NULL && (png_ptr->row_number & 2))
499 png_combine_row(png_ptr, dsp_row, 1/*display*/);
500
501 png_read_finish_row(png_ptr);
502 return;
503 }
504 break;
505 case 5:
506 if ((png_ptr->row_number & 1) || png_ptr->width < 2)
507 {
508 if (dsp_row != NULL)
509 png_combine_row(png_ptr, dsp_row, 1/*display*/);
510
511 png_read_finish_row(png_ptr);
512 return;
513 }
514 break;
515
516 default:
517 case 6:
518 if (!(png_ptr->row_number & 1))
519 {
520 png_read_finish_row(png_ptr);
521 return;
522 }
523 break;
524 }
525 }
526 #endif
527
528 if (!(png_ptr->mode & PNG_HAVE_IDAT))
529 png_error(png_ptr, "Invalid attempt to read row data");
530
531 png_ptr->zstream.next_out = png_ptr->row_buf;
532 png_ptr->zstream.avail_out =
533 (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
534 png_ptr->iwidth) + 1);
535
536 do
537 {
538 if (!(png_ptr->zstream.avail_in))
539 {
540 while (!png_ptr->idat_size)
541 {
542 png_crc_finish(png_ptr, 0);
543
544 png_ptr->idat_size = png_read_chunk_header(png_ptr);
545 if (png_ptr->chunk_name != png_IDAT)
546 png_error(png_ptr, "Not enough image data");
547 }
548 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;
549 png_ptr->zstream.next_in = png_ptr->zbuf;
550 if (png_ptr->zbuf_size > png_ptr->idat_size)
551 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
552 png_crc_read(png_ptr, png_ptr->zbuf,
553 (png_size_t)png_ptr->zstream.avail_in);
554 png_ptr->idat_size -= png_ptr->zstream.avail_in;
555 }
556
557 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
558
559 if (ret == Z_STREAM_END)
560 {
561 if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||
562 png_ptr->idat_size)
563 png_benign_error(png_ptr, "Extra compressed data");
564 png_ptr->mode |= PNG_AFTER_IDAT;
565 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
566 break;
567 }
568
569 if (ret != Z_OK)
570 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
571 "Decompression error");
572
573 } while (png_ptr->zstream.avail_out);
574
575 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
576 {
577 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
578 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
579 png_ptr->prev_row + 1, png_ptr->row_buf[0]);
580 else
581 png_error(png_ptr, "bad adaptive filter value");
582 }
583
584 /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
585 * 1.5.6, while the buffer really is this big in current versions of libpng
586 * it may not be in the future, so this was changed just to copy the
587 * interlaced count:
588 */
589 png_memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
590
591 #ifdef PNG_MNG_FEATURES_SUPPORTED
592 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
593 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
594 {
595 /* Intrapixel differencing */
596 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
597 }
598 #endif
599
600
601 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
602 if (png_ptr->transformations)
603 png_do_read_transformations(png_ptr, &row_info);
604 #endif
605
606 /* The transformed pixel depth should match the depth now in row_info. */
607 if (png_ptr->transformed_pixel_depth == 0)
608 {
609 png_ptr->transformed_pixel_depth = row_info.pixel_depth;
610 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
611 png_error(png_ptr, "sequential row overflow");
612 }
613
614 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
615 png_error(png_ptr, "internal sequential row size calculation error");
616
617 #ifdef PNG_READ_INTERLACING_SUPPORTED
618 /* Blow up interlaced rows to full size */
619 if (png_ptr->interlaced &&
620 (png_ptr->transformations & PNG_INTERLACE))
621 {
622 if (png_ptr->pass < 6)
623 png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
624 png_ptr->transformations);
625
626 if (dsp_row != NULL)
627 png_combine_row(png_ptr, dsp_row, 1/*display*/);
628
629 if (row != NULL)
630 png_combine_row(png_ptr, row, 0/*row*/);
631 }
632
633 else
634 #endif
635 {
636 if (row != NULL)
637 png_combine_row(png_ptr, row, -1/*ignored*/);
638
639 if (dsp_row != NULL)
640 png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
641 }
642 png_read_finish_row(png_ptr);
643
644 if (png_ptr->read_row_fn != NULL)
645 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
646 }
647 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
648
649 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
650 /* Read one or more rows of image data. If the image is interlaced,
651 * and png_set_interlace_handling() has been called, the rows need to
652 * contain the contents of the rows from the previous pass. If the
653 * image has alpha or transparency, and png_handle_alpha()[*] has been
654 * called, the rows contents must be initialized to the contents of the
655 * screen.
656 *
657 * "row" holds the actual image, and pixels are placed in it
658 * as they arrive. If the image is displayed after each pass, it will
659 * appear to "sparkle" in. "display_row" can be used to display a
660 * "chunky" progressive image, with finer detail added as it becomes
661 * available. If you do not want this "chunky" display, you may pass
662 * NULL for display_row. If you do not want the sparkle display, and
663 * you have not called png_handle_alpha(), you may pass NULL for rows.
664 * If you have called png_handle_alpha(), and the image has either an
665 * alpha channel or a transparency chunk, you must provide a buffer for
666 * rows. In this case, you do not have to provide a display_row buffer
667 * also, but you may. If the image is not interlaced, or if you have
668 * not called png_set_interlace_handling(), the display_row buffer will
669 * be ignored, so pass NULL to it.
670 *
671 * [*] png_handle_alpha() does not exist yet, as of this version of libpng
672 */
673
674 void PNGAPI
675 png_read_rows(png_structp png_ptr, png_bytepp row,
676 png_bytepp display_row, png_uint_32 num_rows)
677 {
678 png_uint_32 i;
679 png_bytepp rp;
680 png_bytepp dp;
681
682 png_debug(1, "in png_read_rows");
683
684 if (png_ptr == NULL)
685 return;
686
687 rp = row;
688 dp = display_row;
689 if (rp != NULL && dp != NULL)
690 for (i = 0; i < num_rows; i++)
691 {
692 png_bytep rptr = *rp++;
693 png_bytep dptr = *dp++;
694
695 png_read_row(png_ptr, rptr, dptr);
696 }
697
698 else if (rp != NULL)
699 for (i = 0; i < num_rows; i++)
700 {
701 png_bytep rptr = *rp;
702 png_read_row(png_ptr, rptr, NULL);
703 rp++;
704 }
705
706 else if (dp != NULL)
707 for (i = 0; i < num_rows; i++)
708 {
709 png_bytep dptr = *dp;
710 png_read_row(png_ptr, NULL, dptr);
711 dp++;
712 }
713 }
714 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
715
716 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
717 /* Read the entire image. If the image has an alpha channel or a tRNS
718 * chunk, and you have called png_handle_alpha()[*], you will need to
719 * initialize the image to the current image that PNG will be overlaying.
720 * We set the num_rows again here, in case it was incorrectly set in
721 * png_read_start_row() by a call to png_read_update_info() or
722 * png_start_read_image() if png_set_interlace_handling() wasn't called
723 * prior to either of these functions like it should have been. You can
724 * only call this function once. If you desire to have an image for
725 * each pass of a interlaced image, use png_read_rows() instead.
726 *
727 * [*] png_handle_alpha() does not exist yet, as of this version of libpng
728 */
729 void PNGAPI
730 png_read_image(png_structp png_ptr, png_bytepp image)
731 {
732 png_uint_32 i, image_height;
733 int pass, j;
734 png_bytepp rp;
735
736 png_debug(1, "in png_read_image");
737
738 if (png_ptr == NULL)
739 return;
740
741 #ifdef PNG_READ_INTERLACING_SUPPORTED
742 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
743 {
744 pass = png_set_interlace_handling(png_ptr);
745 /* And make sure transforms are initialized. */
746 png_start_read_image(png_ptr);
747 }
748 else
749 {
750 if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE))
751 {
752 /* Caller called png_start_read_image or png_read_update_info without
753 * first turning on the PNG_INTERLACE transform. We can fix this here,
754 * but the caller should do it!
755 */
756 png_warning(png_ptr, "Interlace handling should be turned on when "
757 "using png_read_image");
758 /* Make sure this is set correctly */
759 png_ptr->num_rows = png_ptr->height;
760 }
761
762 /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in
763 * the above error case.
764 */
765 pass = png_set_interlace_handling(png_ptr);
766 }
767 #else
768 if (png_ptr->interlaced)
769 png_error(png_ptr,
770 "Cannot read interlaced image -- interlace handler disabled");
771
772 pass = 1;
773 #endif
774
775 image_height=png_ptr->height;
776
777 for (j = 0; j < pass; j++)
778 {
779 rp = image;
780 for (i = 0; i < image_height; i++)
781 {
782 png_read_row(png_ptr, *rp, NULL);
783 rp++;
784 }
785 }
786 }
787 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
788
789 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
790 /* Read the end of the PNG file. Will not read past the end of the
791 * file, will verify the end is accurate, and will read any comments
792 * or time information at the end of the file, if info is not NULL.
793 */
794 void PNGAPI
795 png_read_end(png_structp png_ptr, png_infop info_ptr)
796 {
797 png_debug(1, "in png_read_end");
798
799 if (png_ptr == NULL)
800 return;
801
802 png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
803
804 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
805 /* Report invalid palette index; added at libng-1.5.10 */
806 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
807 png_ptr->num_palette_max > png_ptr->num_palette)
808 png_benign_error(png_ptr, "Read palette index exceeding num_palette");
809 #endif
810
811 do
812 {
813 png_uint_32 length = png_read_chunk_header(png_ptr);
814 png_uint_32 chunk_name = png_ptr->chunk_name;
815
816 if (chunk_name == png_IHDR)
817 png_handle_IHDR(png_ptr, info_ptr, length);
818
819 else if (chunk_name == png_IEND)
820 png_handle_IEND(png_ptr, info_ptr, length);
821
822 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
823 else if (png_chunk_unknown_handling(png_ptr, chunk_name) !=
824 PNG_HANDLE_CHUNK_AS_DEFAULT)
825 {
826 if (chunk_name == png_IDAT)
827 {
828 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
829 png_benign_error(png_ptr, "Too many IDATs found");
830 }
831 png_handle_unknown(png_ptr, info_ptr, length);
832 if (chunk_name == png_PLTE)
833 png_ptr->mode |= PNG_HAVE_PLTE;
834 }
835 #endif
836
837 else if (chunk_name == png_IDAT)
838 {
839 /* Zero length IDATs are legal after the last IDAT has been
840 * read, but not after other chunks have been read.
841 */
842 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
843 png_benign_error(png_ptr, "Too many IDATs found");
844
845 png_crc_finish(png_ptr, length);
846 }
847 else if (chunk_name == png_PLTE)
848 png_handle_PLTE(png_ptr, info_ptr, length);
849
850 #ifdef PNG_READ_bKGD_SUPPORTED
851 else if (chunk_name == png_bKGD)
852 png_handle_bKGD(png_ptr, info_ptr, length);
853 #endif
854
855 #ifdef PNG_READ_cHRM_SUPPORTED
856 else if (chunk_name == png_cHRM)
857 png_handle_cHRM(png_ptr, info_ptr, length);
858 #endif
859
860 #ifdef PNG_READ_gAMA_SUPPORTED
861 else if (chunk_name == png_gAMA)
862 png_handle_gAMA(png_ptr, info_ptr, length);
863 #endif
864
865 #ifdef PNG_READ_hIST_SUPPORTED
866 else if (chunk_name == png_hIST)
867 png_handle_hIST(png_ptr, info_ptr, length);
868 #endif
869
870 #ifdef PNG_READ_oFFs_SUPPORTED
871 else if (chunk_name == png_oFFs)
872 png_handle_oFFs(png_ptr, info_ptr, length);
873 #endif
874
875 #ifdef PNG_READ_pCAL_SUPPORTED
876 else if (chunk_name == png_pCAL)
877 png_handle_pCAL(png_ptr, info_ptr, length);
878 #endif
879
880 #ifdef PNG_READ_sCAL_SUPPORTED
881 else if (chunk_name == png_sCAL)
882 png_handle_sCAL(png_ptr, info_ptr, length);
883 #endif
884
885 #ifdef PNG_READ_pHYs_SUPPORTED
886 else if (chunk_name == png_pHYs)
887 png_handle_pHYs(png_ptr, info_ptr, length);
888 #endif
889
890 #ifdef PNG_READ_sBIT_SUPPORTED
891 else if (chunk_name == png_sBIT)
892 png_handle_sBIT(png_ptr, info_ptr, length);
893 #endif
894
895 #ifdef PNG_READ_sRGB_SUPPORTED
896 else if (chunk_name == png_sRGB)
897 png_handle_sRGB(png_ptr, info_ptr, length);
898 #endif
899
900 #ifdef PNG_READ_iCCP_SUPPORTED
901 else if (chunk_name == png_iCCP)
902 png_handle_iCCP(png_ptr, info_ptr, length);
903 #endif
904
905 #ifdef PNG_READ_sPLT_SUPPORTED
906 else if (chunk_name == png_sPLT)
907 png_handle_sPLT(png_ptr, info_ptr, length);
908 #endif
909
910 #ifdef PNG_READ_tEXt_SUPPORTED
911 else if (chunk_name == png_tEXt)
912 png_handle_tEXt(png_ptr, info_ptr, length);
913 #endif
914
915 #ifdef PNG_READ_tIME_SUPPORTED
916 else if (chunk_name == png_tIME)
917 png_handle_tIME(png_ptr, info_ptr, length);
918 #endif
919
920 #ifdef PNG_READ_tRNS_SUPPORTED
921 else if (chunk_name == png_tRNS)
922 png_handle_tRNS(png_ptr, info_ptr, length);
923 #endif
924
925 #ifdef PNG_READ_zTXt_SUPPORTED
926 else if (chunk_name == png_zTXt)
927 png_handle_zTXt(png_ptr, info_ptr, length);
928 #endif
929
930 #ifdef PNG_READ_iTXt_SUPPORTED
931 else if (chunk_name == png_iTXt)
932 png_handle_iTXt(png_ptr, info_ptr, length);
933 #endif
934
935 else
936 png_handle_unknown(png_ptr, info_ptr, length);
937 } while (!(png_ptr->mode & PNG_HAVE_IEND));
938 }
939 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
940
941 /* Free all memory used by the read */
942 void PNGAPI
943 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
944 png_infopp end_info_ptr_ptr)
945 {
946 png_structp png_ptr = NULL;
947 png_infop info_ptr = NULL, end_info_ptr = NULL;
948 #ifdef PNG_USER_MEM_SUPPORTED
949 png_free_ptr free_fn = NULL;
950 png_voidp mem_ptr = NULL;
951 #endif
952
953 png_debug(1, "in png_destroy_read_struct");
954
955 if (png_ptr_ptr != NULL)
956 png_ptr = *png_ptr_ptr;
957 if (png_ptr == NULL)
958 return;
959
960 #ifdef PNG_USER_MEM_SUPPORTED
961 free_fn = png_ptr->free_fn;
962 mem_ptr = png_ptr->mem_ptr;
963 #endif
964
965 if (info_ptr_ptr != NULL)
966 info_ptr = *info_ptr_ptr;
967
968 if (end_info_ptr_ptr != NULL)
969 end_info_ptr = *end_info_ptr_ptr;
970
971 png_read_destroy(png_ptr, info_ptr, end_info_ptr);
972
973 if (info_ptr != NULL)
974 {
975 #ifdef PNG_TEXT_SUPPORTED
976 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);
977 #endif
978
979 #ifdef PNG_USER_MEM_SUPPORTED
980 png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
981 (png_voidp)mem_ptr);
982 #else
983 png_destroy_struct((png_voidp)info_ptr);
984 #endif
985 *info_ptr_ptr = NULL;
986 }
987
988 if (end_info_ptr != NULL)
989 {
990 #ifdef PNG_READ_TEXT_SUPPORTED
991 png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);
992 #endif
993 #ifdef PNG_USER_MEM_SUPPORTED
994 png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
995 (png_voidp)mem_ptr);
996 #else
997 png_destroy_struct((png_voidp)end_info_ptr);
998 #endif
999 *end_info_ptr_ptr = NULL;
1000 }
1001
1002 if (png_ptr != NULL)
1003 {
1004 #ifdef PNG_USER_MEM_SUPPORTED
1005 png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
1006 (png_voidp)mem_ptr);
1007 #else
1008 png_destroy_struct((png_voidp)png_ptr);
1009 #endif
1010 *png_ptr_ptr = NULL;
1011 }
1012 }
1013
1014 /* Free all memory used by the read (old method) */
1015 void /* PRIVATE */
1016 png_read_destroy(png_structp png_ptr, png_infop info_ptr,
1017 png_infop end_info_ptr)
1018 {
1019 #ifdef PNG_SETJMP_SUPPORTED
1020 jmp_buf tmp_jmp;
1021 #endif
1022 png_error_ptr error_fn;
1023 #ifdef PNG_WARNINGS_SUPPORTED
1024 png_error_ptr warning_fn;
1025 #endif
1026 png_voidp error_ptr;
1027 #ifdef PNG_USER_MEM_SUPPORTED
1028 png_free_ptr free_fn;
1029 #endif
1030
1031 png_debug(1, "in png_read_destroy");
1032
1033 if (info_ptr != NULL)
1034 png_info_destroy(png_ptr, info_ptr);
1035
1036 if (end_info_ptr != NULL)
1037 png_info_destroy(png_ptr, end_info_ptr);
1038
1039 #ifdef PNG_READ_GAMMA_SUPPORTED
1040 png_destroy_gamma_table(png_ptr);
1041 #endif
1042
1043 png_free(png_ptr, png_ptr->zbuf);
1044 png_free(png_ptr, png_ptr->big_row_buf);
1045 png_free(png_ptr, png_ptr->big_prev_row);
1046 png_free(png_ptr, png_ptr->chunkdata);
1047
1048 #ifdef PNG_READ_QUANTIZE_SUPPORTED
1049 png_free(png_ptr, png_ptr->palette_lookup);
1050 png_free(png_ptr, png_ptr->quantize_index);
1051 #endif
1052
1053 if (png_ptr->free_me & PNG_FREE_PLTE)
1054 png_zfree(png_ptr, png_ptr->palette);
1055 png_ptr->free_me &= ~PNG_FREE_PLTE;
1056
1057 #if defined(PNG_tRNS_SUPPORTED) || \
1058 defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
1059 if (png_ptr->free_me & PNG_FREE_TRNS)
1060 png_free(png_ptr, png_ptr->trans_alpha);
1061 png_ptr->free_me &= ~PNG_FREE_TRNS;
1062 #endif
1063
1064 #ifdef PNG_READ_hIST_SUPPORTED
1065 if (png_ptr->free_me & PNG_FREE_HIST)
1066 png_free(png_ptr, png_ptr->hist);
1067 png_ptr->free_me &= ~PNG_FREE_HIST;
1068 #endif
1069
1070 inflateEnd(&png_ptr->zstream);
1071
1072 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1073 png_free(png_ptr, png_ptr->save_buffer);
1074 #endif
1075
1076 /* Save the important info out of the png_struct, in case it is
1077 * being used again.
1078 */
1079 #ifdef PNG_SETJMP_SUPPORTED
1080 png_memcpy(tmp_jmp, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
1081 #endif
1082
1083 error_fn = png_ptr->error_fn;
1084 #ifdef PNG_WARNINGS_SUPPORTED
1085 warning_fn = png_ptr->warning_fn;
1086 #endif
1087 error_ptr = png_ptr->error_ptr;
1088 #ifdef PNG_USER_MEM_SUPPORTED
1089 free_fn = png_ptr->free_fn;
1090 #endif
1091
1092 png_memset(png_ptr, 0, png_sizeof(png_struct));
1093
1094 png_ptr->error_fn = error_fn;
1095 #ifdef PNG_WARNINGS_SUPPORTED
1096 png_ptr->warning_fn = warning_fn;
1097 #endif
1098 png_ptr->error_ptr = error_ptr;
1099 #ifdef PNG_USER_MEM_SUPPORTED
1100 png_ptr->free_fn = free_fn;
1101 #endif
1102
1103 #ifdef PNG_SETJMP_SUPPORTED
1104 png_memcpy(png_ptr->longjmp_buffer, tmp_jmp, png_sizeof(jmp_buf));
1105 #endif
1106
1107 }
1108
1109 void PNGAPI
1110 png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
1111 {
1112 if (png_ptr == NULL)
1113 return;
1114
1115 png_ptr->read_row_fn = read_row_fn;
1116 }
1117
1118
1119 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1120 #ifdef PNG_INFO_IMAGE_SUPPORTED
1121 void PNGAPI
1122 png_read_png(png_structp png_ptr, png_infop info_ptr,
1123 int transforms,
1124 voidp params)
1125 {
1126 int row;
1127
1128 if (png_ptr == NULL || info_ptr == NULL)
1129 return;
1130
1131 /* png_read_info() gives us all of the information from the
1132 * PNG file before the first IDAT (image data chunk).
1133 */
1134 png_read_info(png_ptr, info_ptr);
1135 if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
1136 png_error(png_ptr, "Image is too high to process with png_read_png()");
1137
1138 /* -------------- image transformations start here ------------------- */
1139
1140 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
1141 /* Tell libpng to strip 16-bit/color files down to 8 bits per color.
1142 */
1143 if (transforms & PNG_TRANSFORM_SCALE_16)
1144 {
1145 /* Added at libpng-1.5.4. "strip_16" produces the same result that it
1146 * did in earlier versions, while "scale_16" is now more accurate.
1147 */
1148 png_set_scale_16(png_ptr);
1149 }
1150 #endif
1151
1152 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
1153 /* If both SCALE and STRIP are required pngrtran will effectively cancel the
1154 * latter by doing SCALE first. This is ok and allows apps not to check for
1155 * which is supported to get the right answer.
1156 */
1157 if (transforms & PNG_TRANSFORM_STRIP_16)
1158 png_set_strip_16(png_ptr);
1159 #endif
1160
1161 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
1162 /* Strip alpha bytes from the input data without combining with
1163 * the background (not recommended).
1164 */
1165 if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
1166 png_set_strip_alpha(png_ptr);
1167 #endif
1168
1169 #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
1170 /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
1171 * byte into separate bytes (useful for paletted and grayscale images).
1172 */
1173 if (transforms & PNG_TRANSFORM_PACKING)
1174 png_set_packing(png_ptr);
1175 #endif
1176
1177 #ifdef PNG_READ_PACKSWAP_SUPPORTED
1178 /* Change the order of packed pixels to least significant bit first
1179 * (not useful if you are using png_set_packing).
1180 */
1181 if (transforms & PNG_TRANSFORM_PACKSWAP)
1182 png_set_packswap(png_ptr);
1183 #endif
1184
1185 #ifdef PNG_READ_EXPAND_SUPPORTED
1186 /* Expand paletted colors into true RGB triplets
1187 * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel
1188 * Expand paletted or RGB images with transparency to full alpha
1189 * channels so the data will be available as RGBA quartets.
1190 */
1191 if (transforms & PNG_TRANSFORM_EXPAND)
1192 if ((png_ptr->bit_depth < 8) ||
1193 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
1194 (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
1195 png_set_expand(png_ptr);
1196 #endif
1197
1198 /* We don't handle background color or gamma transformation or quantizing.
1199 */
1200
1201 #ifdef PNG_READ_INVERT_SUPPORTED
1202 /* Invert monochrome files to have 0 as white and 1 as black
1203 */
1204 if (transforms & PNG_TRANSFORM_INVERT_MONO)
1205 png_set_invert_mono(png_ptr);
1206 #endif
1207
1208 #ifdef PNG_READ_SHIFT_SUPPORTED
1209 /* If you want to shift the pixel values from the range [0,255] or
1210 * [0,65535] to the original [0,7] or [0,31], or whatever range the
1211 * colors were originally in:
1212 */
1213 if ((transforms & PNG_TRANSFORM_SHIFT)
1214 && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
1215 {
1216 png_color_8p sig_bit;
1217
1218 png_get_sBIT(png_ptr, info_ptr, &sig_bit);
1219 png_set_shift(png_ptr, sig_bit);
1220 }
1221 #endif
1222
1223 #ifdef PNG_READ_BGR_SUPPORTED
1224 /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
1225 if (transforms & PNG_TRANSFORM_BGR)
1226 png_set_bgr(png_ptr);
1227 #endif
1228
1229 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
1230 /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
1231 if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
1232 png_set_swap_alpha(png_ptr);
1233 #endif
1234
1235 #ifdef PNG_READ_SWAP_SUPPORTED
1236 /* Swap bytes of 16-bit files to least significant byte first */
1237 if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
1238 png_set_swap(png_ptr);
1239 #endif
1240
1241 /* Added at libpng-1.2.41 */
1242 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
1243 /* Invert the alpha channel from opacity to transparency */
1244 if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
1245 png_set_invert_alpha(png_ptr);
1246 #endif
1247
1248 /* Added at libpng-1.2.41 */
1249 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
1250 /* Expand grayscale image to RGB */
1251 if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)
1252 png_set_gray_to_rgb(png_ptr);
1253 #endif
1254
1255 /* Added at libpng-1.5.4 */
1256 #ifdef PNG_READ_EXPAND_16_SUPPORTED
1257 if (transforms & PNG_TRANSFORM_EXPAND_16)
1258 png_set_expand_16(png_ptr);
1259 #endif
1260
1261 /* We don't handle adding filler bytes */
1262
1263 /* We use png_read_image and rely on that for interlace handling, but we also
1264 * call png_read_update_info therefore must turn on interlace handling now:
1265 */
1266 (void)png_set_interlace_handling(png_ptr);
1267
1268 /* Optional call to gamma correct and add the background to the palette
1269 * and update info structure. REQUIRED if you are expecting libpng to
1270 * update the palette for you (i.e., you selected such a transform above).
1271 */
1272 png_read_update_info(png_ptr, info_ptr);
1273
1274 /* -------------- image transformations end here ------------------- */
1275
1276 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1277 if (info_ptr->row_pointers == NULL)
1278 {
1279 png_uint_32 iptr;
1280
1281 info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
1282 info_ptr->height * png_sizeof(png_bytep));
1283 for (iptr=0; iptr<info_ptr->height; iptr++)
1284 info_ptr->row_pointers[iptr] = NULL;
1285
1286 info_ptr->free_me |= PNG_FREE_ROWS;
1287
1288 for (row = 0; row < (int)info_ptr->height; row++)
1289 info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
1290 png_get_rowbytes(png_ptr, info_ptr));
1291 }
1292
1293 png_read_image(png_ptr, info_ptr->row_pointers);
1294 info_ptr->valid |= PNG_INFO_IDAT;
1295
1296 /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
1297 png_read_end(png_ptr, info_ptr);
1298
1299 PNG_UNUSED(transforms) /* Quiet compiler warnings */
1300 PNG_UNUSED(params)
1301
1302 }
1303 #endif /* PNG_INFO_IMAGE_SUPPORTED */
1304 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
1305 #endif /* PNG_READ_SUPPORTED */