istereo2
diff libs/libpng/pngread.c @ 2:81d35769f546
added the tunnel effect source
| author | John Tsiombikas <nuclear@member.fsf.org> |
|---|---|
| date | Sat, 19 Sep 2015 05:51:51 +0300 |
| parents | |
| children |
line diff
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/libs/libpng/pngread.c Sat Sep 19 05:51:51 2015 +0300 1.3 @@ -0,0 +1,1459 @@ 1.4 + 1.5 +/* pngread.c - read a PNG file 1.6 + * 1.7 + * Last changed in libpng 1.2.30 [August 15, 2008] 1.8 + * For conditions of distribution and use, see copyright notice in png.h 1.9 + * Copyright (c) 1998-2008 Glenn Randers-Pehrson 1.10 + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 1.11 + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 1.12 + * 1.13 + * This file contains routines that an application calls directly to 1.14 + * read a PNG file or stream. 1.15 + */ 1.16 + 1.17 +#define PNG_INTERNAL 1.18 +#include "png.h" 1.19 +#if defined(PNG_READ_SUPPORTED) 1.20 + 1.21 +/* Create a PNG structure for reading, and allocate any memory needed. */ 1.22 +png_structp PNGAPI 1.23 +png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, 1.24 + png_error_ptr error_fn, png_error_ptr warn_fn) 1.25 +{ 1.26 + 1.27 +#ifdef PNG_USER_MEM_SUPPORTED 1.28 + return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, 1.29 + warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); 1.30 +} 1.31 + 1.32 +/* Alternate create PNG structure for reading, and allocate any memory needed. */ 1.33 +png_structp PNGAPI 1.34 +png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, 1.35 + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 1.36 + png_malloc_ptr malloc_fn, png_free_ptr free_fn) 1.37 +{ 1.38 +#endif /* PNG_USER_MEM_SUPPORTED */ 1.39 + 1.40 +#ifdef PNG_SETJMP_SUPPORTED 1.41 + volatile 1.42 +#endif 1.43 + png_structp png_ptr; 1.44 + 1.45 +#ifdef PNG_SETJMP_SUPPORTED 1.46 +#ifdef USE_FAR_KEYWORD 1.47 + jmp_buf jmpbuf; 1.48 +#endif 1.49 +#endif 1.50 + 1.51 + int i; 1.52 + 1.53 + png_debug(1, "in png_create_read_struct\n"); 1.54 +#ifdef PNG_USER_MEM_SUPPORTED 1.55 + png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, 1.56 + (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); 1.57 +#else 1.58 + png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); 1.59 +#endif 1.60 + if (png_ptr == NULL) 1.61 + return (NULL); 1.62 + 1.63 + /* added at libpng-1.2.6 */ 1.64 +#ifdef PNG_SET_USER_LIMITS_SUPPORTED 1.65 + png_ptr->user_width_max=PNG_USER_WIDTH_MAX; 1.66 + png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; 1.67 +#endif 1.68 + 1.69 +#ifdef PNG_SETJMP_SUPPORTED 1.70 +#ifdef USE_FAR_KEYWORD 1.71 + if (setjmp(jmpbuf)) 1.72 +#else 1.73 + if (setjmp(png_ptr->jmpbuf)) 1.74 +#endif 1.75 + { 1.76 + png_free(png_ptr, png_ptr->zbuf); 1.77 + png_ptr->zbuf = NULL; 1.78 +#ifdef PNG_USER_MEM_SUPPORTED 1.79 + png_destroy_struct_2((png_voidp)png_ptr, 1.80 + (png_free_ptr)free_fn, (png_voidp)mem_ptr); 1.81 +#else 1.82 + png_destroy_struct((png_voidp)png_ptr); 1.83 +#endif 1.84 + return (NULL); 1.85 + } 1.86 +#ifdef USE_FAR_KEYWORD 1.87 + png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); 1.88 +#endif 1.89 +#endif 1.90 + 1.91 +#ifdef PNG_USER_MEM_SUPPORTED 1.92 + png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); 1.93 +#endif 1.94 + 1.95 + png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); 1.96 + 1.97 + if (user_png_ver) 1.98 + { 1.99 + i = 0; 1.100 + do 1.101 + { 1.102 + if (user_png_ver[i] != png_libpng_ver[i]) 1.103 + png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 1.104 + } while (png_libpng_ver[i++]); 1.105 + } 1.106 + else 1.107 + png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 1.108 + 1.109 + 1.110 + if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) 1.111 + { 1.112 + /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so 1.113 + * we must recompile any applications that use any older library version. 1.114 + * For versions after libpng 1.0, we will be compatible, so we need 1.115 + * only check the first digit. 1.116 + */ 1.117 + if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || 1.118 + (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || 1.119 + (user_png_ver[0] == '0' && user_png_ver[2] < '9')) 1.120 + { 1.121 +#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) 1.122 + char msg[80]; 1.123 + if (user_png_ver) 1.124 + { 1.125 + png_snprintf(msg, 80, 1.126 + "Application was compiled with png.h from libpng-%.20s", 1.127 + user_png_ver); 1.128 + png_warning(png_ptr, msg); 1.129 + } 1.130 + png_snprintf(msg, 80, 1.131 + "Application is running with png.c from libpng-%.20s", 1.132 + png_libpng_ver); 1.133 + png_warning(png_ptr, msg); 1.134 +#endif 1.135 +#ifdef PNG_ERROR_NUMBERS_SUPPORTED 1.136 + png_ptr->flags = 0; 1.137 +#endif 1.138 + png_error(png_ptr, 1.139 + "Incompatible libpng version in application and library"); 1.140 + } 1.141 + } 1.142 + 1.143 + /* initialize zbuf - compression buffer */ 1.144 + png_ptr->zbuf_size = PNG_ZBUF_SIZE; 1.145 + png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, 1.146 + (png_uint_32)png_ptr->zbuf_size); 1.147 + png_ptr->zstream.zalloc = png_zalloc; 1.148 + png_ptr->zstream.zfree = png_zfree; 1.149 + png_ptr->zstream.opaque = (voidpf)png_ptr; 1.150 + 1.151 + switch (inflateInit(&png_ptr->zstream)) 1.152 + { 1.153 + case Z_OK: /* Do nothing */ break; 1.154 + case Z_MEM_ERROR: 1.155 + case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; 1.156 + case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break; 1.157 + default: png_error(png_ptr, "Unknown zlib error"); 1.158 + } 1.159 + 1.160 + png_ptr->zstream.next_out = png_ptr->zbuf; 1.161 + png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; 1.162 + 1.163 + png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); 1.164 + 1.165 +#ifdef PNG_SETJMP_SUPPORTED 1.166 +/* Applications that neglect to set up their own setjmp() and then encounter 1.167 + a png_error() will longjmp here. Since the jmpbuf is then meaningless we 1.168 + abort instead of returning. */ 1.169 +#ifdef USE_FAR_KEYWORD 1.170 + if (setjmp(jmpbuf)) 1.171 + PNG_ABORT(); 1.172 + png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); 1.173 +#else 1.174 + if (setjmp(png_ptr->jmpbuf)) 1.175 + PNG_ABORT(); 1.176 +#endif 1.177 +#endif 1.178 + return (png_ptr); 1.179 +} 1.180 + 1.181 +#if defined(PNG_1_0_X) || defined(PNG_1_2_X) 1.182 +/* Initialize PNG structure for reading, and allocate any memory needed. 1.183 + This interface is deprecated in favour of the png_create_read_struct(), 1.184 + and it will disappear as of libpng-1.3.0. */ 1.185 +#undef png_read_init 1.186 +void PNGAPI 1.187 +png_read_init(png_structp png_ptr) 1.188 +{ 1.189 + /* We only come here via pre-1.0.7-compiled applications */ 1.190 + png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); 1.191 +} 1.192 + 1.193 +void PNGAPI 1.194 +png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, 1.195 + png_size_t png_struct_size, png_size_t png_info_size) 1.196 +{ 1.197 + /* We only come here via pre-1.0.12-compiled applications */ 1.198 + if (png_ptr == NULL) return; 1.199 +#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) 1.200 + if (png_sizeof(png_struct) > png_struct_size || 1.201 + png_sizeof(png_info) > png_info_size) 1.202 + { 1.203 + char msg[80]; 1.204 + png_ptr->warning_fn = NULL; 1.205 + if (user_png_ver) 1.206 + { 1.207 + png_snprintf(msg, 80, 1.208 + "Application was compiled with png.h from libpng-%.20s", 1.209 + user_png_ver); 1.210 + png_warning(png_ptr, msg); 1.211 + } 1.212 + png_snprintf(msg, 80, 1.213 + "Application is running with png.c from libpng-%.20s", 1.214 + png_libpng_ver); 1.215 + png_warning(png_ptr, msg); 1.216 + } 1.217 +#endif 1.218 + if (png_sizeof(png_struct) > png_struct_size) 1.219 + { 1.220 + png_ptr->error_fn = NULL; 1.221 +#ifdef PNG_ERROR_NUMBERS_SUPPORTED 1.222 + png_ptr->flags = 0; 1.223 +#endif 1.224 + png_error(png_ptr, 1.225 + "The png struct allocated by the application for reading is too small."); 1.226 + } 1.227 + if (png_sizeof(png_info) > png_info_size) 1.228 + { 1.229 + png_ptr->error_fn = NULL; 1.230 +#ifdef PNG_ERROR_NUMBERS_SUPPORTED 1.231 + png_ptr->flags = 0; 1.232 +#endif 1.233 + png_error(png_ptr, 1.234 + "The info struct allocated by application for reading is too small."); 1.235 + } 1.236 + png_read_init_3(&png_ptr, user_png_ver, png_struct_size); 1.237 +} 1.238 +#endif /* PNG_1_0_X || PNG_1_2_X */ 1.239 + 1.240 +void PNGAPI 1.241 +png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, 1.242 + png_size_t png_struct_size) 1.243 +{ 1.244 +#ifdef PNG_SETJMP_SUPPORTED 1.245 + jmp_buf tmp_jmp; /* to save current jump buffer */ 1.246 +#endif 1.247 + 1.248 + int i = 0; 1.249 + 1.250 + png_structp png_ptr=*ptr_ptr; 1.251 + 1.252 + if (png_ptr == NULL) return; 1.253 + 1.254 + do 1.255 + { 1.256 + if (user_png_ver[i] != png_libpng_ver[i]) 1.257 + { 1.258 +#ifdef PNG_LEGACY_SUPPORTED 1.259 + png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 1.260 +#else 1.261 + png_ptr->warning_fn = NULL; 1.262 + png_warning(png_ptr, 1.263 + "Application uses deprecated png_read_init() and should be recompiled."); 1.264 + break; 1.265 +#endif 1.266 + } 1.267 + } while (png_libpng_ver[i++]); 1.268 + 1.269 + png_debug(1, "in png_read_init_3\n"); 1.270 + 1.271 +#ifdef PNG_SETJMP_SUPPORTED 1.272 + /* save jump buffer and error functions */ 1.273 + png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); 1.274 +#endif 1.275 + 1.276 + if (png_sizeof(png_struct) > png_struct_size) 1.277 + { 1.278 + png_destroy_struct(png_ptr); 1.279 + *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); 1.280 + png_ptr = *ptr_ptr; 1.281 + } 1.282 + 1.283 + /* reset all variables to 0 */ 1.284 + png_memset(png_ptr, 0, png_sizeof(png_struct)); 1.285 + 1.286 +#ifdef PNG_SETJMP_SUPPORTED 1.287 + /* restore jump buffer */ 1.288 + png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); 1.289 +#endif 1.290 + 1.291 + /* added at libpng-1.2.6 */ 1.292 +#ifdef PNG_SET_USER_LIMITS_SUPPORTED 1.293 + png_ptr->user_width_max=PNG_USER_WIDTH_MAX; 1.294 + png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; 1.295 +#endif 1.296 + 1.297 + /* initialize zbuf - compression buffer */ 1.298 + png_ptr->zbuf_size = PNG_ZBUF_SIZE; 1.299 + png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, 1.300 + (png_uint_32)png_ptr->zbuf_size); 1.301 + png_ptr->zstream.zalloc = png_zalloc; 1.302 + png_ptr->zstream.zfree = png_zfree; 1.303 + png_ptr->zstream.opaque = (voidpf)png_ptr; 1.304 + 1.305 + switch (inflateInit(&png_ptr->zstream)) 1.306 + { 1.307 + case Z_OK: /* Do nothing */ break; 1.308 + case Z_MEM_ERROR: 1.309 + case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break; 1.310 + case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break; 1.311 + default: png_error(png_ptr, "Unknown zlib error"); 1.312 + } 1.313 + 1.314 + png_ptr->zstream.next_out = png_ptr->zbuf; 1.315 + png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; 1.316 + 1.317 + png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); 1.318 +} 1.319 + 1.320 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.321 +/* Read the information before the actual image data. This has been 1.322 + * changed in v0.90 to allow reading a file that already has the magic 1.323 + * bytes read from the stream. You can tell libpng how many bytes have 1.324 + * been read from the beginning of the stream (up to the maximum of 8) 1.325 + * via png_set_sig_bytes(), and we will only check the remaining bytes 1.326 + * here. The application can then have access to the signature bytes we 1.327 + * read if it is determined that this isn't a valid PNG file. 1.328 + */ 1.329 +void PNGAPI 1.330 +png_read_info(png_structp png_ptr, png_infop info_ptr) 1.331 +{ 1.332 + if (png_ptr == NULL || info_ptr == NULL) return; 1.333 + png_debug(1, "in png_read_info\n"); 1.334 + /* If we haven't checked all of the PNG signature bytes, do so now. */ 1.335 + if (png_ptr->sig_bytes < 8) 1.336 + { 1.337 + png_size_t num_checked = png_ptr->sig_bytes, 1.338 + num_to_check = 8 - num_checked; 1.339 + 1.340 + png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); 1.341 + png_ptr->sig_bytes = 8; 1.342 + 1.343 + if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) 1.344 + { 1.345 + if (num_checked < 4 && 1.346 + png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) 1.347 + png_error(png_ptr, "Not a PNG file"); 1.348 + else 1.349 + png_error(png_ptr, "PNG file corrupted by ASCII conversion"); 1.350 + } 1.351 + if (num_checked < 3) 1.352 + png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; 1.353 + } 1.354 + 1.355 + for (;;) 1.356 + { 1.357 +#ifdef PNG_USE_LOCAL_ARRAYS 1.358 + PNG_CONST PNG_IHDR; 1.359 + PNG_CONST PNG_IDAT; 1.360 + PNG_CONST PNG_IEND; 1.361 + PNG_CONST PNG_PLTE; 1.362 +#if defined(PNG_READ_bKGD_SUPPORTED) 1.363 + PNG_CONST PNG_bKGD; 1.364 +#endif 1.365 +#if defined(PNG_READ_cHRM_SUPPORTED) 1.366 + PNG_CONST PNG_cHRM; 1.367 +#endif 1.368 +#if defined(PNG_READ_gAMA_SUPPORTED) 1.369 + PNG_CONST PNG_gAMA; 1.370 +#endif 1.371 +#if defined(PNG_READ_hIST_SUPPORTED) 1.372 + PNG_CONST PNG_hIST; 1.373 +#endif 1.374 +#if defined(PNG_READ_iCCP_SUPPORTED) 1.375 + PNG_CONST PNG_iCCP; 1.376 +#endif 1.377 +#if defined(PNG_READ_iTXt_SUPPORTED) 1.378 + PNG_CONST PNG_iTXt; 1.379 +#endif 1.380 +#if defined(PNG_READ_oFFs_SUPPORTED) 1.381 + PNG_CONST PNG_oFFs; 1.382 +#endif 1.383 +#if defined(PNG_READ_pCAL_SUPPORTED) 1.384 + PNG_CONST PNG_pCAL; 1.385 +#endif 1.386 +#if defined(PNG_READ_pHYs_SUPPORTED) 1.387 + PNG_CONST PNG_pHYs; 1.388 +#endif 1.389 +#if defined(PNG_READ_sBIT_SUPPORTED) 1.390 + PNG_CONST PNG_sBIT; 1.391 +#endif 1.392 +#if defined(PNG_READ_sCAL_SUPPORTED) 1.393 + PNG_CONST PNG_sCAL; 1.394 +#endif 1.395 +#if defined(PNG_READ_sPLT_SUPPORTED) 1.396 + PNG_CONST PNG_sPLT; 1.397 +#endif 1.398 +#if defined(PNG_READ_sRGB_SUPPORTED) 1.399 + PNG_CONST PNG_sRGB; 1.400 +#endif 1.401 +#if defined(PNG_READ_tEXt_SUPPORTED) 1.402 + PNG_CONST PNG_tEXt; 1.403 +#endif 1.404 +#if defined(PNG_READ_tIME_SUPPORTED) 1.405 + PNG_CONST PNG_tIME; 1.406 +#endif 1.407 +#if defined(PNG_READ_tRNS_SUPPORTED) 1.408 + PNG_CONST PNG_tRNS; 1.409 +#endif 1.410 +#if defined(PNG_READ_zTXt_SUPPORTED) 1.411 + PNG_CONST PNG_zTXt; 1.412 +#endif 1.413 +#endif /* PNG_USE_LOCAL_ARRAYS */ 1.414 + png_uint_32 length = png_read_chunk_header(png_ptr); 1.415 + PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; 1.416 + 1.417 + /* This should be a binary subdivision search or a hash for 1.418 + * matching the chunk name rather than a linear search. 1.419 + */ 1.420 + if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.421 + if (png_ptr->mode & PNG_AFTER_IDAT) 1.422 + png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; 1.423 + 1.424 + if (!png_memcmp(chunk_name, png_IHDR, 4)) 1.425 + png_handle_IHDR(png_ptr, info_ptr, length); 1.426 + else if (!png_memcmp(chunk_name, png_IEND, 4)) 1.427 + png_handle_IEND(png_ptr, info_ptr, length); 1.428 +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 1.429 + else if (png_handle_as_unknown(png_ptr, chunk_name)) 1.430 + { 1.431 + if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.432 + png_ptr->mode |= PNG_HAVE_IDAT; 1.433 + png_handle_unknown(png_ptr, info_ptr, length); 1.434 + if (!png_memcmp(chunk_name, png_PLTE, 4)) 1.435 + png_ptr->mode |= PNG_HAVE_PLTE; 1.436 + else if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.437 + { 1.438 + if (!(png_ptr->mode & PNG_HAVE_IHDR)) 1.439 + png_error(png_ptr, "Missing IHDR before IDAT"); 1.440 + else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 1.441 + !(png_ptr->mode & PNG_HAVE_PLTE)) 1.442 + png_error(png_ptr, "Missing PLTE before IDAT"); 1.443 + break; 1.444 + } 1.445 + } 1.446 +#endif 1.447 + else if (!png_memcmp(chunk_name, png_PLTE, 4)) 1.448 + png_handle_PLTE(png_ptr, info_ptr, length); 1.449 + else if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.450 + { 1.451 + if (!(png_ptr->mode & PNG_HAVE_IHDR)) 1.452 + png_error(png_ptr, "Missing IHDR before IDAT"); 1.453 + else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 1.454 + !(png_ptr->mode & PNG_HAVE_PLTE)) 1.455 + png_error(png_ptr, "Missing PLTE before IDAT"); 1.456 + 1.457 + png_ptr->idat_size = length; 1.458 + png_ptr->mode |= PNG_HAVE_IDAT; 1.459 + break; 1.460 + } 1.461 +#if defined(PNG_READ_bKGD_SUPPORTED) 1.462 + else if (!png_memcmp(chunk_name, png_bKGD, 4)) 1.463 + png_handle_bKGD(png_ptr, info_ptr, length); 1.464 +#endif 1.465 +#if defined(PNG_READ_cHRM_SUPPORTED) 1.466 + else if (!png_memcmp(chunk_name, png_cHRM, 4)) 1.467 + png_handle_cHRM(png_ptr, info_ptr, length); 1.468 +#endif 1.469 +#if defined(PNG_READ_gAMA_SUPPORTED) 1.470 + else if (!png_memcmp(chunk_name, png_gAMA, 4)) 1.471 + png_handle_gAMA(png_ptr, info_ptr, length); 1.472 +#endif 1.473 +#if defined(PNG_READ_hIST_SUPPORTED) 1.474 + else if (!png_memcmp(chunk_name, png_hIST, 4)) 1.475 + png_handle_hIST(png_ptr, info_ptr, length); 1.476 +#endif 1.477 +#if defined(PNG_READ_oFFs_SUPPORTED) 1.478 + else if (!png_memcmp(chunk_name, png_oFFs, 4)) 1.479 + png_handle_oFFs(png_ptr, info_ptr, length); 1.480 +#endif 1.481 +#if defined(PNG_READ_pCAL_SUPPORTED) 1.482 + else if (!png_memcmp(chunk_name, png_pCAL, 4)) 1.483 + png_handle_pCAL(png_ptr, info_ptr, length); 1.484 +#endif 1.485 +#if defined(PNG_READ_sCAL_SUPPORTED) 1.486 + else if (!png_memcmp(chunk_name, png_sCAL, 4)) 1.487 + png_handle_sCAL(png_ptr, info_ptr, length); 1.488 +#endif 1.489 +#if defined(PNG_READ_pHYs_SUPPORTED) 1.490 + else if (!png_memcmp(chunk_name, png_pHYs, 4)) 1.491 + png_handle_pHYs(png_ptr, info_ptr, length); 1.492 +#endif 1.493 +#if defined(PNG_READ_sBIT_SUPPORTED) 1.494 + else if (!png_memcmp(chunk_name, png_sBIT, 4)) 1.495 + png_handle_sBIT(png_ptr, info_ptr, length); 1.496 +#endif 1.497 +#if defined(PNG_READ_sRGB_SUPPORTED) 1.498 + else if (!png_memcmp(chunk_name, png_sRGB, 4)) 1.499 + png_handle_sRGB(png_ptr, info_ptr, length); 1.500 +#endif 1.501 +#if defined(PNG_READ_iCCP_SUPPORTED) 1.502 + else if (!png_memcmp(chunk_name, png_iCCP, 4)) 1.503 + png_handle_iCCP(png_ptr, info_ptr, length); 1.504 +#endif 1.505 +#if defined(PNG_READ_sPLT_SUPPORTED) 1.506 + else if (!png_memcmp(chunk_name, png_sPLT, 4)) 1.507 + png_handle_sPLT(png_ptr, info_ptr, length); 1.508 +#endif 1.509 +#if defined(PNG_READ_tEXt_SUPPORTED) 1.510 + else if (!png_memcmp(chunk_name, png_tEXt, 4)) 1.511 + png_handle_tEXt(png_ptr, info_ptr, length); 1.512 +#endif 1.513 +#if defined(PNG_READ_tIME_SUPPORTED) 1.514 + else if (!png_memcmp(chunk_name, png_tIME, 4)) 1.515 + png_handle_tIME(png_ptr, info_ptr, length); 1.516 +#endif 1.517 +#if defined(PNG_READ_tRNS_SUPPORTED) 1.518 + else if (!png_memcmp(chunk_name, png_tRNS, 4)) 1.519 + png_handle_tRNS(png_ptr, info_ptr, length); 1.520 +#endif 1.521 +#if defined(PNG_READ_zTXt_SUPPORTED) 1.522 + else if (!png_memcmp(chunk_name, png_zTXt, 4)) 1.523 + png_handle_zTXt(png_ptr, info_ptr, length); 1.524 +#endif 1.525 +#if defined(PNG_READ_iTXt_SUPPORTED) 1.526 + else if (!png_memcmp(chunk_name, png_iTXt, 4)) 1.527 + png_handle_iTXt(png_ptr, info_ptr, length); 1.528 +#endif 1.529 + else 1.530 + png_handle_unknown(png_ptr, info_ptr, length); 1.531 + } 1.532 +} 1.533 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.534 + 1.535 +/* optional call to update the users info_ptr structure */ 1.536 +void PNGAPI 1.537 +png_read_update_info(png_structp png_ptr, png_infop info_ptr) 1.538 +{ 1.539 + png_debug(1, "in png_read_update_info\n"); 1.540 + if (png_ptr == NULL) return; 1.541 + if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 1.542 + png_read_start_row(png_ptr); 1.543 + else 1.544 + png_warning(png_ptr, 1.545 + "Ignoring extra png_read_update_info() call; row buffer not reallocated"); 1.546 + png_read_transform_info(png_ptr, info_ptr); 1.547 +} 1.548 + 1.549 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.550 +/* Initialize palette, background, etc, after transformations 1.551 + * are set, but before any reading takes place. This allows 1.552 + * the user to obtain a gamma-corrected palette, for example. 1.553 + * If the user doesn't call this, we will do it ourselves. 1.554 + */ 1.555 +void PNGAPI 1.556 +png_start_read_image(png_structp png_ptr) 1.557 +{ 1.558 + png_debug(1, "in png_start_read_image\n"); 1.559 + if (png_ptr == NULL) return; 1.560 + if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 1.561 + png_read_start_row(png_ptr); 1.562 +} 1.563 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.564 + 1.565 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.566 +void PNGAPI 1.567 +png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) 1.568 +{ 1.569 +#ifdef PNG_USE_LOCAL_ARRAYS 1.570 + PNG_CONST PNG_IDAT; 1.571 + PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 1.572 + 0xff}; 1.573 + PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; 1.574 +#endif 1.575 + int ret; 1.576 + if (png_ptr == NULL) return; 1.577 + png_debug2(1, "in png_read_row (row %lu, pass %d)\n", 1.578 + png_ptr->row_number, png_ptr->pass); 1.579 + if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 1.580 + png_read_start_row(png_ptr); 1.581 + if (png_ptr->row_number == 0 && png_ptr->pass == 0) 1.582 + { 1.583 + /* check for transforms that have been set but were defined out */ 1.584 +#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) 1.585 + if (png_ptr->transformations & PNG_INVERT_MONO) 1.586 + png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); 1.587 +#endif 1.588 +#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) 1.589 + if (png_ptr->transformations & PNG_FILLER) 1.590 + png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); 1.591 +#endif 1.592 +#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED) 1.593 + if (png_ptr->transformations & PNG_PACKSWAP) 1.594 + png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); 1.595 +#endif 1.596 +#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) 1.597 + if (png_ptr->transformations & PNG_PACK) 1.598 + png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); 1.599 +#endif 1.600 +#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) 1.601 + if (png_ptr->transformations & PNG_SHIFT) 1.602 + png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); 1.603 +#endif 1.604 +#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) 1.605 + if (png_ptr->transformations & PNG_BGR) 1.606 + png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); 1.607 +#endif 1.608 +#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) 1.609 + if (png_ptr->transformations & PNG_SWAP_BYTES) 1.610 + png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); 1.611 +#endif 1.612 + } 1.613 + 1.614 +#if defined(PNG_READ_INTERLACING_SUPPORTED) 1.615 + /* if interlaced and we do not need a new row, combine row and return */ 1.616 + if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) 1.617 + { 1.618 + switch (png_ptr->pass) 1.619 + { 1.620 + case 0: 1.621 + if (png_ptr->row_number & 0x07) 1.622 + { 1.623 + if (dsp_row != NULL) 1.624 + png_combine_row(png_ptr, dsp_row, 1.625 + png_pass_dsp_mask[png_ptr->pass]); 1.626 + png_read_finish_row(png_ptr); 1.627 + return; 1.628 + } 1.629 + break; 1.630 + case 1: 1.631 + if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) 1.632 + { 1.633 + if (dsp_row != NULL) 1.634 + png_combine_row(png_ptr, dsp_row, 1.635 + png_pass_dsp_mask[png_ptr->pass]); 1.636 + png_read_finish_row(png_ptr); 1.637 + return; 1.638 + } 1.639 + break; 1.640 + case 2: 1.641 + if ((png_ptr->row_number & 0x07) != 4) 1.642 + { 1.643 + if (dsp_row != NULL && (png_ptr->row_number & 4)) 1.644 + png_combine_row(png_ptr, dsp_row, 1.645 + png_pass_dsp_mask[png_ptr->pass]); 1.646 + png_read_finish_row(png_ptr); 1.647 + return; 1.648 + } 1.649 + break; 1.650 + case 3: 1.651 + if ((png_ptr->row_number & 3) || png_ptr->width < 3) 1.652 + { 1.653 + if (dsp_row != NULL) 1.654 + png_combine_row(png_ptr, dsp_row, 1.655 + png_pass_dsp_mask[png_ptr->pass]); 1.656 + png_read_finish_row(png_ptr); 1.657 + return; 1.658 + } 1.659 + break; 1.660 + case 4: 1.661 + if ((png_ptr->row_number & 3) != 2) 1.662 + { 1.663 + if (dsp_row != NULL && (png_ptr->row_number & 2)) 1.664 + png_combine_row(png_ptr, dsp_row, 1.665 + png_pass_dsp_mask[png_ptr->pass]); 1.666 + png_read_finish_row(png_ptr); 1.667 + return; 1.668 + } 1.669 + break; 1.670 + case 5: 1.671 + if ((png_ptr->row_number & 1) || png_ptr->width < 2) 1.672 + { 1.673 + if (dsp_row != NULL) 1.674 + png_combine_row(png_ptr, dsp_row, 1.675 + png_pass_dsp_mask[png_ptr->pass]); 1.676 + png_read_finish_row(png_ptr); 1.677 + return; 1.678 + } 1.679 + break; 1.680 + case 6: 1.681 + if (!(png_ptr->row_number & 1)) 1.682 + { 1.683 + png_read_finish_row(png_ptr); 1.684 + return; 1.685 + } 1.686 + break; 1.687 + } 1.688 + } 1.689 +#endif 1.690 + 1.691 + if (!(png_ptr->mode & PNG_HAVE_IDAT)) 1.692 + png_error(png_ptr, "Invalid attempt to read row data"); 1.693 + 1.694 + png_ptr->zstream.next_out = png_ptr->row_buf; 1.695 + png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; 1.696 + do 1.697 + { 1.698 + if (!(png_ptr->zstream.avail_in)) 1.699 + { 1.700 + while (!png_ptr->idat_size) 1.701 + { 1.702 + png_crc_finish(png_ptr, 0); 1.703 + 1.704 + png_ptr->idat_size = png_read_chunk_header(png_ptr); 1.705 + if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) 1.706 + png_error(png_ptr, "Not enough image data"); 1.707 + } 1.708 + png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; 1.709 + png_ptr->zstream.next_in = png_ptr->zbuf; 1.710 + if (png_ptr->zbuf_size > png_ptr->idat_size) 1.711 + png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; 1.712 + png_crc_read(png_ptr, png_ptr->zbuf, 1.713 + (png_size_t)png_ptr->zstream.avail_in); 1.714 + png_ptr->idat_size -= png_ptr->zstream.avail_in; 1.715 + } 1.716 + ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); 1.717 + if (ret == Z_STREAM_END) 1.718 + { 1.719 + if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || 1.720 + png_ptr->idat_size) 1.721 + png_error(png_ptr, "Extra compressed data"); 1.722 + png_ptr->mode |= PNG_AFTER_IDAT; 1.723 + png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; 1.724 + break; 1.725 + } 1.726 + if (ret != Z_OK) 1.727 + png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : 1.728 + "Decompression error"); 1.729 + 1.730 + } while (png_ptr->zstream.avail_out); 1.731 + 1.732 + png_ptr->row_info.color_type = png_ptr->color_type; 1.733 + png_ptr->row_info.width = png_ptr->iwidth; 1.734 + png_ptr->row_info.channels = png_ptr->channels; 1.735 + png_ptr->row_info.bit_depth = png_ptr->bit_depth; 1.736 + png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; 1.737 + png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, 1.738 + png_ptr->row_info.width); 1.739 + 1.740 + if (png_ptr->row_buf[0]) 1.741 + png_read_filter_row(png_ptr, &(png_ptr->row_info), 1.742 + png_ptr->row_buf + 1, png_ptr->prev_row + 1, 1.743 + (int)(png_ptr->row_buf[0])); 1.744 + 1.745 + png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, 1.746 + png_ptr->rowbytes + 1); 1.747 + 1.748 +#if defined(PNG_MNG_FEATURES_SUPPORTED) 1.749 + if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && 1.750 + (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) 1.751 + { 1.752 + /* Intrapixel differencing */ 1.753 + png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); 1.754 + } 1.755 +#endif 1.756 + 1.757 + 1.758 + if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) 1.759 + png_do_read_transformations(png_ptr); 1.760 + 1.761 +#if defined(PNG_READ_INTERLACING_SUPPORTED) 1.762 + /* blow up interlaced rows to full size */ 1.763 + if (png_ptr->interlaced && 1.764 + (png_ptr->transformations & PNG_INTERLACE)) 1.765 + { 1.766 + if (png_ptr->pass < 6) 1.767 +/* old interface (pre-1.0.9): 1.768 + png_do_read_interlace(&(png_ptr->row_info), 1.769 + png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); 1.770 + */ 1.771 + png_do_read_interlace(png_ptr); 1.772 + 1.773 + if (dsp_row != NULL) 1.774 + png_combine_row(png_ptr, dsp_row, 1.775 + png_pass_dsp_mask[png_ptr->pass]); 1.776 + if (row != NULL) 1.777 + png_combine_row(png_ptr, row, 1.778 + png_pass_mask[png_ptr->pass]); 1.779 + } 1.780 + else 1.781 +#endif 1.782 + { 1.783 + if (row != NULL) 1.784 + png_combine_row(png_ptr, row, 0xff); 1.785 + if (dsp_row != NULL) 1.786 + png_combine_row(png_ptr, dsp_row, 0xff); 1.787 + } 1.788 + png_read_finish_row(png_ptr); 1.789 + 1.790 + if (png_ptr->read_row_fn != NULL) 1.791 + (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); 1.792 +} 1.793 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.794 + 1.795 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.796 +/* Read one or more rows of image data. If the image is interlaced, 1.797 + * and png_set_interlace_handling() has been called, the rows need to 1.798 + * contain the contents of the rows from the previous pass. If the 1.799 + * image has alpha or transparency, and png_handle_alpha()[*] has been 1.800 + * called, the rows contents must be initialized to the contents of the 1.801 + * screen. 1.802 + * 1.803 + * "row" holds the actual image, and pixels are placed in it 1.804 + * as they arrive. If the image is displayed after each pass, it will 1.805 + * appear to "sparkle" in. "display_row" can be used to display a 1.806 + * "chunky" progressive image, with finer detail added as it becomes 1.807 + * available. If you do not want this "chunky" display, you may pass 1.808 + * NULL for display_row. If you do not want the sparkle display, and 1.809 + * you have not called png_handle_alpha(), you may pass NULL for rows. 1.810 + * If you have called png_handle_alpha(), and the image has either an 1.811 + * alpha channel or a transparency chunk, you must provide a buffer for 1.812 + * rows. In this case, you do not have to provide a display_row buffer 1.813 + * also, but you may. If the image is not interlaced, or if you have 1.814 + * not called png_set_interlace_handling(), the display_row buffer will 1.815 + * be ignored, so pass NULL to it. 1.816 + * 1.817 + * [*] png_handle_alpha() does not exist yet, as of this version of libpng 1.818 + */ 1.819 + 1.820 +void PNGAPI 1.821 +png_read_rows(png_structp png_ptr, png_bytepp row, 1.822 + png_bytepp display_row, png_uint_32 num_rows) 1.823 +{ 1.824 + png_uint_32 i; 1.825 + png_bytepp rp; 1.826 + png_bytepp dp; 1.827 + 1.828 + png_debug(1, "in png_read_rows\n"); 1.829 + if (png_ptr == NULL) return; 1.830 + rp = row; 1.831 + dp = display_row; 1.832 + if (rp != NULL && dp != NULL) 1.833 + for (i = 0; i < num_rows; i++) 1.834 + { 1.835 + png_bytep rptr = *rp++; 1.836 + png_bytep dptr = *dp++; 1.837 + 1.838 + png_read_row(png_ptr, rptr, dptr); 1.839 + } 1.840 + else if (rp != NULL) 1.841 + for (i = 0; i < num_rows; i++) 1.842 + { 1.843 + png_bytep rptr = *rp; 1.844 + png_read_row(png_ptr, rptr, png_bytep_NULL); 1.845 + rp++; 1.846 + } 1.847 + else if (dp != NULL) 1.848 + for (i = 0; i < num_rows; i++) 1.849 + { 1.850 + png_bytep dptr = *dp; 1.851 + png_read_row(png_ptr, png_bytep_NULL, dptr); 1.852 + dp++; 1.853 + } 1.854 +} 1.855 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.856 + 1.857 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.858 +/* Read the entire image. If the image has an alpha channel or a tRNS 1.859 + * chunk, and you have called png_handle_alpha()[*], you will need to 1.860 + * initialize the image to the current image that PNG will be overlaying. 1.861 + * We set the num_rows again here, in case it was incorrectly set in 1.862 + * png_read_start_row() by a call to png_read_update_info() or 1.863 + * png_start_read_image() if png_set_interlace_handling() wasn't called 1.864 + * prior to either of these functions like it should have been. You can 1.865 + * only call this function once. If you desire to have an image for 1.866 + * each pass of a interlaced image, use png_read_rows() instead. 1.867 + * 1.868 + * [*] png_handle_alpha() does not exist yet, as of this version of libpng 1.869 + */ 1.870 +void PNGAPI 1.871 +png_read_image(png_structp png_ptr, png_bytepp image) 1.872 +{ 1.873 + png_uint_32 i, image_height; 1.874 + int pass, j; 1.875 + png_bytepp rp; 1.876 + 1.877 + png_debug(1, "in png_read_image\n"); 1.878 + if (png_ptr == NULL) return; 1.879 + 1.880 +#ifdef PNG_READ_INTERLACING_SUPPORTED 1.881 + pass = png_set_interlace_handling(png_ptr); 1.882 +#else 1.883 + if (png_ptr->interlaced) 1.884 + png_error(png_ptr, 1.885 + "Cannot read interlaced image -- interlace handler disabled."); 1.886 + pass = 1; 1.887 +#endif 1.888 + 1.889 + 1.890 + image_height=png_ptr->height; 1.891 + png_ptr->num_rows = image_height; /* Make sure this is set correctly */ 1.892 + 1.893 + for (j = 0; j < pass; j++) 1.894 + { 1.895 + rp = image; 1.896 + for (i = 0; i < image_height; i++) 1.897 + { 1.898 + png_read_row(png_ptr, *rp, png_bytep_NULL); 1.899 + rp++; 1.900 + } 1.901 + } 1.902 +} 1.903 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.904 + 1.905 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.906 +/* Read the end of the PNG file. Will not read past the end of the 1.907 + * file, will verify the end is accurate, and will read any comments 1.908 + * or time information at the end of the file, if info is not NULL. 1.909 + */ 1.910 +void PNGAPI 1.911 +png_read_end(png_structp png_ptr, png_infop info_ptr) 1.912 +{ 1.913 + png_debug(1, "in png_read_end\n"); 1.914 + if (png_ptr == NULL) return; 1.915 + png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ 1.916 + 1.917 + do 1.918 + { 1.919 +#ifdef PNG_USE_LOCAL_ARRAYS 1.920 + PNG_CONST PNG_IHDR; 1.921 + PNG_CONST PNG_IDAT; 1.922 + PNG_CONST PNG_IEND; 1.923 + PNG_CONST PNG_PLTE; 1.924 +#if defined(PNG_READ_bKGD_SUPPORTED) 1.925 + PNG_CONST PNG_bKGD; 1.926 +#endif 1.927 +#if defined(PNG_READ_cHRM_SUPPORTED) 1.928 + PNG_CONST PNG_cHRM; 1.929 +#endif 1.930 +#if defined(PNG_READ_gAMA_SUPPORTED) 1.931 + PNG_CONST PNG_gAMA; 1.932 +#endif 1.933 +#if defined(PNG_READ_hIST_SUPPORTED) 1.934 + PNG_CONST PNG_hIST; 1.935 +#endif 1.936 +#if defined(PNG_READ_iCCP_SUPPORTED) 1.937 + PNG_CONST PNG_iCCP; 1.938 +#endif 1.939 +#if defined(PNG_READ_iTXt_SUPPORTED) 1.940 + PNG_CONST PNG_iTXt; 1.941 +#endif 1.942 +#if defined(PNG_READ_oFFs_SUPPORTED) 1.943 + PNG_CONST PNG_oFFs; 1.944 +#endif 1.945 +#if defined(PNG_READ_pCAL_SUPPORTED) 1.946 + PNG_CONST PNG_pCAL; 1.947 +#endif 1.948 +#if defined(PNG_READ_pHYs_SUPPORTED) 1.949 + PNG_CONST PNG_pHYs; 1.950 +#endif 1.951 +#if defined(PNG_READ_sBIT_SUPPORTED) 1.952 + PNG_CONST PNG_sBIT; 1.953 +#endif 1.954 +#if defined(PNG_READ_sCAL_SUPPORTED) 1.955 + PNG_CONST PNG_sCAL; 1.956 +#endif 1.957 +#if defined(PNG_READ_sPLT_SUPPORTED) 1.958 + PNG_CONST PNG_sPLT; 1.959 +#endif 1.960 +#if defined(PNG_READ_sRGB_SUPPORTED) 1.961 + PNG_CONST PNG_sRGB; 1.962 +#endif 1.963 +#if defined(PNG_READ_tEXt_SUPPORTED) 1.964 + PNG_CONST PNG_tEXt; 1.965 +#endif 1.966 +#if defined(PNG_READ_tIME_SUPPORTED) 1.967 + PNG_CONST PNG_tIME; 1.968 +#endif 1.969 +#if defined(PNG_READ_tRNS_SUPPORTED) 1.970 + PNG_CONST PNG_tRNS; 1.971 +#endif 1.972 +#if defined(PNG_READ_zTXt_SUPPORTED) 1.973 + PNG_CONST PNG_zTXt; 1.974 +#endif 1.975 +#endif /* PNG_USE_LOCAL_ARRAYS */ 1.976 + png_uint_32 length = png_read_chunk_header(png_ptr); 1.977 + PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; 1.978 + 1.979 + if (!png_memcmp(chunk_name, png_IHDR, 4)) 1.980 + png_handle_IHDR(png_ptr, info_ptr, length); 1.981 + else if (!png_memcmp(chunk_name, png_IEND, 4)) 1.982 + png_handle_IEND(png_ptr, info_ptr, length); 1.983 +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 1.984 + else if (png_handle_as_unknown(png_ptr, chunk_name)) 1.985 + { 1.986 + if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.987 + { 1.988 + if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) 1.989 + png_error(png_ptr, "Too many IDAT's found"); 1.990 + } 1.991 + png_handle_unknown(png_ptr, info_ptr, length); 1.992 + if (!png_memcmp(chunk_name, png_PLTE, 4)) 1.993 + png_ptr->mode |= PNG_HAVE_PLTE; 1.994 + } 1.995 +#endif 1.996 + else if (!png_memcmp(chunk_name, png_IDAT, 4)) 1.997 + { 1.998 + /* Zero length IDATs are legal after the last IDAT has been 1.999 + * read, but not after other chunks have been read. 1.1000 + */ 1.1001 + if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) 1.1002 + png_error(png_ptr, "Too many IDAT's found"); 1.1003 + png_crc_finish(png_ptr, length); 1.1004 + } 1.1005 + else if (!png_memcmp(chunk_name, png_PLTE, 4)) 1.1006 + png_handle_PLTE(png_ptr, info_ptr, length); 1.1007 +#if defined(PNG_READ_bKGD_SUPPORTED) 1.1008 + else if (!png_memcmp(chunk_name, png_bKGD, 4)) 1.1009 + png_handle_bKGD(png_ptr, info_ptr, length); 1.1010 +#endif 1.1011 +#if defined(PNG_READ_cHRM_SUPPORTED) 1.1012 + else if (!png_memcmp(chunk_name, png_cHRM, 4)) 1.1013 + png_handle_cHRM(png_ptr, info_ptr, length); 1.1014 +#endif 1.1015 +#if defined(PNG_READ_gAMA_SUPPORTED) 1.1016 + else if (!png_memcmp(chunk_name, png_gAMA, 4)) 1.1017 + png_handle_gAMA(png_ptr, info_ptr, length); 1.1018 +#endif 1.1019 +#if defined(PNG_READ_hIST_SUPPORTED) 1.1020 + else if (!png_memcmp(chunk_name, png_hIST, 4)) 1.1021 + png_handle_hIST(png_ptr, info_ptr, length); 1.1022 +#endif 1.1023 +#if defined(PNG_READ_oFFs_SUPPORTED) 1.1024 + else if (!png_memcmp(chunk_name, png_oFFs, 4)) 1.1025 + png_handle_oFFs(png_ptr, info_ptr, length); 1.1026 +#endif 1.1027 +#if defined(PNG_READ_pCAL_SUPPORTED) 1.1028 + else if (!png_memcmp(chunk_name, png_pCAL, 4)) 1.1029 + png_handle_pCAL(png_ptr, info_ptr, length); 1.1030 +#endif 1.1031 +#if defined(PNG_READ_sCAL_SUPPORTED) 1.1032 + else if (!png_memcmp(chunk_name, png_sCAL, 4)) 1.1033 + png_handle_sCAL(png_ptr, info_ptr, length); 1.1034 +#endif 1.1035 +#if defined(PNG_READ_pHYs_SUPPORTED) 1.1036 + else if (!png_memcmp(chunk_name, png_pHYs, 4)) 1.1037 + png_handle_pHYs(png_ptr, info_ptr, length); 1.1038 +#endif 1.1039 +#if defined(PNG_READ_sBIT_SUPPORTED) 1.1040 + else if (!png_memcmp(chunk_name, png_sBIT, 4)) 1.1041 + png_handle_sBIT(png_ptr, info_ptr, length); 1.1042 +#endif 1.1043 +#if defined(PNG_READ_sRGB_SUPPORTED) 1.1044 + else if (!png_memcmp(chunk_name, png_sRGB, 4)) 1.1045 + png_handle_sRGB(png_ptr, info_ptr, length); 1.1046 +#endif 1.1047 +#if defined(PNG_READ_iCCP_SUPPORTED) 1.1048 + else if (!png_memcmp(chunk_name, png_iCCP, 4)) 1.1049 + png_handle_iCCP(png_ptr, info_ptr, length); 1.1050 +#endif 1.1051 +#if defined(PNG_READ_sPLT_SUPPORTED) 1.1052 + else if (!png_memcmp(chunk_name, png_sPLT, 4)) 1.1053 + png_handle_sPLT(png_ptr, info_ptr, length); 1.1054 +#endif 1.1055 +#if defined(PNG_READ_tEXt_SUPPORTED) 1.1056 + else if (!png_memcmp(chunk_name, png_tEXt, 4)) 1.1057 + png_handle_tEXt(png_ptr, info_ptr, length); 1.1058 +#endif 1.1059 +#if defined(PNG_READ_tIME_SUPPORTED) 1.1060 + else if (!png_memcmp(chunk_name, png_tIME, 4)) 1.1061 + png_handle_tIME(png_ptr, info_ptr, length); 1.1062 +#endif 1.1063 +#if defined(PNG_READ_tRNS_SUPPORTED) 1.1064 + else if (!png_memcmp(chunk_name, png_tRNS, 4)) 1.1065 + png_handle_tRNS(png_ptr, info_ptr, length); 1.1066 +#endif 1.1067 +#if defined(PNG_READ_zTXt_SUPPORTED) 1.1068 + else if (!png_memcmp(chunk_name, png_zTXt, 4)) 1.1069 + png_handle_zTXt(png_ptr, info_ptr, length); 1.1070 +#endif 1.1071 +#if defined(PNG_READ_iTXt_SUPPORTED) 1.1072 + else if (!png_memcmp(chunk_name, png_iTXt, 4)) 1.1073 + png_handle_iTXt(png_ptr, info_ptr, length); 1.1074 +#endif 1.1075 + else 1.1076 + png_handle_unknown(png_ptr, info_ptr, length); 1.1077 + } while (!(png_ptr->mode & PNG_HAVE_IEND)); 1.1078 +} 1.1079 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.1080 + 1.1081 +/* free all memory used by the read */ 1.1082 +void PNGAPI 1.1083 +png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, 1.1084 + png_infopp end_info_ptr_ptr) 1.1085 +{ 1.1086 + png_structp png_ptr = NULL; 1.1087 + png_infop info_ptr = NULL, end_info_ptr = NULL; 1.1088 +#ifdef PNG_USER_MEM_SUPPORTED 1.1089 + png_free_ptr free_fn = NULL; 1.1090 + png_voidp mem_ptr = NULL; 1.1091 +#endif 1.1092 + 1.1093 + png_debug(1, "in png_destroy_read_struct\n"); 1.1094 + if (png_ptr_ptr != NULL) 1.1095 + png_ptr = *png_ptr_ptr; 1.1096 + if (png_ptr == NULL) 1.1097 + return; 1.1098 + 1.1099 +#ifdef PNG_USER_MEM_SUPPORTED 1.1100 + free_fn = png_ptr->free_fn; 1.1101 + mem_ptr = png_ptr->mem_ptr; 1.1102 +#endif 1.1103 + 1.1104 + if (info_ptr_ptr != NULL) 1.1105 + info_ptr = *info_ptr_ptr; 1.1106 + 1.1107 + if (end_info_ptr_ptr != NULL) 1.1108 + end_info_ptr = *end_info_ptr_ptr; 1.1109 + 1.1110 + png_read_destroy(png_ptr, info_ptr, end_info_ptr); 1.1111 + 1.1112 + if (info_ptr != NULL) 1.1113 + { 1.1114 +#if defined(PNG_TEXT_SUPPORTED) 1.1115 + png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); 1.1116 +#endif 1.1117 + 1.1118 +#ifdef PNG_USER_MEM_SUPPORTED 1.1119 + png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, 1.1120 + (png_voidp)mem_ptr); 1.1121 +#else 1.1122 + png_destroy_struct((png_voidp)info_ptr); 1.1123 +#endif 1.1124 + *info_ptr_ptr = NULL; 1.1125 + } 1.1126 + 1.1127 + if (end_info_ptr != NULL) 1.1128 + { 1.1129 +#if defined(PNG_READ_TEXT_SUPPORTED) 1.1130 + png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); 1.1131 +#endif 1.1132 +#ifdef PNG_USER_MEM_SUPPORTED 1.1133 + png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, 1.1134 + (png_voidp)mem_ptr); 1.1135 +#else 1.1136 + png_destroy_struct((png_voidp)end_info_ptr); 1.1137 +#endif 1.1138 + *end_info_ptr_ptr = NULL; 1.1139 + } 1.1140 + 1.1141 + if (png_ptr != NULL) 1.1142 + { 1.1143 +#ifdef PNG_USER_MEM_SUPPORTED 1.1144 + png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, 1.1145 + (png_voidp)mem_ptr); 1.1146 +#else 1.1147 + png_destroy_struct((png_voidp)png_ptr); 1.1148 +#endif 1.1149 + *png_ptr_ptr = NULL; 1.1150 + } 1.1151 +} 1.1152 + 1.1153 +/* free all memory used by the read (old method) */ 1.1154 +void /* PRIVATE */ 1.1155 +png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) 1.1156 +{ 1.1157 +#ifdef PNG_SETJMP_SUPPORTED 1.1158 + jmp_buf tmp_jmp; 1.1159 +#endif 1.1160 + png_error_ptr error_fn; 1.1161 + png_error_ptr warning_fn; 1.1162 + png_voidp error_ptr; 1.1163 +#ifdef PNG_USER_MEM_SUPPORTED 1.1164 + png_free_ptr free_fn; 1.1165 +#endif 1.1166 + 1.1167 + png_debug(1, "in png_read_destroy\n"); 1.1168 + if (info_ptr != NULL) 1.1169 + png_info_destroy(png_ptr, info_ptr); 1.1170 + 1.1171 + if (end_info_ptr != NULL) 1.1172 + png_info_destroy(png_ptr, end_info_ptr); 1.1173 + 1.1174 + png_free(png_ptr, png_ptr->zbuf); 1.1175 + png_free(png_ptr, png_ptr->big_row_buf); 1.1176 + png_free(png_ptr, png_ptr->prev_row); 1.1177 + png_free(png_ptr, png_ptr->chunkdata); 1.1178 +#if defined(PNG_READ_DITHER_SUPPORTED) 1.1179 + png_free(png_ptr, png_ptr->palette_lookup); 1.1180 + png_free(png_ptr, png_ptr->dither_index); 1.1181 +#endif 1.1182 +#if defined(PNG_READ_GAMMA_SUPPORTED) 1.1183 + png_free(png_ptr, png_ptr->gamma_table); 1.1184 +#endif 1.1185 +#if defined(PNG_READ_BACKGROUND_SUPPORTED) 1.1186 + png_free(png_ptr, png_ptr->gamma_from_1); 1.1187 + png_free(png_ptr, png_ptr->gamma_to_1); 1.1188 +#endif 1.1189 +#ifdef PNG_FREE_ME_SUPPORTED 1.1190 + if (png_ptr->free_me & PNG_FREE_PLTE) 1.1191 + png_zfree(png_ptr, png_ptr->palette); 1.1192 + png_ptr->free_me &= ~PNG_FREE_PLTE; 1.1193 +#else 1.1194 + if (png_ptr->flags & PNG_FLAG_FREE_PLTE) 1.1195 + png_zfree(png_ptr, png_ptr->palette); 1.1196 + png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; 1.1197 +#endif 1.1198 +#if defined(PNG_tRNS_SUPPORTED) || \ 1.1199 + defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1.1200 +#ifdef PNG_FREE_ME_SUPPORTED 1.1201 + if (png_ptr->free_me & PNG_FREE_TRNS) 1.1202 + png_free(png_ptr, png_ptr->trans); 1.1203 + png_ptr->free_me &= ~PNG_FREE_TRNS; 1.1204 +#else 1.1205 + if (png_ptr->flags & PNG_FLAG_FREE_TRNS) 1.1206 + png_free(png_ptr, png_ptr->trans); 1.1207 + png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; 1.1208 +#endif 1.1209 +#endif 1.1210 +#if defined(PNG_READ_hIST_SUPPORTED) 1.1211 +#ifdef PNG_FREE_ME_SUPPORTED 1.1212 + if (png_ptr->free_me & PNG_FREE_HIST) 1.1213 + png_free(png_ptr, png_ptr->hist); 1.1214 + png_ptr->free_me &= ~PNG_FREE_HIST; 1.1215 +#else 1.1216 + if (png_ptr->flags & PNG_FLAG_FREE_HIST) 1.1217 + png_free(png_ptr, png_ptr->hist); 1.1218 + png_ptr->flags &= ~PNG_FLAG_FREE_HIST; 1.1219 +#endif 1.1220 +#endif 1.1221 +#if defined(PNG_READ_GAMMA_SUPPORTED) 1.1222 + if (png_ptr->gamma_16_table != NULL) 1.1223 + { 1.1224 + int i; 1.1225 + int istop = (1 << (8 - png_ptr->gamma_shift)); 1.1226 + for (i = 0; i < istop; i++) 1.1227 + { 1.1228 + png_free(png_ptr, png_ptr->gamma_16_table[i]); 1.1229 + } 1.1230 + png_free(png_ptr, png_ptr->gamma_16_table); 1.1231 + } 1.1232 +#if defined(PNG_READ_BACKGROUND_SUPPORTED) 1.1233 + if (png_ptr->gamma_16_from_1 != NULL) 1.1234 + { 1.1235 + int i; 1.1236 + int istop = (1 << (8 - png_ptr->gamma_shift)); 1.1237 + for (i = 0; i < istop; i++) 1.1238 + { 1.1239 + png_free(png_ptr, png_ptr->gamma_16_from_1[i]); 1.1240 + } 1.1241 + png_free(png_ptr, png_ptr->gamma_16_from_1); 1.1242 + } 1.1243 + if (png_ptr->gamma_16_to_1 != NULL) 1.1244 + { 1.1245 + int i; 1.1246 + int istop = (1 << (8 - png_ptr->gamma_shift)); 1.1247 + for (i = 0; i < istop; i++) 1.1248 + { 1.1249 + png_free(png_ptr, png_ptr->gamma_16_to_1[i]); 1.1250 + } 1.1251 + png_free(png_ptr, png_ptr->gamma_16_to_1); 1.1252 + } 1.1253 +#endif 1.1254 +#endif 1.1255 +#if defined(PNG_TIME_RFC1123_SUPPORTED) 1.1256 + png_free(png_ptr, png_ptr->time_buffer); 1.1257 +#endif 1.1258 + 1.1259 + inflateEnd(&png_ptr->zstream); 1.1260 +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1.1261 + png_free(png_ptr, png_ptr->save_buffer); 1.1262 +#endif 1.1263 + 1.1264 +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1.1265 +#ifdef PNG_TEXT_SUPPORTED 1.1266 + png_free(png_ptr, png_ptr->current_text); 1.1267 +#endif /* PNG_TEXT_SUPPORTED */ 1.1268 +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ 1.1269 + 1.1270 + /* Save the important info out of the png_struct, in case it is 1.1271 + * being used again. 1.1272 + */ 1.1273 +#ifdef PNG_SETJMP_SUPPORTED 1.1274 + png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); 1.1275 +#endif 1.1276 + 1.1277 + error_fn = png_ptr->error_fn; 1.1278 + warning_fn = png_ptr->warning_fn; 1.1279 + error_ptr = png_ptr->error_ptr; 1.1280 +#ifdef PNG_USER_MEM_SUPPORTED 1.1281 + free_fn = png_ptr->free_fn; 1.1282 +#endif 1.1283 + 1.1284 + png_memset(png_ptr, 0, png_sizeof(png_struct)); 1.1285 + 1.1286 + png_ptr->error_fn = error_fn; 1.1287 + png_ptr->warning_fn = warning_fn; 1.1288 + png_ptr->error_ptr = error_ptr; 1.1289 +#ifdef PNG_USER_MEM_SUPPORTED 1.1290 + png_ptr->free_fn = free_fn; 1.1291 +#endif 1.1292 + 1.1293 +#ifdef PNG_SETJMP_SUPPORTED 1.1294 + png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); 1.1295 +#endif 1.1296 + 1.1297 +} 1.1298 + 1.1299 +void PNGAPI 1.1300 +png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) 1.1301 +{ 1.1302 + if (png_ptr == NULL) return; 1.1303 + png_ptr->read_row_fn = read_row_fn; 1.1304 +} 1.1305 + 1.1306 + 1.1307 +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED 1.1308 +#if defined(PNG_INFO_IMAGE_SUPPORTED) 1.1309 +void PNGAPI 1.1310 +png_read_png(png_structp png_ptr, png_infop info_ptr, 1.1311 + int transforms, 1.1312 + voidp params) 1.1313 +{ 1.1314 + int row; 1.1315 + 1.1316 + if (png_ptr == NULL) return; 1.1317 +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) 1.1318 + /* invert the alpha channel from opacity to transparency 1.1319 + */ 1.1320 + if (transforms & PNG_TRANSFORM_INVERT_ALPHA) 1.1321 + png_set_invert_alpha(png_ptr); 1.1322 +#endif 1.1323 + 1.1324 + /* png_read_info() gives us all of the information from the 1.1325 + * PNG file before the first IDAT (image data chunk). 1.1326 + */ 1.1327 + png_read_info(png_ptr, info_ptr); 1.1328 + if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) 1.1329 + png_error(png_ptr, "Image is too high to process with png_read_png()"); 1.1330 + 1.1331 + /* -------------- image transformations start here ------------------- */ 1.1332 + 1.1333 +#if defined(PNG_READ_16_TO_8_SUPPORTED) 1.1334 + /* tell libpng to strip 16 bit/color files down to 8 bits per color 1.1335 + */ 1.1336 + if (transforms & PNG_TRANSFORM_STRIP_16) 1.1337 + png_set_strip_16(png_ptr); 1.1338 +#endif 1.1339 + 1.1340 +#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) 1.1341 + /* Strip alpha bytes from the input data without combining with 1.1342 + * the background (not recommended). 1.1343 + */ 1.1344 + if (transforms & PNG_TRANSFORM_STRIP_ALPHA) 1.1345 + png_set_strip_alpha(png_ptr); 1.1346 +#endif 1.1347 + 1.1348 +#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) 1.1349 + /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single 1.1350 + * byte into separate bytes (useful for paletted and grayscale images). 1.1351 + */ 1.1352 + if (transforms & PNG_TRANSFORM_PACKING) 1.1353 + png_set_packing(png_ptr); 1.1354 +#endif 1.1355 + 1.1356 +#if defined(PNG_READ_PACKSWAP_SUPPORTED) 1.1357 + /* Change the order of packed pixels to least significant bit first 1.1358 + * (not useful if you are using png_set_packing). 1.1359 + */ 1.1360 + if (transforms & PNG_TRANSFORM_PACKSWAP) 1.1361 + png_set_packswap(png_ptr); 1.1362 +#endif 1.1363 + 1.1364 +#if defined(PNG_READ_EXPAND_SUPPORTED) 1.1365 + /* Expand paletted colors into true RGB triplets 1.1366 + * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel 1.1367 + * Expand paletted or RGB images with transparency to full alpha 1.1368 + * channels so the data will be available as RGBA quartets. 1.1369 + */ 1.1370 + if (transforms & PNG_TRANSFORM_EXPAND) 1.1371 + if ((png_ptr->bit_depth < 8) || 1.1372 + (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || 1.1373 + (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) 1.1374 + png_set_expand(png_ptr); 1.1375 +#endif 1.1376 + 1.1377 + /* We don't handle background color or gamma transformation or dithering. 1.1378 + */ 1.1379 + 1.1380 +#if defined(PNG_READ_INVERT_SUPPORTED) 1.1381 + /* invert monochrome files to have 0 as white and 1 as black 1.1382 + */ 1.1383 + if (transforms & PNG_TRANSFORM_INVERT_MONO) 1.1384 + png_set_invert_mono(png_ptr); 1.1385 +#endif 1.1386 + 1.1387 +#if defined(PNG_READ_SHIFT_SUPPORTED) 1.1388 + /* If you want to shift the pixel values from the range [0,255] or 1.1389 + * [0,65535] to the original [0,7] or [0,31], or whatever range the 1.1390 + * colors were originally in: 1.1391 + */ 1.1392 + if ((transforms & PNG_TRANSFORM_SHIFT) 1.1393 + && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) 1.1394 + { 1.1395 + png_color_8p sig_bit; 1.1396 + 1.1397 + png_get_sBIT(png_ptr, info_ptr, &sig_bit); 1.1398 + png_set_shift(png_ptr, sig_bit); 1.1399 + } 1.1400 +#endif 1.1401 + 1.1402 +#if defined(PNG_READ_BGR_SUPPORTED) 1.1403 + /* flip the RGB pixels to BGR (or RGBA to BGRA) 1.1404 + */ 1.1405 + if (transforms & PNG_TRANSFORM_BGR) 1.1406 + png_set_bgr(png_ptr); 1.1407 +#endif 1.1408 + 1.1409 +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) 1.1410 + /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) 1.1411 + */ 1.1412 + if (transforms & PNG_TRANSFORM_SWAP_ALPHA) 1.1413 + png_set_swap_alpha(png_ptr); 1.1414 +#endif 1.1415 + 1.1416 +#if defined(PNG_READ_SWAP_SUPPORTED) 1.1417 + /* swap bytes of 16 bit files to least significant byte first 1.1418 + */ 1.1419 + if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) 1.1420 + png_set_swap(png_ptr); 1.1421 +#endif 1.1422 + 1.1423 + /* We don't handle adding filler bytes */ 1.1424 + 1.1425 + /* Optional call to gamma correct and add the background to the palette 1.1426 + * and update info structure. REQUIRED if you are expecting libpng to 1.1427 + * update the palette for you (i.e., you selected such a transform above). 1.1428 + */ 1.1429 + png_read_update_info(png_ptr, info_ptr); 1.1430 + 1.1431 + /* -------------- image transformations end here ------------------- */ 1.1432 + 1.1433 +#ifdef PNG_FREE_ME_SUPPORTED 1.1434 + png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); 1.1435 +#endif 1.1436 + if (info_ptr->row_pointers == NULL) 1.1437 + { 1.1438 + info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, 1.1439 + info_ptr->height * png_sizeof(png_bytep)); 1.1440 +#ifdef PNG_FREE_ME_SUPPORTED 1.1441 + info_ptr->free_me |= PNG_FREE_ROWS; 1.1442 +#endif 1.1443 + for (row = 0; row < (int)info_ptr->height; row++) 1.1444 + { 1.1445 + info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, 1.1446 + png_get_rowbytes(png_ptr, info_ptr)); 1.1447 + } 1.1448 + } 1.1449 + 1.1450 + png_read_image(png_ptr, info_ptr->row_pointers); 1.1451 + info_ptr->valid |= PNG_INFO_IDAT; 1.1452 + 1.1453 + /* read rest of file, and get additional chunks in info_ptr - REQUIRED */ 1.1454 + png_read_end(png_ptr, info_ptr); 1.1455 + 1.1456 + transforms = transforms; /* quiet compiler warnings */ 1.1457 + params = params; 1.1458 + 1.1459 +} 1.1460 +#endif /* PNG_INFO_IMAGE_SUPPORTED */ 1.1461 +#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ 1.1462 +#endif /* PNG_READ_SUPPORTED */