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