1 2 /* pngread.c - read a PNG file 3 * 4 * Last changed in libpng 1.2.44 [June 26, 2010] 5 * Copyright (c) 1998-2010 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 #define PNG_INTERNAL 18 #define PNG_NO_PEDANTIC_WARNINGS 19 #include "png.h" 20 #ifdef PNG_READ_SUPPORTED 21 22 23 /* Create a PNG structure for reading, and allocate any memory needed. */ 24 png_structp PNGAPI 25 png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, 26 png_error_ptr error_fn, png_error_ptr warn_fn) 27 { 28 29 #ifdef PNG_USER_MEM_SUPPORTED 30 return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, 31 warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); 32 } 33 34 /* Alternate create PNG structure for reading, and allocate any memory 35 * needed. 36 */ 37 png_structp PNGAPI 38 png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, 39 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 40 png_malloc_ptr malloc_fn, png_free_ptr free_fn) 41 { 42 #endif /* PNG_USER_MEM_SUPPORTED */ 43 44 #ifdef PNG_SETJMP_SUPPORTED 45 volatile 46 #endif 47 png_structp png_ptr; 48 49 #ifdef PNG_SETJMP_SUPPORTED 50 #ifdef USE_FAR_KEYWORD 51 jmp_buf jmpbuf; 52 #endif 53 #endif 54 55 int i; 56 57 png_debug(1, "in png_create_read_struct"); 58 59 #ifdef PNG_USER_MEM_SUPPORTED 60 png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, 61 (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); 62 #else 63 png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); 64 #endif 65 if (png_ptr == NULL) 66 return (NULL); 67 68 /* Added at libpng-1.2.6 */ 69 #ifdef PNG_USER_LIMITS_SUPPORTED 70 png_ptr->user_width_max = PNG_USER_WIDTH_MAX; 71 png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; 72 # ifdef PNG_USER_CHUNK_CACHE_MAX 73 /* Added at libpng-1.2.43 and 1.4.0 */ 74 png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; 75 # endif 76 # ifdef PNG_SET_USER_CHUNK_MALLOC_MAX 77 /* Added at libpng-1.2.43 and 1.4.1 */ 78 png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; 79 # endif 80 #endif 81 82 #ifdef PNG_SETJMP_SUPPORTED 83 #ifdef USE_FAR_KEYWORD 84 if (setjmp(jmpbuf)) 85 #else 86 if (setjmp(png_ptr->jmpbuf)) 87 #endif 88 { 89 png_free(png_ptr, png_ptr->zbuf); 90 png_ptr->zbuf = NULL; 91 #ifdef PNG_USER_MEM_SUPPORTED 92 png_destroy_struct_2((png_voidp)png_ptr, 93 (png_free_ptr)free_fn, (png_voidp)mem_ptr); 94 #else 95 png_destroy_struct((png_voidp)png_ptr); 96 #endif 97 return (NULL); 98 } 99 #ifdef USE_FAR_KEYWORD 100 png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); 101 #endif 102 #endif /* PNG_SETJMP_SUPPORTED */ 103 104 #ifdef PNG_USER_MEM_SUPPORTED 105 png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); 106 #endif 107 108 png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); 109 110 if (user_png_ver) 111 { 112 i = 0; 113 do 114 { 115 if (user_png_ver[i] != png_libpng_ver[i]) 116 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 117 } while (png_libpng_ver[i++]); 118 } 119 else 120 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 121 122 123 if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) 124 { 125 /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so 126 * we must recompile any applications that use any older library version. 127 * For versions after libpng 1.0, we will be compatible, so we need 128 * only check the first digit. 129 */ 130 if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || 131 (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || 132 (user_png_ver[0] == '0' && user_png_ver[2] < '9')) 133 { 134 #if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) 135 char msg[80]; 136 if (user_png_ver) 137 { 138 png_snprintf(msg, 80, 139 "Application was compiled with png.h from libpng-%.20s", 140 user_png_ver); 141 png_warning(png_ptr, msg); 142 } 143 png_snprintf(msg, 80, 144 "Application is running with png.c from libpng-%.20s", 145 png_libpng_ver); 146 png_warning(png_ptr, msg); 147 #endif 148 #ifdef PNG_ERROR_NUMBERS_SUPPORTED 149 png_ptr->flags = 0; 150 #endif 151 png_error(png_ptr, 152 "Incompatible libpng version in application and library"); 153 } 154 } 155 156 /* Initialize zbuf - compression buffer */ 157 png_ptr->zbuf_size = PNG_ZBUF_SIZE; 158 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, 159 (png_uint_32)png_ptr->zbuf_size); 160 png_ptr->zstream.zalloc = png_zalloc; 161 png_ptr->zstream.zfree = png_zfree; 162 png_ptr->zstream.opaque = (voidpf)png_ptr; 163 164 switch (inflateInit(&png_ptr->zstream)) 165 { 166 case Z_OK: /* Do nothing */ break; 167 case Z_MEM_ERROR: 168 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); 169 break; 170 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); 171 break; 172 default: png_error(png_ptr, "Unknown zlib error"); 173 } 174 175 176 png_ptr->zstream.next_out = png_ptr->zbuf; 177 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; 178 179 png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); 180 181 #ifdef PNG_SETJMP_SUPPORTED 182 /* Applications that neglect to set up their own setjmp() and then 183 encounter a png_error() will longjmp here. Since the jmpbuf is 184 then meaningless we abort instead of returning. */ 185 #ifdef USE_FAR_KEYWORD 186 if (setjmp(jmpbuf)) 187 PNG_ABORT(); 188 png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); 189 #else 190 if (setjmp(png_ptr->jmpbuf)) 191 PNG_ABORT(); 192 #endif 193 #endif /* PNG_SETJMP_SUPPORTED */ 194 195 #ifdef PNG_INDEX_SUPPORTED 196 png_ptr->index = NULL; 197 #endif 198 199 return (png_ptr); 200 } 201 202 #if defined(PNG_1_0_X) || defined(PNG_1_2_X) 203 /* Initialize PNG structure for reading, and allocate any memory needed. 204 * This interface is deprecated in favour of the png_create_read_struct(), 205 * and it will disappear as of libpng-1.3.0. 206 */ 207 #undef png_read_init 208 void PNGAPI 209 png_read_init(png_structp png_ptr) 210 { 211 /* We only come here via pre-1.0.7-compiled applications */ 212 png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); 213 } 214 215 void PNGAPI 216 png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, 217 png_size_t png_struct_size, png_size_t png_info_size) 218 { 219 /* We only come here via pre-1.0.12-compiled applications */ 220 if (png_ptr == NULL) 221 return; 222 #if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) 223 if (png_sizeof(png_struct) > png_struct_size || 224 png_sizeof(png_info) > png_info_size) 225 { 226 char msg[80]; 227 png_ptr->warning_fn = NULL; 228 if (user_png_ver) 229 { 230 png_snprintf(msg, 80, 231 "Application was compiled with png.h from libpng-%.20s", 232 user_png_ver); 233 png_warning(png_ptr, msg); 234 } 235 png_snprintf(msg, 80, 236 "Application is running with png.c from libpng-%.20s", 237 png_libpng_ver); 238 png_warning(png_ptr, msg); 239 } 240 #endif 241 if (png_sizeof(png_struct) > png_struct_size) 242 { 243 png_ptr->error_fn = NULL; 244 #ifdef PNG_ERROR_NUMBERS_SUPPORTED 245 png_ptr->flags = 0; 246 #endif 247 png_error(png_ptr, 248 "The png struct allocated by the application for reading is" 249 " too small."); 250 } 251 if (png_sizeof(png_info) > png_info_size) 252 { 253 png_ptr->error_fn = NULL; 254 #ifdef PNG_ERROR_NUMBERS_SUPPORTED 255 png_ptr->flags = 0; 256 #endif 257 png_error(png_ptr, 258 "The info struct allocated by application for reading is" 259 " too small."); 260 } 261 png_read_init_3(&png_ptr, user_png_ver, png_struct_size); 262 } 263 #endif /* PNG_1_0_X || PNG_1_2_X */ 264 265 void PNGAPI 266 png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, 267 png_size_t png_struct_size) 268 { 269 #ifdef PNG_SETJMP_SUPPORTED 270 jmp_buf tmp_jmp; /* to save current jump buffer */ 271 #endif 272 273 int i = 0; 274 275 png_structp png_ptr=*ptr_ptr; 276 277 if (png_ptr == NULL) 278 return; 279 280 do 281 { 282 if (user_png_ver[i] != png_libpng_ver[i]) 283 { 284 #ifdef PNG_LEGACY_SUPPORTED 285 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 286 #else 287 png_ptr->warning_fn = NULL; 288 png_warning(png_ptr, 289 "Application uses deprecated png_read_init() and should be" 290 " recompiled."); 291 break; 292 #endif 293 } 294 } while (png_libpng_ver[i++]); 295 296 png_debug(1, "in png_read_init_3"); 297 298 #ifdef PNG_SETJMP_SUPPORTED 299 /* Save jump buffer and error functions */ 300 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); 301 #endif 302 303 if (png_sizeof(png_struct) > png_struct_size) 304 { 305 png_destroy_struct(png_ptr); 306 *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); 307 png_ptr = *ptr_ptr; 308 } 309 310 /* Reset all variables to 0 */ 311 png_memset(png_ptr, 0, png_sizeof(png_struct)); 312 313 #ifdef PNG_SETJMP_SUPPORTED 314 /* Restore jump buffer */ 315 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); 316 #endif 317 318 /* Added at libpng-1.2.6 */ 319 #ifdef PNG_SET_USER_LIMITS_SUPPORTED 320 png_ptr->user_width_max = PNG_USER_WIDTH_MAX; 321 png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; 322 #endif 323 324 /* Initialize zbuf - compression buffer */ 325 png_ptr->zbuf_size = PNG_ZBUF_SIZE; 326 png_ptr->zstream.zalloc = png_zalloc; 327 png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, 328 (png_uint_32)png_ptr->zbuf_size); 329 png_ptr->zstream.zalloc = png_zalloc; 330 png_ptr->zstream.zfree = png_zfree; 331 png_ptr->zstream.opaque = (voidpf)png_ptr; 332 333 switch (inflateInit(&png_ptr->zstream)) 334 { 335 case Z_OK: /* Do nothing */ break; 336 case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; 337 case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); 338 break; 339 default: png_error(png_ptr, "Unknown zlib error"); 340 } 341 342 png_ptr->zstream.next_out = png_ptr->zbuf; 343 png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; 344 345 png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); 346 } 347 348 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 349 /* Read the information before the actual image data. This has been 350 * changed in v0.90 to allow reading a file that already has the magic 351 * bytes read from the stream. You can tell libpng how many bytes have 352 * been read from the beginning of the stream (up to the maximum of 8) 353 * via png_set_sig_bytes(), and we will only check the remaining bytes 354 * here. The application can then have access to the signature bytes we 355 * read if it is determined that this isn't a valid PNG file. 356 */ 357 void PNGAPI 358 png_read_info(png_structp png_ptr, png_infop info_ptr) 359 { 360 png_debug(1, "in png_read_info"); 361 362 if (png_ptr == NULL || info_ptr == NULL) 363 return; 364 365 /* If we haven't checked all of the PNG signature bytes, do so now. */ 366 if (png_ptr->sig_bytes < 8) 367 { 368 png_size_t num_checked = png_ptr->sig_bytes, 369 num_to_check = 8 - num_checked; 370 371 png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); 372 png_ptr->sig_bytes = 8; 373 374 if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) 375 { 376 if (num_checked < 4 && 377 png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) 378 png_error(png_ptr, "Not a PNG file"); 379 else 380 png_error(png_ptr, "PNG file corrupted by ASCII conversion"); 381 } 382 if (num_checked < 3) 383 png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; 384 } 385 386 for (;;) 387 { 388 #ifdef PNG_USE_LOCAL_ARRAYS 389 PNG_CONST PNG_IHDR; 390 PNG_CONST PNG_IDAT; 391 PNG_CONST PNG_IEND; 392 PNG_CONST PNG_PLTE; 393 #ifdef PNG_READ_bKGD_SUPPORTED 394 PNG_CONST PNG_bKGD; 395 #endif 396 #ifdef PNG_READ_cHRM_SUPPORTED 397 PNG_CONST PNG_cHRM; 398 #endif 399 #ifdef PNG_READ_gAMA_SUPPORTED 400 PNG_CONST PNG_gAMA; 401 #endif 402 #ifdef PNG_READ_hIST_SUPPORTED 403 PNG_CONST PNG_hIST; 404 #endif 405 #ifdef PNG_READ_iCCP_SUPPORTED 406 PNG_CONST PNG_iCCP; 407 #endif 408 #ifdef PNG_READ_iTXt_SUPPORTED 409 PNG_CONST PNG_iTXt; 410 #endif 411 #ifdef PNG_READ_oFFs_SUPPORTED 412 PNG_CONST PNG_oFFs; 413 #endif 414 #ifdef PNG_READ_pCAL_SUPPORTED 415 PNG_CONST PNG_pCAL; 416 #endif 417 #ifdef PNG_READ_pHYs_SUPPORTED 418 PNG_CONST PNG_pHYs; 419 #endif 420 #ifdef PNG_READ_sBIT_SUPPORTED 421 PNG_CONST PNG_sBIT; 422 #endif 423 #ifdef PNG_READ_sCAL_SUPPORTED 424 PNG_CONST PNG_sCAL; 425 #endif 426 #ifdef PNG_READ_sPLT_SUPPORTED 427 PNG_CONST PNG_sPLT; 428 #endif 429 #ifdef PNG_READ_sRGB_SUPPORTED 430 PNG_CONST PNG_sRGB; 431 #endif 432 #ifdef PNG_READ_tEXt_SUPPORTED 433 PNG_CONST PNG_tEXt; 434 #endif 435 #ifdef PNG_READ_tIME_SUPPORTED 436 PNG_CONST PNG_tIME; 437 #endif 438 #ifdef PNG_READ_tRNS_SUPPORTED 439 PNG_CONST PNG_tRNS; 440 #endif 441 #ifdef PNG_READ_zTXt_SUPPORTED 442 PNG_CONST PNG_zTXt; 443 #endif 444 #endif /* PNG_USE_LOCAL_ARRAYS */ 445 png_uint_32 length = png_read_chunk_header(png_ptr); 446 PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; 447 448 /* This should be a binary subdivision search or a hash for 449 * matching the chunk name rather than a linear search. 450 */ 451 if (!png_memcmp(chunk_name, png_IDAT, 4)) 452 if (png_ptr->mode & PNG_AFTER_IDAT) 453 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; 454 455 if (!png_memcmp(chunk_name, png_IHDR, 4)) 456 png_handle_IHDR(png_ptr, info_ptr, length); 457 else if (!png_memcmp(chunk_name, png_IEND, 4)) 458 png_handle_IEND(png_ptr, info_ptr, length); 459 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 460 else if (png_handle_as_unknown(png_ptr, chunk_name)) 461 { 462 if (!png_memcmp(chunk_name, png_IDAT, 4)) 463 png_ptr->mode |= PNG_HAVE_IDAT; 464 png_handle_unknown(png_ptr, info_ptr, length); 465 if (!png_memcmp(chunk_name, png_PLTE, 4)) 466 png_ptr->mode |= PNG_HAVE_PLTE; 467 else if (!png_memcmp(chunk_name, png_IDAT, 4)) 468 { 469 if (!(png_ptr->mode & PNG_HAVE_IHDR)) 470 png_error(png_ptr, "Missing IHDR before IDAT"); 471 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 472 !(png_ptr->mode & PNG_HAVE_PLTE)) 473 png_error(png_ptr, "Missing PLTE before IDAT"); 474 break; 475 } 476 } 477 #endif 478 else if (!png_memcmp(chunk_name, png_PLTE, 4)) 479 png_handle_PLTE(png_ptr, info_ptr, length); 480 else if (!png_memcmp(chunk_name, png_IDAT, 4)) 481 { 482 if (!(png_ptr->mode & PNG_HAVE_IHDR)) 483 png_error(png_ptr, "Missing IHDR before IDAT"); 484 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 485 !(png_ptr->mode & PNG_HAVE_PLTE)) 486 png_error(png_ptr, "Missing PLTE before IDAT"); 487 488 png_ptr->idat_size = length; 489 png_ptr->mode |= PNG_HAVE_IDAT; 490 break; 491 } 492 #ifdef PNG_READ_bKGD_SUPPORTED 493 else if (!png_memcmp(chunk_name, png_bKGD, 4)) 494 png_handle_bKGD(png_ptr, info_ptr, length); 495 #endif 496 #ifdef PNG_READ_cHRM_SUPPORTED 497 else if (!png_memcmp(chunk_name, png_cHRM, 4)) 498 png_handle_cHRM(png_ptr, info_ptr, length); 499 #endif 500 #ifdef PNG_READ_gAMA_SUPPORTED 501 else if (!png_memcmp(chunk_name, png_gAMA, 4)) 502 png_handle_gAMA(png_ptr, info_ptr, length); 503 #endif 504 #ifdef PNG_READ_hIST_SUPPORTED 505 else if (!png_memcmp(chunk_name, png_hIST, 4)) 506 png_handle_hIST(png_ptr, info_ptr, length); 507 #endif 508 #ifdef PNG_READ_oFFs_SUPPORTED 509 else if (!png_memcmp(chunk_name, png_oFFs, 4)) 510 png_handle_oFFs(png_ptr, info_ptr, length); 511 #endif 512 #ifdef PNG_READ_pCAL_SUPPORTED 513 else if (!png_memcmp(chunk_name, png_pCAL, 4)) 514 png_handle_pCAL(png_ptr, info_ptr, length); 515 #endif 516 #ifdef PNG_READ_sCAL_SUPPORTED 517 else if (!png_memcmp(chunk_name, png_sCAL, 4)) 518 png_handle_sCAL(png_ptr, info_ptr, length); 519 #endif 520 #ifdef PNG_READ_pHYs_SUPPORTED 521 else if (!png_memcmp(chunk_name, png_pHYs, 4)) 522 png_handle_pHYs(png_ptr, info_ptr, length); 523 #endif 524 #ifdef PNG_READ_sBIT_SUPPORTED 525 else if (!png_memcmp(chunk_name, png_sBIT, 4)) 526 png_handle_sBIT(png_ptr, info_ptr, length); 527 #endif 528 #ifdef PNG_READ_sRGB_SUPPORTED 529 else if (!png_memcmp(chunk_name, png_sRGB, 4)) 530 png_handle_sRGB(png_ptr, info_ptr, length); 531 #endif 532 #ifdef PNG_READ_iCCP_SUPPORTED 533 else if (!png_memcmp(chunk_name, png_iCCP, 4)) 534 png_handle_iCCP(png_ptr, info_ptr, length); 535 #endif 536 #ifdef PNG_READ_sPLT_SUPPORTED 537 else if (!png_memcmp(chunk_name, png_sPLT, 4)) 538 png_handle_sPLT(png_ptr, info_ptr, length); 539 #endif 540 #ifdef PNG_READ_tEXt_SUPPORTED 541 else if (!png_memcmp(chunk_name, png_tEXt, 4)) 542 png_handle_tEXt(png_ptr, info_ptr, length); 543 #endif 544 #ifdef PNG_READ_tIME_SUPPORTED 545 else if (!png_memcmp(chunk_name, png_tIME, 4)) 546 png_handle_tIME(png_ptr, info_ptr, length); 547 #endif 548 #ifdef PNG_READ_tRNS_SUPPORTED 549 else if (!png_memcmp(chunk_name, png_tRNS, 4)) 550 png_handle_tRNS(png_ptr, info_ptr, length); 551 #endif 552 #ifdef PNG_READ_zTXt_SUPPORTED 553 else if (!png_memcmp(chunk_name, png_zTXt, 4)) 554 png_handle_zTXt(png_ptr, info_ptr, length); 555 #endif 556 #ifdef PNG_READ_iTXt_SUPPORTED 557 else if (!png_memcmp(chunk_name, png_iTXt, 4)) 558 png_handle_iTXt(png_ptr, info_ptr, length); 559 #endif 560 else 561 png_handle_unknown(png_ptr, info_ptr, length); 562 } 563 } 564 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 565 566 /* Optional call to update the users info_ptr structure */ 567 void PNGAPI 568 png_read_update_info(png_structp png_ptr, png_infop info_ptr) 569 { 570 png_debug(1, "in png_read_update_info"); 571 572 if (png_ptr == NULL) 573 return; 574 #ifdef PNG_INDEX_SUPPORTED 575 if (png_ptr->index) { 576 png_read_start_row(png_ptr); 577 } 578 #endif 579 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 580 png_read_start_row(png_ptr); 581 else 582 png_warning(png_ptr, 583 "Ignoring extra png_read_update_info() call; row buffer not reallocated"); 584 585 png_read_transform_info(png_ptr, info_ptr); 586 } 587 588 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 589 /* Initialize palette, background, etc, after transformations 590 * are set, but before any reading takes place. This allows 591 * the user to obtain a gamma-corrected palette, for example. 592 * If the user doesn't call this, we will do it ourselves. 593 */ 594 void PNGAPI 595 png_start_read_image(png_structp png_ptr) 596 { 597 png_debug(1, "in png_start_read_image"); 598 599 if (png_ptr == NULL) 600 return; 601 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 602 png_read_start_row(png_ptr); 603 } 604 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 605 606 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 607 void PNGAPI 608 png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) 609 { 610 PNG_CONST PNG_IDAT; 611 PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 612 0xff}; 613 PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; 614 int ret; 615 616 if (png_ptr == NULL) 617 return; 618 619 png_debug2(1, "in png_read_row (row %lu, pass %d)", 620 png_ptr->row_number, png_ptr->pass); 621 622 if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) 623 png_read_start_row(png_ptr); 624 if (png_ptr->row_number == 0 && png_ptr->pass == 0) 625 { 626 /* Check for transforms that have been set but were defined out */ 627 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) 628 if (png_ptr->transformations & PNG_INVERT_MONO) 629 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); 630 #endif 631 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) 632 if (png_ptr->transformations & PNG_FILLER) 633 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); 634 #endif 635 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ 636 !defined(PNG_READ_PACKSWAP_SUPPORTED) 637 if (png_ptr->transformations & PNG_PACKSWAP) 638 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); 639 #endif 640 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) 641 if (png_ptr->transformations & PNG_PACK) 642 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); 643 #endif 644 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) 645 if (png_ptr->transformations & PNG_SHIFT) 646 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); 647 #endif 648 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) 649 if (png_ptr->transformations & PNG_BGR) 650 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); 651 #endif 652 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) 653 if (png_ptr->transformations & PNG_SWAP_BYTES) 654 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); 655 #endif 656 } 657 658 #ifdef PNG_READ_INTERLACING_SUPPORTED 659 /* If interlaced and we do not need a new row, combine row and return */ 660 if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) 661 { 662 switch (png_ptr->pass) 663 { 664 case 0: 665 if (png_ptr->row_number & 0x07) 666 { 667 if (dsp_row != NULL) 668 png_combine_row(png_ptr, dsp_row, 669 png_pass_dsp_mask[png_ptr->pass]); 670 png_read_finish_row(png_ptr); 671 return; 672 } 673 break; 674 case 1: 675 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) 676 { 677 if (dsp_row != NULL) 678 png_combine_row(png_ptr, dsp_row, 679 png_pass_dsp_mask[png_ptr->pass]); 680 png_read_finish_row(png_ptr); 681 return; 682 } 683 break; 684 case 2: 685 if ((png_ptr->row_number & 0x07) != 4) 686 { 687 if (dsp_row != NULL && (png_ptr->row_number & 4)) 688 png_combine_row(png_ptr, dsp_row, 689 png_pass_dsp_mask[png_ptr->pass]); 690 png_read_finish_row(png_ptr); 691 return; 692 } 693 break; 694 case 3: 695 if ((png_ptr->row_number & 3) || png_ptr->width < 3) 696 { 697 if (dsp_row != NULL) 698 png_combine_row(png_ptr, dsp_row, 699 png_pass_dsp_mask[png_ptr->pass]); 700 png_read_finish_row(png_ptr); 701 return; 702 } 703 break; 704 case 4: 705 if ((png_ptr->row_number & 3) != 2) 706 { 707 if (dsp_row != NULL && (png_ptr->row_number & 2)) 708 png_combine_row(png_ptr, dsp_row, 709 png_pass_dsp_mask[png_ptr->pass]); 710 png_read_finish_row(png_ptr); 711 return; 712 } 713 break; 714 case 5: 715 if ((png_ptr->row_number & 1) || png_ptr->width < 2) 716 { 717 if (dsp_row != NULL) 718 png_combine_row(png_ptr, dsp_row, 719 png_pass_dsp_mask[png_ptr->pass]); 720 png_read_finish_row(png_ptr); 721 return; 722 } 723 break; 724 case 6: 725 if (!(png_ptr->row_number & 1)) 726 { 727 png_read_finish_row(png_ptr); 728 return; 729 } 730 break; 731 } 732 } 733 #endif 734 735 if (!(png_ptr->mode & PNG_HAVE_IDAT)) 736 png_error(png_ptr, "Invalid attempt to read row data"); 737 738 png_ptr->zstream.next_out = png_ptr->row_buf; 739 png_ptr->zstream.avail_out = 740 (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth, 741 png_ptr->iwidth) + 1); 742 do 743 { 744 if (!(png_ptr->zstream.avail_in)) 745 { 746 while (!png_ptr->idat_size) 747 { 748 #ifdef PNG_INDEX_SUPPORTED 749 if (png_ptr->index) { 750 png_opt_crc_finish(png_ptr, 0, 0); 751 png_ptr->index->stream_idat_position = png_ptr->total_data_read; 752 } else 753 #endif 754 png_crc_finish(png_ptr, 0); 755 756 757 png_ptr->idat_size = png_read_chunk_header(png_ptr); 758 if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) 759 png_error(png_ptr, "Not enough image data"); 760 } 761 png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; 762 png_ptr->zstream.next_in = png_ptr->zbuf; 763 if (png_ptr->zbuf_size > png_ptr->idat_size) 764 png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; 765 png_crc_read(png_ptr, png_ptr->zbuf, 766 (png_size_t)png_ptr->zstream.avail_in); 767 png_ptr->idat_size -= png_ptr->zstream.avail_in; 768 } 769 ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); 770 if (ret == Z_STREAM_END) 771 { 772 if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || 773 png_ptr->idat_size) 774 png_error(png_ptr, "Extra compressed data"); 775 png_ptr->mode |= PNG_AFTER_IDAT; 776 png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; 777 break; 778 } 779 if (ret != Z_OK) 780 #ifdef PNG_INDEX_SUPPORTED 781 if (png_ptr->index && png_ptr->row_number != png_ptr->height - 1) 782 #endif 783 png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : 784 "Decompression error"); 785 786 } while (png_ptr->zstream.avail_out); 787 788 png_ptr->row_info.color_type = png_ptr->color_type; 789 png_ptr->row_info.width = png_ptr->iwidth; 790 png_ptr->row_info.channels = png_ptr->channels; 791 png_ptr->row_info.bit_depth = png_ptr->bit_depth; 792 png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; 793 png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, 794 png_ptr->row_info.width); 795 796 if (png_ptr->row_buf[0]) 797 png_read_filter_row(png_ptr, &(png_ptr->row_info), 798 png_ptr->row_buf + 1, png_ptr->prev_row + 1, 799 (int)(png_ptr->row_buf[0])); 800 801 png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, 802 png_ptr->rowbytes + 1); 803 804 #ifdef PNG_MNG_FEATURES_SUPPORTED 805 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && 806 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) 807 { 808 /* Intrapixel differencing */ 809 png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); 810 } 811 #endif 812 813 814 if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) 815 png_do_read_transformations(png_ptr); 816 817 #ifdef PNG_READ_INTERLACING_SUPPORTED 818 /* Blow up interlaced rows to full size */ 819 if (png_ptr->interlaced && 820 (png_ptr->transformations & PNG_INTERLACE)) 821 { 822 if (png_ptr->pass < 6) 823 /* Old interface (pre-1.0.9): 824 * png_do_read_interlace(&(png_ptr->row_info), 825 * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); 826 */ 827 png_do_read_interlace(png_ptr); 828 829 if (dsp_row != NULL) 830 png_combine_row(png_ptr, dsp_row, 831 png_pass_dsp_mask[png_ptr->pass]); 832 if (row != NULL) 833 png_combine_row(png_ptr, row, 834 png_pass_mask[png_ptr->pass]); 835 } 836 else 837 #endif 838 { 839 if (row != NULL) 840 png_combine_row(png_ptr, row, 0xff); 841 if (dsp_row != NULL) 842 png_combine_row(png_ptr, dsp_row, 0xff); 843 } 844 png_read_finish_row(png_ptr); 845 846 if (png_ptr->read_row_fn != NULL) 847 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); 848 } 849 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 850 851 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 852 /* Read one or more rows of image data. If the image is interlaced, 853 * and png_set_interlace_handling() has been called, the rows need to 854 * contain the contents of the rows from the previous pass. If the 855 * image has alpha or transparency, and png_handle_alpha()[*] has been 856 * called, the rows contents must be initialized to the contents of the 857 * screen. 858 * 859 * "row" holds the actual image, and pixels are placed in it 860 * as they arrive. If the image is displayed after each pass, it will 861 * appear to "sparkle" in. "display_row" can be used to display a 862 * "chunky" progressive image, with finer detail added as it becomes 863 * available. If you do not want this "chunky" display, you may pass 864 * NULL for display_row. If you do not want the sparkle display, and 865 * you have not called png_handle_alpha(), you may pass NULL for rows. 866 * If you have called png_handle_alpha(), and the image has either an 867 * alpha channel or a transparency chunk, you must provide a buffer for 868 * rows. In this case, you do not have to provide a display_row buffer 869 * also, but you may. If the image is not interlaced, or if you have 870 * not called png_set_interlace_handling(), the display_row buffer will 871 * be ignored, so pass NULL to it. 872 * 873 * [*] png_handle_alpha() does not exist yet, as of this version of libpng 874 */ 875 876 void PNGAPI 877 png_read_rows(png_structp png_ptr, png_bytepp row, 878 png_bytepp display_row, png_uint_32 num_rows) 879 { 880 png_uint_32 i; 881 png_bytepp rp; 882 png_bytepp dp; 883 884 png_debug(1, "in png_read_rows"); 885 886 if (png_ptr == NULL) 887 return; 888 rp = row; 889 dp = display_row; 890 if (rp != NULL && dp != NULL) 891 for (i = 0; i < num_rows; i++) 892 { 893 png_bytep rptr = *rp++; 894 png_bytep dptr = *dp++; 895 896 png_read_row(png_ptr, rptr, dptr); 897 } 898 else if (rp != NULL) 899 for (i = 0; i < num_rows; i++) 900 { 901 png_bytep rptr = *rp; 902 png_read_row(png_ptr, rptr, png_bytep_NULL); 903 rp++; 904 } 905 else if (dp != NULL) 906 for (i = 0; i < num_rows; i++) 907 { 908 png_bytep dptr = *dp; 909 png_read_row(png_ptr, png_bytep_NULL, dptr); 910 dp++; 911 } 912 } 913 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 914 915 #ifdef PNG_INDEX_SUPPORTED 916 #define IDAT_HEADER_SIZE 8 917 918 /* Set the png read position to a new position based on idat_position and 919 * offset. 920 */ 921 void 922 png_set_read_offset(png_structp png_ptr, 923 png_uint_32 idat_position, png_uint_32 bytes_left) 924 { 925 png_seek_data(png_ptr, idat_position); 926 png_ptr->idat_size = png_read_chunk_header(png_ptr); 927 928 // We need to add back IDAT_HEADER_SIZE because in zlib's perspective, 929 // IDAT_HEADER in PNG is already stripped out. 930 png_seek_data(png_ptr, idat_position + IDAT_HEADER_SIZE + png_ptr->idat_size - bytes_left); 931 png_ptr->idat_size = bytes_left; 932 } 933 934 /* Configure png decoder to decode the pass starting from *row. 935 * The requested row may be adjusted to align with an indexing row. 936 * The actual row for the decoder to start its decoding will be returned in 937 * *row. 938 */ 939 void PNGAPI 940 png_configure_decoder(png_structp png_ptr, int *row, int pass) 941 { 942 png_indexp index = png_ptr->index; 943 int n = *row / index->step[pass]; 944 png_line_indexp line_index = index->pass_line_index[pass][n]; 945 946 // Adjust row to an indexing row. 947 *row = n * index->step[pass]; 948 png_ptr->row_number = *row; 949 950 #ifdef PNG_READ_INTERLACING_SUPPORTED 951 if (png_ptr->interlaced) 952 png_set_interlaced_pass(png_ptr, pass); 953 #endif 954 955 long row_byte_length = 956 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1; 957 958 inflateEnd(&png_ptr->zstream); 959 inflateCopy(&png_ptr->zstream, line_index->z_state); 960 961 // Set the png read position to line_index. 962 png_set_read_offset(png_ptr, line_index->stream_idat_position, 963 line_index->bytes_left_in_idat); 964 png_memcpy_check(png_ptr, 965 png_ptr->prev_row, line_index->prev_row, row_byte_length); 966 png_ptr->zstream.avail_in = 0; 967 } 968 969 /* Build the line index and store the index in png_ptr->index. 970 */ 971 void PNGAPI 972 png_build_index(png_structp png_ptr) 973 { 974 // number of rows in a 8x8 block for each interlaced pass. 975 int number_rows_in_pass[7] = {1, 1, 1, 2, 2, 4, 4}; 976 977 int ret; 978 png_uint_32 i, j; 979 png_bytep rp; 980 int p, pass_number = 1; 981 982 #ifdef PNG_READ_INTERLACING_SUPPORTED 983 pass_number = png_set_interlace_handling(png_ptr); 984 #endif 985 986 if (png_ptr == NULL) 987 return; 988 989 png_read_start_row(png_ptr); 990 991 #ifdef PNG_READ_INTERLACING_SUPPORTED 992 if (!png_ptr->interlaced) 993 #endif 994 { 995 number_rows_in_pass[0] = 8; 996 } 997 998 rp = png_malloc(png_ptr, png_ptr->rowbytes); 999 1000 png_indexp index = png_malloc(png_ptr, sizeof(png_index)); 1001 png_ptr->index = index; 1002 1003 index->stream_idat_position = png_ptr->total_data_read - IDAT_HEADER_SIZE; 1004 1005 // Set the default size of index in each pass to 0, 1006 // so that we can free index correctly in png_destroy_read_struct. 1007 for (p = 0; p < 7; p++) 1008 index->size[p] = 0; 1009 1010 for (p = 0; p < pass_number; p++) 1011 { 1012 // We adjust the index step in each pass to make sure each pass 1013 // has roughly the same size of index. 1014 // This way, we won't consume to much memory in recording index. 1015 index->step[p] = INDEX_SAMPLE_SIZE * (8 / number_rows_in_pass[p]); 1016 index->size[p] = 1017 (png_ptr->height + index->step[p] - 1) / index->step[p]; 1018 index->pass_line_index[p] = 1019 png_malloc(png_ptr, index->size[p] * sizeof(png_line_indexp)); 1020 1021 // Get the row_byte_length seen by the filter. This value may be 1022 // different from the row_byte_length of a bitmap in the case of 1023 // color palette mode. 1024 int row_byte_length = 1025 PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1; 1026 1027 // Now, we record index for each indexing row. 1028 for (i = 0; i < index->size[p]; i++) 1029 { 1030 png_line_indexp line_index = png_malloc(png_ptr, sizeof(png_line_index)); 1031 index->pass_line_index[p][i] = line_index; 1032 1033 line_index->z_state = png_malloc(png_ptr, sizeof(z_stream)); 1034 inflateCopy(line_index->z_state, &png_ptr->zstream); 1035 line_index->prev_row = png_malloc(png_ptr, row_byte_length); 1036 png_memcpy_check(png_ptr, 1037 line_index->prev_row, png_ptr->prev_row, row_byte_length); 1038 line_index->stream_idat_position = index->stream_idat_position; 1039 line_index->bytes_left_in_idat = png_ptr->idat_size + png_ptr->zstream.avail_in; 1040 1041 // Skip the "step" number of rows to the next indexing row. 1042 for (j = 0; j < index->step[p] && 1043 i * index->step[p] + j < png_ptr->height; j++) 1044 { 1045 png_read_row(png_ptr, rp, png_bytep_NULL); 1046 } 1047 } 1048 } 1049 png_free(png_ptr, rp); 1050 } 1051 #endif 1052 1053 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1054 /* Read the entire image. If the image has an alpha channel or a tRNS 1055 * chunk, and you have called png_handle_alpha()[*], you will need to 1056 * initialize the image to the current image that PNG will be overlaying. 1057 * We set the num_rows again here, in case it was incorrectly set in 1058 * png_read_start_row() by a call to png_read_update_info() or 1059 * png_start_read_image() if png_set_interlace_handling() wasn't called 1060 * prior to either of these functions like it should have been. You can 1061 * only call this function once. If you desire to have an image for 1062 * each pass of a interlaced image, use png_read_rows() instead. 1063 * 1064 * [*] png_handle_alpha() does not exist yet, as of this version of libpng 1065 */ 1066 void PNGAPI 1067 png_read_image(png_structp png_ptr, png_bytepp image) 1068 { 1069 png_uint_32 i, image_height; 1070 int pass, j; 1071 png_bytepp rp; 1072 1073 png_debug(1, "in png_read_image"); 1074 1075 if (png_ptr == NULL) 1076 return; 1077 1078 #ifdef PNG_READ_INTERLACING_SUPPORTED 1079 pass = png_set_interlace_handling(png_ptr); 1080 #else 1081 if (png_ptr->interlaced) 1082 png_error(png_ptr, 1083 "Cannot read interlaced image -- interlace handler disabled."); 1084 pass = 1; 1085 #endif 1086 1087 1088 image_height=png_ptr->height; 1089 png_ptr->num_rows = image_height; /* Make sure this is set correctly */ 1090 1091 for (j = 0; j < pass; j++) 1092 { 1093 rp = image; 1094 for (i = 0; i < image_height; i++) 1095 { 1096 png_read_row(png_ptr, *rp, png_bytep_NULL); 1097 rp++; 1098 } 1099 } 1100 } 1101 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 1102 1103 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1104 /* Read the end of the PNG file. Will not read past the end of the 1105 * file, will verify the end is accurate, and will read any comments 1106 * or time information at the end of the file, if info is not NULL. 1107 */ 1108 void PNGAPI 1109 png_read_end(png_structp png_ptr, png_infop info_ptr) 1110 { 1111 png_debug(1, "in png_read_end"); 1112 1113 if (png_ptr == NULL) 1114 return; 1115 png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ 1116 1117 do 1118 { 1119 #ifdef PNG_USE_LOCAL_ARRAYS 1120 PNG_CONST PNG_IHDR; 1121 PNG_CONST PNG_IDAT; 1122 PNG_CONST PNG_IEND; 1123 PNG_CONST PNG_PLTE; 1124 #ifdef PNG_READ_bKGD_SUPPORTED 1125 PNG_CONST PNG_bKGD; 1126 #endif 1127 #ifdef PNG_READ_cHRM_SUPPORTED 1128 PNG_CONST PNG_cHRM; 1129 #endif 1130 #ifdef PNG_READ_gAMA_SUPPORTED 1131 PNG_CONST PNG_gAMA; 1132 #endif 1133 #ifdef PNG_READ_hIST_SUPPORTED 1134 PNG_CONST PNG_hIST; 1135 #endif 1136 #ifdef PNG_READ_iCCP_SUPPORTED 1137 PNG_CONST PNG_iCCP; 1138 #endif 1139 #ifdef PNG_READ_iTXt_SUPPORTED 1140 PNG_CONST PNG_iTXt; 1141 #endif 1142 #ifdef PNG_READ_oFFs_SUPPORTED 1143 PNG_CONST PNG_oFFs; 1144 #endif 1145 #ifdef PNG_READ_pCAL_SUPPORTED 1146 PNG_CONST PNG_pCAL; 1147 #endif 1148 #ifdef PNG_READ_pHYs_SUPPORTED 1149 PNG_CONST PNG_pHYs; 1150 #endif 1151 #ifdef PNG_READ_sBIT_SUPPORTED 1152 PNG_CONST PNG_sBIT; 1153 #endif 1154 #ifdef PNG_READ_sCAL_SUPPORTED 1155 PNG_CONST PNG_sCAL; 1156 #endif 1157 #ifdef PNG_READ_sPLT_SUPPORTED 1158 PNG_CONST PNG_sPLT; 1159 #endif 1160 #ifdef PNG_READ_sRGB_SUPPORTED 1161 PNG_CONST PNG_sRGB; 1162 #endif 1163 #ifdef PNG_READ_tEXt_SUPPORTED 1164 PNG_CONST PNG_tEXt; 1165 #endif 1166 #ifdef PNG_READ_tIME_SUPPORTED 1167 PNG_CONST PNG_tIME; 1168 #endif 1169 #ifdef PNG_READ_tRNS_SUPPORTED 1170 PNG_CONST PNG_tRNS; 1171 #endif 1172 #ifdef PNG_READ_zTXt_SUPPORTED 1173 PNG_CONST PNG_zTXt; 1174 #endif 1175 #endif /* PNG_USE_LOCAL_ARRAYS */ 1176 png_uint_32 length = png_read_chunk_header(png_ptr); 1177 PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; 1178 1179 if (!png_memcmp(chunk_name, png_IHDR, 4)) 1180 png_handle_IHDR(png_ptr, info_ptr, length); 1181 else if (!png_memcmp(chunk_name, png_IEND, 4)) 1182 png_handle_IEND(png_ptr, info_ptr, length); 1183 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 1184 else if (png_handle_as_unknown(png_ptr, chunk_name)) 1185 { 1186 if (!png_memcmp(chunk_name, png_IDAT, 4)) 1187 { 1188 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) 1189 png_error(png_ptr, "Too many IDAT's found"); 1190 } 1191 png_handle_unknown(png_ptr, info_ptr, length); 1192 if (!png_memcmp(chunk_name, png_PLTE, 4)) 1193 png_ptr->mode |= PNG_HAVE_PLTE; 1194 } 1195 #endif 1196 else if (!png_memcmp(chunk_name, png_IDAT, 4)) 1197 { 1198 /* Zero length IDATs are legal after the last IDAT has been 1199 * read, but not after other chunks have been read. 1200 */ 1201 if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) 1202 png_error(png_ptr, "Too many IDAT's found"); 1203 png_crc_finish(png_ptr, length); 1204 } 1205 else if (!png_memcmp(chunk_name, png_PLTE, 4)) 1206 png_handle_PLTE(png_ptr, info_ptr, length); 1207 #ifdef PNG_READ_bKGD_SUPPORTED 1208 else if (!png_memcmp(chunk_name, png_bKGD, 4)) 1209 png_handle_bKGD(png_ptr, info_ptr, length); 1210 #endif 1211 #ifdef PNG_READ_cHRM_SUPPORTED 1212 else if (!png_memcmp(chunk_name, png_cHRM, 4)) 1213 png_handle_cHRM(png_ptr, info_ptr, length); 1214 #endif 1215 #ifdef PNG_READ_gAMA_SUPPORTED 1216 else if (!png_memcmp(chunk_name, png_gAMA, 4)) 1217 png_handle_gAMA(png_ptr, info_ptr, length); 1218 #endif 1219 #ifdef PNG_READ_hIST_SUPPORTED 1220 else if (!png_memcmp(chunk_name, png_hIST, 4)) 1221 png_handle_hIST(png_ptr, info_ptr, length); 1222 #endif 1223 #ifdef PNG_READ_oFFs_SUPPORTED 1224 else if (!png_memcmp(chunk_name, png_oFFs, 4)) 1225 png_handle_oFFs(png_ptr, info_ptr, length); 1226 #endif 1227 #ifdef PNG_READ_pCAL_SUPPORTED 1228 else if (!png_memcmp(chunk_name, png_pCAL, 4)) 1229 png_handle_pCAL(png_ptr, info_ptr, length); 1230 #endif 1231 #ifdef PNG_READ_sCAL_SUPPORTED 1232 else if (!png_memcmp(chunk_name, png_sCAL, 4)) 1233 png_handle_sCAL(png_ptr, info_ptr, length); 1234 #endif 1235 #ifdef PNG_READ_pHYs_SUPPORTED 1236 else if (!png_memcmp(chunk_name, png_pHYs, 4)) 1237 png_handle_pHYs(png_ptr, info_ptr, length); 1238 #endif 1239 #ifdef PNG_READ_sBIT_SUPPORTED 1240 else if (!png_memcmp(chunk_name, png_sBIT, 4)) 1241 png_handle_sBIT(png_ptr, info_ptr, length); 1242 #endif 1243 #ifdef PNG_READ_sRGB_SUPPORTED 1244 else if (!png_memcmp(chunk_name, png_sRGB, 4)) 1245 png_handle_sRGB(png_ptr, info_ptr, length); 1246 #endif 1247 #ifdef PNG_READ_iCCP_SUPPORTED 1248 else if (!png_memcmp(chunk_name, png_iCCP, 4)) 1249 png_handle_iCCP(png_ptr, info_ptr, length); 1250 #endif 1251 #ifdef PNG_READ_sPLT_SUPPORTED 1252 else if (!png_memcmp(chunk_name, png_sPLT, 4)) 1253 png_handle_sPLT(png_ptr, info_ptr, length); 1254 #endif 1255 #ifdef PNG_READ_tEXt_SUPPORTED 1256 else if (!png_memcmp(chunk_name, png_tEXt, 4)) 1257 png_handle_tEXt(png_ptr, info_ptr, length); 1258 #endif 1259 #ifdef PNG_READ_tIME_SUPPORTED 1260 else if (!png_memcmp(chunk_name, png_tIME, 4)) 1261 png_handle_tIME(png_ptr, info_ptr, length); 1262 #endif 1263 #ifdef PNG_READ_tRNS_SUPPORTED 1264 else if (!png_memcmp(chunk_name, png_tRNS, 4)) 1265 png_handle_tRNS(png_ptr, info_ptr, length); 1266 #endif 1267 #ifdef PNG_READ_zTXt_SUPPORTED 1268 else if (!png_memcmp(chunk_name, png_zTXt, 4)) 1269 png_handle_zTXt(png_ptr, info_ptr, length); 1270 #endif 1271 #ifdef PNG_READ_iTXt_SUPPORTED 1272 else if (!png_memcmp(chunk_name, png_iTXt, 4)) 1273 png_handle_iTXt(png_ptr, info_ptr, length); 1274 #endif 1275 else 1276 png_handle_unknown(png_ptr, info_ptr, length); 1277 } while (!(png_ptr->mode & PNG_HAVE_IEND)); 1278 } 1279 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 1280 1281 /* Free all memory used by the read */ 1282 void PNGAPI 1283 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, 1284 png_infopp end_info_ptr_ptr) 1285 { 1286 png_structp png_ptr = NULL; 1287 png_infop info_ptr = NULL, end_info_ptr = NULL; 1288 #ifdef PNG_USER_MEM_SUPPORTED 1289 png_free_ptr free_fn = NULL; 1290 png_voidp mem_ptr = NULL; 1291 #endif 1292 1293 png_debug(1, "in png_destroy_read_struct"); 1294 1295 if (png_ptr_ptr != NULL) 1296 png_ptr = *png_ptr_ptr; 1297 if (png_ptr == NULL) 1298 return; 1299 1300 #ifdef PNG_USER_MEM_SUPPORTED 1301 free_fn = png_ptr->free_fn; 1302 mem_ptr = png_ptr->mem_ptr; 1303 #endif 1304 1305 if (info_ptr_ptr != NULL) 1306 info_ptr = *info_ptr_ptr; 1307 1308 if (end_info_ptr_ptr != NULL) 1309 end_info_ptr = *end_info_ptr_ptr; 1310 1311 png_read_destroy(png_ptr, info_ptr, end_info_ptr); 1312 1313 if (info_ptr != NULL) 1314 { 1315 #ifdef PNG_TEXT_SUPPORTED 1316 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); 1317 #endif 1318 1319 #ifdef PNG_USER_MEM_SUPPORTED 1320 png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, 1321 (png_voidp)mem_ptr); 1322 #else 1323 png_destroy_struct((png_voidp)info_ptr); 1324 #endif 1325 *info_ptr_ptr = NULL; 1326 } 1327 1328 if (end_info_ptr != NULL) 1329 { 1330 #ifdef PNG_READ_TEXT_SUPPORTED 1331 png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); 1332 #endif 1333 #ifdef PNG_USER_MEM_SUPPORTED 1334 png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, 1335 (png_voidp)mem_ptr); 1336 #else 1337 png_destroy_struct((png_voidp)end_info_ptr); 1338 #endif 1339 *end_info_ptr_ptr = NULL; 1340 } 1341 1342 if (png_ptr != NULL) 1343 { 1344 #ifdef PNG_INDEX_SUPPORTED 1345 if (png_ptr->index) { 1346 unsigned int i, p; 1347 png_indexp index = png_ptr->index; 1348 for (p = 0; p < 7; p++) { 1349 for (i = 0; i < index->size[p]; i++) { 1350 inflateEnd(index->pass_line_index[p][i]->z_state); 1351 png_free(png_ptr, index->pass_line_index[p][i]->z_state); 1352 png_free(png_ptr, index->pass_line_index[p][i]->prev_row); 1353 png_free(png_ptr, index->pass_line_index[p][i]); 1354 } 1355 if (index->size[p] != 0) { 1356 png_free(png_ptr, index->pass_line_index[p]); 1357 } 1358 } 1359 png_free(png_ptr, index); 1360 } 1361 #endif 1362 #ifdef PNG_USER_MEM_SUPPORTED 1363 png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, 1364 (png_voidp)mem_ptr); 1365 #else 1366 png_destroy_struct((png_voidp)png_ptr); 1367 #endif 1368 *png_ptr_ptr = NULL; 1369 } 1370 } 1371 1372 /* Free all memory used by the read (old method) */ 1373 void /* PRIVATE */ 1374 png_read_destroy(png_structp png_ptr, png_infop info_ptr, 1375 png_infop end_info_ptr) 1376 { 1377 #ifdef PNG_SETJMP_SUPPORTED 1378 jmp_buf tmp_jmp; 1379 #endif 1380 png_error_ptr error_fn; 1381 png_error_ptr warning_fn; 1382 png_voidp error_ptr; 1383 #ifdef PNG_USER_MEM_SUPPORTED 1384 png_free_ptr free_fn; 1385 #endif 1386 1387 png_debug(1, "in png_read_destroy"); 1388 1389 if (info_ptr != NULL) 1390 png_info_destroy(png_ptr, info_ptr); 1391 1392 if (end_info_ptr != NULL) 1393 png_info_destroy(png_ptr, end_info_ptr); 1394 1395 png_free(png_ptr, png_ptr->zbuf); 1396 png_free(png_ptr, png_ptr->big_row_buf); 1397 png_free(png_ptr, png_ptr->prev_row); 1398 png_free(png_ptr, png_ptr->chunkdata); 1399 #ifdef PNG_READ_DITHER_SUPPORTED 1400 png_free(png_ptr, png_ptr->palette_lookup); 1401 png_free(png_ptr, png_ptr->dither_index); 1402 #endif 1403 #ifdef PNG_READ_GAMMA_SUPPORTED 1404 png_free(png_ptr, png_ptr->gamma_table); 1405 #endif 1406 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1407 png_free(png_ptr, png_ptr->gamma_from_1); 1408 png_free(png_ptr, png_ptr->gamma_to_1); 1409 #endif 1410 #ifdef PNG_FREE_ME_SUPPORTED 1411 if (png_ptr->free_me & PNG_FREE_PLTE) 1412 png_zfree(png_ptr, png_ptr->palette); 1413 png_ptr->free_me &= ~PNG_FREE_PLTE; 1414 #else 1415 if (png_ptr->flags & PNG_FLAG_FREE_PLTE) 1416 png_zfree(png_ptr, png_ptr->palette); 1417 png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; 1418 #endif 1419 #if defined(PNG_tRNS_SUPPORTED) || \ 1420 defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 1421 #ifdef PNG_FREE_ME_SUPPORTED 1422 if (png_ptr->free_me & PNG_FREE_TRNS) 1423 png_free(png_ptr, png_ptr->trans); 1424 png_ptr->free_me &= ~PNG_FREE_TRNS; 1425 #else 1426 if (png_ptr->flags & PNG_FLAG_FREE_TRNS) 1427 png_free(png_ptr, png_ptr->trans); 1428 png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; 1429 #endif 1430 #endif 1431 #ifdef PNG_READ_hIST_SUPPORTED 1432 #ifdef PNG_FREE_ME_SUPPORTED 1433 if (png_ptr->free_me & PNG_FREE_HIST) 1434 png_free(png_ptr, png_ptr->hist); 1435 png_ptr->free_me &= ~PNG_FREE_HIST; 1436 #else 1437 if (png_ptr->flags & PNG_FLAG_FREE_HIST) 1438 png_free(png_ptr, png_ptr->hist); 1439 png_ptr->flags &= ~PNG_FLAG_FREE_HIST; 1440 #endif 1441 #endif 1442 #ifdef PNG_READ_GAMMA_SUPPORTED 1443 if (png_ptr->gamma_16_table != NULL) 1444 { 1445 int i; 1446 int istop = (1 << (8 - png_ptr->gamma_shift)); 1447 for (i = 0; i < istop; i++) 1448 { 1449 png_free(png_ptr, png_ptr->gamma_16_table[i]); 1450 } 1451 png_free(png_ptr, png_ptr->gamma_16_table); 1452 } 1453 #ifdef PNG_READ_BACKGROUND_SUPPORTED 1454 if (png_ptr->gamma_16_from_1 != NULL) 1455 { 1456 int i; 1457 int istop = (1 << (8 - png_ptr->gamma_shift)); 1458 for (i = 0; i < istop; i++) 1459 { 1460 png_free(png_ptr, png_ptr->gamma_16_from_1[i]); 1461 } 1462 png_free(png_ptr, png_ptr->gamma_16_from_1); 1463 } 1464 if (png_ptr->gamma_16_to_1 != NULL) 1465 { 1466 int i; 1467 int istop = (1 << (8 - png_ptr->gamma_shift)); 1468 for (i = 0; i < istop; i++) 1469 { 1470 png_free(png_ptr, png_ptr->gamma_16_to_1[i]); 1471 } 1472 png_free(png_ptr, png_ptr->gamma_16_to_1); 1473 } 1474 #endif 1475 #endif 1476 #ifdef PNG_TIME_RFC1123_SUPPORTED 1477 png_free(png_ptr, png_ptr->time_buffer); 1478 #endif 1479 1480 inflateEnd(&png_ptr->zstream); 1481 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1482 png_free(png_ptr, png_ptr->save_buffer); 1483 #endif 1484 1485 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1486 #ifdef PNG_TEXT_SUPPORTED 1487 png_free(png_ptr, png_ptr->current_text); 1488 #endif /* PNG_TEXT_SUPPORTED */ 1489 #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ 1490 1491 /* Save the important info out of the png_struct, in case it is 1492 * being used again. 1493 */ 1494 #ifdef PNG_SETJMP_SUPPORTED 1495 png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); 1496 #endif 1497 1498 error_fn = png_ptr->error_fn; 1499 warning_fn = png_ptr->warning_fn; 1500 error_ptr = png_ptr->error_ptr; 1501 #ifdef PNG_USER_MEM_SUPPORTED 1502 free_fn = png_ptr->free_fn; 1503 #endif 1504 1505 png_memset(png_ptr, 0, png_sizeof(png_struct)); 1506 1507 png_ptr->error_fn = error_fn; 1508 png_ptr->warning_fn = warning_fn; 1509 png_ptr->error_ptr = error_ptr; 1510 #ifdef PNG_USER_MEM_SUPPORTED 1511 png_ptr->free_fn = free_fn; 1512 #endif 1513 1514 #ifdef PNG_SETJMP_SUPPORTED 1515 png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); 1516 #endif 1517 1518 } 1519 1520 void PNGAPI 1521 png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) 1522 { 1523 if (png_ptr == NULL) 1524 return; 1525 png_ptr->read_row_fn = read_row_fn; 1526 } 1527 1528 1529 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1530 #ifdef PNG_INFO_IMAGE_SUPPORTED 1531 void PNGAPI 1532 png_read_png(png_structp png_ptr, png_infop info_ptr, 1533 int transforms, 1534 voidp params) 1535 { 1536 int row; 1537 1538 if (png_ptr == NULL) 1539 return; 1540 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 1541 /* Invert the alpha channel from opacity to transparency 1542 */ 1543 if (transforms & PNG_TRANSFORM_INVERT_ALPHA) 1544 png_set_invert_alpha(png_ptr); 1545 #endif 1546 1547 /* png_read_info() gives us all of the information from the 1548 * PNG file before the first IDAT (image data chunk). 1549 */ 1550 png_read_info(png_ptr, info_ptr); 1551 if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) 1552 png_error(png_ptr, "Image is too high to process with png_read_png()"); 1553 1554 /* -------------- image transformations start here ------------------- */ 1555 1556 #ifdef PNG_READ_16_TO_8_SUPPORTED 1557 /* Tell libpng to strip 16 bit/color files down to 8 bits per color. 1558 */ 1559 if (transforms & PNG_TRANSFORM_STRIP_16) 1560 png_set_strip_16(png_ptr); 1561 #endif 1562 1563 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 1564 /* Strip alpha bytes from the input data without combining with 1565 * the background (not recommended). 1566 */ 1567 if (transforms & PNG_TRANSFORM_STRIP_ALPHA) 1568 png_set_strip_alpha(png_ptr); 1569 #endif 1570 1571 #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) 1572 /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single 1573 * byte into separate bytes (useful for paletted and grayscale images). 1574 */ 1575 if (transforms & PNG_TRANSFORM_PACKING) 1576 png_set_packing(png_ptr); 1577 #endif 1578 1579 #ifdef PNG_READ_PACKSWAP_SUPPORTED 1580 /* Change the order of packed pixels to least significant bit first 1581 * (not useful if you are using png_set_packing). 1582 */ 1583 if (transforms & PNG_TRANSFORM_PACKSWAP) 1584 png_set_packswap(png_ptr); 1585 #endif 1586 1587 #ifdef PNG_READ_EXPAND_SUPPORTED 1588 /* Expand paletted colors into true RGB triplets 1589 * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel 1590 * Expand paletted or RGB images with transparency to full alpha 1591 * channels so the data will be available as RGBA quartets. 1592 */ 1593 if (transforms & PNG_TRANSFORM_EXPAND) 1594 if ((png_ptr->bit_depth < 8) || 1595 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || 1596 (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) 1597 png_set_expand(png_ptr); 1598 #endif 1599 1600 /* We don't handle background color or gamma transformation or dithering. 1601 */ 1602 1603 #ifdef PNG_READ_INVERT_SUPPORTED 1604 /* Invert monochrome files to have 0 as white and 1 as black 1605 */ 1606 if (transforms & PNG_TRANSFORM_INVERT_MONO) 1607 png_set_invert_mono(png_ptr); 1608 #endif 1609 1610 #ifdef PNG_READ_SHIFT_SUPPORTED 1611 /* If you want to shift the pixel values from the range [0,255] or 1612 * [0,65535] to the original [0,7] or [0,31], or whatever range the 1613 * colors were originally in: 1614 */ 1615 if ((transforms & PNG_TRANSFORM_SHIFT) 1616 && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) 1617 { 1618 png_color_8p sig_bit; 1619 1620 png_get_sBIT(png_ptr, info_ptr, &sig_bit); 1621 png_set_shift(png_ptr, sig_bit); 1622 } 1623 #endif 1624 1625 #ifdef PNG_READ_BGR_SUPPORTED 1626 /* Flip the RGB pixels to BGR (or RGBA to BGRA) 1627 */ 1628 if (transforms & PNG_TRANSFORM_BGR) 1629 png_set_bgr(png_ptr); 1630 #endif 1631 1632 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED 1633 /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) 1634 */ 1635 if (transforms & PNG_TRANSFORM_SWAP_ALPHA) 1636 png_set_swap_alpha(png_ptr); 1637 #endif 1638 1639 #ifdef PNG_READ_SWAP_SUPPORTED 1640 /* Swap bytes of 16 bit files to least significant byte first 1641 */ 1642 if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) 1643 png_set_swap(png_ptr); 1644 #endif 1645 1646 /* Added at libpng-1.2.41 */ 1647 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 1648 /* Invert the alpha channel from opacity to transparency 1649 */ 1650 if (transforms & PNG_TRANSFORM_INVERT_ALPHA) 1651 png_set_invert_alpha(png_ptr); 1652 #endif 1653 1654 /* Added at libpng-1.2.41 */ 1655 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 1656 /* Expand grayscale image to RGB 1657 */ 1658 if (transforms & PNG_TRANSFORM_GRAY_TO_RGB) 1659 png_set_gray_to_rgb(png_ptr); 1660 #endif 1661 1662 /* We don't handle adding filler bytes */ 1663 1664 /* Optional call to gamma correct and add the background to the palette 1665 * and update info structure. REQUIRED if you are expecting libpng to 1666 * update the palette for you (i.e., you selected such a transform above). 1667 */ 1668 png_read_update_info(png_ptr, info_ptr); 1669 1670 /* -------------- image transformations end here ------------------- */ 1671 1672 #ifdef PNG_FREE_ME_SUPPORTED 1673 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); 1674 #endif 1675 if (info_ptr->row_pointers == NULL) 1676 { 1677 info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, 1678 info_ptr->height * png_sizeof(png_bytep)); 1679 png_memset(info_ptr->row_pointers, 0, info_ptr->height 1680 * png_sizeof(png_bytep)); 1681 1682 #ifdef PNG_FREE_ME_SUPPORTED 1683 info_ptr->free_me |= PNG_FREE_ROWS; 1684 #endif 1685 1686 for (row = 0; row < (int)info_ptr->height; row++) 1687 info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, 1688 png_get_rowbytes(png_ptr, info_ptr)); 1689 } 1690 1691 png_read_image(png_ptr, info_ptr->row_pointers); 1692 info_ptr->valid |= PNG_INFO_IDAT; 1693 1694 /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ 1695 png_read_end(png_ptr, info_ptr); 1696 1697 transforms = transforms; /* Quiet compiler warnings */ 1698 params = params; 1699 1700 } 1701 #endif /* PNG_INFO_IMAGE_SUPPORTED */ 1702 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ 1703 #endif /* PNG_READ_SUPPORTED */ 1704
