1 /* 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. Oracle designates this 7 * particular file as subject to the "Classpath" exception as provided 8 * by Oracle in the LICENSE file that accompanied this code. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 /* pngread.c - read a PNG file 26 * 27 * This file is available under and governed by the GNU General Public 28 * License version 2 only, as published by the Free Software Foundation. 29 * However, the following notice accompanied the original version of this 30 * file and, per its terms, should not be removed: 31 * 32 * Last changed in libpng 1.6.35 [July 15, 2018] 33 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson 34 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 35 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 36 * 37 * This code is released under the libpng license. 38 * For conditions of distribution and use, see the disclaimer 39 * and license in png.h 40 * 41 * This file contains routines that an application calls directly to 42 * read a PNG file or stream. 43 */ 44 45 #include "pngpriv.h" 46 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) 47 # include <errno.h> 48 #endif 49 50 #ifdef PNG_READ_SUPPORTED 51 52 /* Create a PNG structure for reading, and allocate any memory needed. */ 53 PNG_FUNCTION(png_structp,PNGAPI 54 png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr, 55 png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) 56 { 57 #ifndef PNG_USER_MEM_SUPPORTED 58 png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, 59 error_fn, warn_fn, NULL, NULL, NULL); 60 #else 61 return png_create_read_struct_2(user_png_ver, error_ptr, error_fn, 62 warn_fn, NULL, NULL, NULL); 63 } 64 65 /* Alternate create PNG structure for reading, and allocate any memory 66 * needed. 67 */ 68 PNG_FUNCTION(png_structp,PNGAPI 69 png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr, 70 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 71 png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) 72 { 73 png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, 74 error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); 75 #endif /* USER_MEM */ 76 77 if (png_ptr != NULL) 78 { 79 png_ptr->mode = PNG_IS_READ_STRUCT; 80 81 /* Added in libpng-1.6.0; this can be used to detect a read structure if 82 * required (it will be zero in a write structure.) 83 */ 84 # ifdef PNG_SEQUENTIAL_READ_SUPPORTED 85 png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE; 86 # endif 87 88 # ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED 89 png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; 90 91 /* In stable builds only warn if an application error can be completely 92 * handled. 93 */ 94 # if PNG_RELEASE_BUILD 95 png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN; 96 # endif 97 # endif 98 99 /* TODO: delay this, it can be done in png_init_io (if the app doesn't 100 * do it itself) avoiding setting the default function if it is not 101 * required. 102 */ 103 png_set_read_fn(png_ptr, NULL, NULL); 104 } 105 106 return png_ptr; 107 } 108 109 110 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 111 /* Read the information before the actual image data. This has been 112 * changed in v0.90 to allow reading a file that already has the magic 113 * bytes read from the stream. You can tell libpng how many bytes have 114 * been read from the beginning of the stream (up to the maximum of 8) 115 * via png_set_sig_bytes(), and we will only check the remaining bytes 116 * here. The application can then have access to the signature bytes we 117 * read if it is determined that this isn't a valid PNG file. 118 */ 119 void PNGAPI 120 png_read_info(png_structrp png_ptr, png_inforp info_ptr) 121 { 122 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 123 int keep; 124 #endif 125 126 png_debug(1, "in png_read_info"); 127 128 if (png_ptr == NULL || info_ptr == NULL) 129 return; 130 131 /* Read and check the PNG file signature. */ 132 png_read_sig(png_ptr, info_ptr); 133 134 for (;;) 135 { 136 png_uint_32 length = png_read_chunk_header(png_ptr); 137 png_uint_32 chunk_name = png_ptr->chunk_name; 138 139 /* IDAT logic needs to happen here to simplify getting the two flags 140 * right. 141 */ 142 if (chunk_name == png_IDAT) 143 { 144 if ((png_ptr->mode & PNG_HAVE_IHDR) == 0) 145 png_chunk_error(png_ptr, "Missing IHDR before IDAT"); 146 147 else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 148 (png_ptr->mode & PNG_HAVE_PLTE) == 0) 149 png_chunk_error(png_ptr, "Missing PLTE before IDAT"); 150 151 else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0) 152 png_chunk_benign_error(png_ptr, "Too many IDATs found"); 153 154 png_ptr->mode |= PNG_HAVE_IDAT; 155 } 156 157 else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0) 158 { 159 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; 160 png_ptr->mode |= PNG_AFTER_IDAT; 161 } 162 163 /* This should be a binary subdivision search or a hash for 164 * matching the chunk name rather than a linear search. 165 */ 166 if (chunk_name == png_IHDR) 167 png_handle_IHDR(png_ptr, info_ptr, length); 168 169 else if (chunk_name == png_IEND) 170 png_handle_IEND(png_ptr, info_ptr, length); 171 172 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 173 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0) 174 { 175 png_handle_unknown(png_ptr, info_ptr, length, keep); 176 177 if (chunk_name == png_PLTE) 178 png_ptr->mode |= PNG_HAVE_PLTE; 179 180 else if (chunk_name == png_IDAT) 181 { 182 png_ptr->idat_size = 0; /* It has been consumed */ 183 break; 184 } 185 } 186 #endif 187 else if (chunk_name == png_PLTE) 188 png_handle_PLTE(png_ptr, info_ptr, length); 189 190 else if (chunk_name == png_IDAT) 191 { 192 png_ptr->idat_size = length; 193 break; 194 } 195 196 #ifdef PNG_READ_bKGD_SUPPORTED 197 else if (chunk_name == png_bKGD) 198 png_handle_bKGD(png_ptr, info_ptr, length); 199 #endif 200 201 #ifdef PNG_READ_cHRM_SUPPORTED 202 else if (chunk_name == png_cHRM) 203 png_handle_cHRM(png_ptr, info_ptr, length); 204 #endif 205 206 #ifdef PNG_READ_eXIf_SUPPORTED 207 else if (chunk_name == png_eXIf) 208 png_handle_eXIf(png_ptr, info_ptr, length); 209 #endif 210 211 #ifdef PNG_READ_gAMA_SUPPORTED 212 else if (chunk_name == png_gAMA) 213 png_handle_gAMA(png_ptr, info_ptr, length); 214 #endif 215 216 #ifdef PNG_READ_hIST_SUPPORTED 217 else if (chunk_name == png_hIST) 218 png_handle_hIST(png_ptr, info_ptr, length); 219 #endif 220 221 #ifdef PNG_READ_oFFs_SUPPORTED 222 else if (chunk_name == png_oFFs) 223 png_handle_oFFs(png_ptr, info_ptr, length); 224 #endif 225 226 #ifdef PNG_READ_pCAL_SUPPORTED 227 else if (chunk_name == png_pCAL) 228 png_handle_pCAL(png_ptr, info_ptr, length); 229 #endif 230 231 #ifdef PNG_READ_sCAL_SUPPORTED 232 else if (chunk_name == png_sCAL) 233 png_handle_sCAL(png_ptr, info_ptr, length); 234 #endif 235 236 #ifdef PNG_READ_pHYs_SUPPORTED 237 else if (chunk_name == png_pHYs) 238 png_handle_pHYs(png_ptr, info_ptr, length); 239 #endif 240 241 #ifdef PNG_READ_sBIT_SUPPORTED 242 else if (chunk_name == png_sBIT) 243 png_handle_sBIT(png_ptr, info_ptr, length); 244 #endif 245 246 #ifdef PNG_READ_sRGB_SUPPORTED 247 else if (chunk_name == png_sRGB) 248 png_handle_sRGB(png_ptr, info_ptr, length); 249 #endif 250 251 #ifdef PNG_READ_iCCP_SUPPORTED 252 else if (chunk_name == png_iCCP) 253 png_handle_iCCP(png_ptr, info_ptr, length); 254 #endif 255 256 #ifdef PNG_READ_sPLT_SUPPORTED 257 else if (chunk_name == png_sPLT) 258 png_handle_sPLT(png_ptr, info_ptr, length); 259 #endif 260 261 #ifdef PNG_READ_tEXt_SUPPORTED 262 else if (chunk_name == png_tEXt) 263 png_handle_tEXt(png_ptr, info_ptr, length); 264 #endif 265 266 #ifdef PNG_READ_tIME_SUPPORTED 267 else if (chunk_name == png_tIME) 268 png_handle_tIME(png_ptr, info_ptr, length); 269 #endif 270 271 #ifdef PNG_READ_tRNS_SUPPORTED 272 else if (chunk_name == png_tRNS) 273 png_handle_tRNS(png_ptr, info_ptr, length); 274 #endif 275 276 #ifdef PNG_READ_zTXt_SUPPORTED 277 else if (chunk_name == png_zTXt) 278 png_handle_zTXt(png_ptr, info_ptr, length); 279 #endif 280 281 #ifdef PNG_READ_iTXt_SUPPORTED 282 else if (chunk_name == png_iTXt) 283 png_handle_iTXt(png_ptr, info_ptr, length); 284 #endif 285 286 else 287 png_handle_unknown(png_ptr, info_ptr, length, 288 PNG_HANDLE_CHUNK_AS_DEFAULT); 289 } 290 } 291 #endif /* SEQUENTIAL_READ */ 292 293 /* Optional call to update the users info_ptr structure */ 294 void PNGAPI 295 png_read_update_info(png_structrp png_ptr, png_inforp info_ptr) 296 { 297 png_debug(1, "in png_read_update_info"); 298 299 if (png_ptr != NULL) 300 { 301 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) 302 { 303 png_read_start_row(png_ptr); 304 305 # ifdef PNG_READ_TRANSFORMS_SUPPORTED 306 png_read_transform_info(png_ptr, info_ptr); 307 # else 308 PNG_UNUSED(info_ptr) 309 # endif 310 } 311 312 /* New in 1.6.0 this avoids the bug of doing the initializations twice */ 313 else 314 png_app_error(png_ptr, 315 "png_read_update_info/png_start_read_image: duplicate call"); 316 } 317 } 318 319 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 320 /* Initialize palette, background, etc, after transformations 321 * are set, but before any reading takes place. This allows 322 * the user to obtain a gamma-corrected palette, for example. 323 * If the user doesn't call this, we will do it ourselves. 324 */ 325 void PNGAPI 326 png_start_read_image(png_structrp png_ptr) 327 { 328 png_debug(1, "in png_start_read_image"); 329 330 if (png_ptr != NULL) 331 { 332 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) 333 png_read_start_row(png_ptr); 334 335 /* New in 1.6.0 this avoids the bug of doing the initializations twice */ 336 else 337 png_app_error(png_ptr, 338 "png_start_read_image/png_read_update_info: duplicate call"); 339 } 340 } 341 #endif /* SEQUENTIAL_READ */ 342 343 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 344 #ifdef PNG_MNG_FEATURES_SUPPORTED 345 /* Undoes intrapixel differencing, 346 * NOTE: this is apparently only supported in the 'sequential' reader. 347 */ 348 static void 349 png_do_read_intrapixel(png_row_infop row_info, png_bytep row) 350 { 351 png_debug(1, "in png_do_read_intrapixel"); 352 353 if ( 354 (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0) 355 { 356 int bytes_per_pixel; 357 png_uint_32 row_width = row_info->width; 358 359 if (row_info->bit_depth == 8) 360 { 361 png_bytep rp; 362 png_uint_32 i; 363 364 if (row_info->color_type == PNG_COLOR_TYPE_RGB) 365 bytes_per_pixel = 3; 366 367 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 368 bytes_per_pixel = 4; 369 370 else 371 return; 372 373 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) 374 { 375 *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff); 376 *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff); 377 } 378 } 379 else if (row_info->bit_depth == 16) 380 { 381 png_bytep rp; 382 png_uint_32 i; 383 384 if (row_info->color_type == PNG_COLOR_TYPE_RGB) 385 bytes_per_pixel = 6; 386 387 else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) 388 bytes_per_pixel = 8; 389 390 else 391 return; 392 393 for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) 394 { 395 png_uint_32 s0 = (png_uint_32)(*(rp ) << 8) | *(rp + 1); 396 png_uint_32 s1 = (png_uint_32)(*(rp + 2) << 8) | *(rp + 3); 397 png_uint_32 s2 = (png_uint_32)(*(rp + 4) << 8) | *(rp + 5); 398 png_uint_32 red = (s0 + s1 + 65536) & 0xffff; 399 png_uint_32 blue = (s2 + s1 + 65536) & 0xffff; 400 *(rp ) = (png_byte)((red >> 8) & 0xff); 401 *(rp + 1) = (png_byte)(red & 0xff); 402 *(rp + 4) = (png_byte)((blue >> 8) & 0xff); 403 *(rp + 5) = (png_byte)(blue & 0xff); 404 } 405 } 406 } 407 } 408 #endif /* MNG_FEATURES */ 409 410 void PNGAPI 411 png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row) 412 { 413 png_row_info row_info; 414 415 if (png_ptr == NULL) 416 return; 417 418 png_debug2(1, "in png_read_row (row %lu, pass %d)", 419 (unsigned long)png_ptr->row_number, png_ptr->pass); 420 421 /* png_read_start_row sets the information (in particular iwidth) for this 422 * interlace pass. 423 */ 424 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) 425 png_read_start_row(png_ptr); 426 427 /* 1.5.6: row_info moved out of png_struct to a local here. */ 428 row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */ 429 row_info.color_type = png_ptr->color_type; 430 row_info.bit_depth = png_ptr->bit_depth; 431 row_info.channels = png_ptr->channels; 432 row_info.pixel_depth = png_ptr->pixel_depth; 433 row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); 434 435 #ifdef PNG_WARNINGS_SUPPORTED 436 if (png_ptr->row_number == 0 && png_ptr->pass == 0) 437 { 438 /* Check for transforms that have been set but were defined out */ 439 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) 440 if ((png_ptr->transformations & PNG_INVERT_MONO) != 0) 441 png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined"); 442 #endif 443 444 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) 445 if ((png_ptr->transformations & PNG_FILLER) != 0) 446 png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined"); 447 #endif 448 449 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ 450 !defined(PNG_READ_PACKSWAP_SUPPORTED) 451 if ((png_ptr->transformations & PNG_PACKSWAP) != 0) 452 png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined"); 453 #endif 454 455 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) 456 if ((png_ptr->transformations & PNG_PACK) != 0) 457 png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined"); 458 #endif 459 460 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) 461 if ((png_ptr->transformations & PNG_SHIFT) != 0) 462 png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined"); 463 #endif 464 465 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) 466 if ((png_ptr->transformations & PNG_BGR) != 0) 467 png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined"); 468 #endif 469 470 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) 471 if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0) 472 png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined"); 473 #endif 474 } 475 #endif /* WARNINGS */ 476 477 #ifdef PNG_READ_INTERLACING_SUPPORTED 478 /* If interlaced and we do not need a new row, combine row and return. 479 * Notice that the pixels we have from previous rows have been transformed 480 * already; we can only combine like with like (transformed or 481 * untransformed) and, because of the libpng API for interlaced images, this 482 * means we must transform before de-interlacing. 483 */ 484 if (png_ptr->interlaced != 0 && 485 (png_ptr->transformations & PNG_INTERLACE) != 0) 486 { 487 switch (png_ptr->pass) 488 { 489 case 0: 490 if (png_ptr->row_number & 0x07) 491 { 492 if (dsp_row != NULL) 493 png_combine_row(png_ptr, dsp_row, 1/*display*/); 494 png_read_finish_row(png_ptr); 495 return; 496 } 497 break; 498 499 case 1: 500 if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) 501 { 502 if (dsp_row != NULL) 503 png_combine_row(png_ptr, dsp_row, 1/*display*/); 504 505 png_read_finish_row(png_ptr); 506 return; 507 } 508 break; 509 510 case 2: 511 if ((png_ptr->row_number & 0x07) != 4) 512 { 513 if (dsp_row != NULL && (png_ptr->row_number & 4)) 514 png_combine_row(png_ptr, dsp_row, 1/*display*/); 515 516 png_read_finish_row(png_ptr); 517 return; 518 } 519 break; 520 521 case 3: 522 if ((png_ptr->row_number & 3) || png_ptr->width < 3) 523 { 524 if (dsp_row != NULL) 525 png_combine_row(png_ptr, dsp_row, 1/*display*/); 526 527 png_read_finish_row(png_ptr); 528 return; 529 } 530 break; 531 532 case 4: 533 if ((png_ptr->row_number & 3) != 2) 534 { 535 if (dsp_row != NULL && (png_ptr->row_number & 2)) 536 png_combine_row(png_ptr, dsp_row, 1/*display*/); 537 538 png_read_finish_row(png_ptr); 539 return; 540 } 541 break; 542 543 case 5: 544 if ((png_ptr->row_number & 1) || png_ptr->width < 2) 545 { 546 if (dsp_row != NULL) 547 png_combine_row(png_ptr, dsp_row, 1/*display*/); 548 549 png_read_finish_row(png_ptr); 550 return; 551 } 552 break; 553 554 default: 555 case 6: 556 if ((png_ptr->row_number & 1) == 0) 557 { 558 png_read_finish_row(png_ptr); 559 return; 560 } 561 break; 562 } 563 } 564 #endif 565 566 if ((png_ptr->mode & PNG_HAVE_IDAT) == 0) 567 png_error(png_ptr, "Invalid attempt to read row data"); 568 569 /* Fill the row with IDAT data: */ 570 png_ptr->row_buf[0]=255; /* to force error if no data was found */ 571 png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1); 572 573 if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE) 574 { 575 if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) 576 png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, 577 png_ptr->prev_row + 1, png_ptr->row_buf[0]); 578 else 579 png_error(png_ptr, "bad adaptive filter value"); 580 } 581 582 /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before 583 * 1.5.6, while the buffer really is this big in current versions of libpng 584 * it may not be in the future, so this was changed just to copy the 585 * interlaced count: 586 */ 587 memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); 588 589 #ifdef PNG_MNG_FEATURES_SUPPORTED 590 if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 && 591 (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) 592 { 593 /* Intrapixel differencing */ 594 png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1); 595 } 596 #endif 597 598 #ifdef PNG_READ_TRANSFORMS_SUPPORTED 599 if (png_ptr->transformations) 600 png_do_read_transformations(png_ptr, &row_info); 601 #endif 602 603 /* The transformed pixel depth should match the depth now in row_info. */ 604 if (png_ptr->transformed_pixel_depth == 0) 605 { 606 png_ptr->transformed_pixel_depth = row_info.pixel_depth; 607 if (row_info.pixel_depth > png_ptr->maximum_pixel_depth) 608 png_error(png_ptr, "sequential row overflow"); 609 } 610 611 else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) 612 png_error(png_ptr, "internal sequential row size calculation error"); 613 614 #ifdef PNG_READ_INTERLACING_SUPPORTED 615 /* Expand interlaced rows to full size */ 616 if (png_ptr->interlaced != 0 && 617 (png_ptr->transformations & PNG_INTERLACE) != 0) 618 { 619 if (png_ptr->pass < 6) 620 png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, 621 png_ptr->transformations); 622 623 if (dsp_row != NULL) 624 png_combine_row(png_ptr, dsp_row, 1/*display*/); 625 626 if (row != NULL) 627 png_combine_row(png_ptr, row, 0/*row*/); 628 } 629 630 else 631 #endif 632 { 633 if (row != NULL) 634 png_combine_row(png_ptr, row, -1/*ignored*/); 635 636 if (dsp_row != NULL) 637 png_combine_row(png_ptr, dsp_row, -1/*ignored*/); 638 } 639 png_read_finish_row(png_ptr); 640 641 if (png_ptr->read_row_fn != NULL) 642 (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); 643 644 } 645 #endif /* SEQUENTIAL_READ */ 646 647 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 648 /* Read one or more rows of image data. If the image is interlaced, 649 * and png_set_interlace_handling() has been called, the rows need to 650 * contain the contents of the rows from the previous pass. If the 651 * image has alpha or transparency, and png_handle_alpha()[*] has been 652 * called, the rows contents must be initialized to the contents of the 653 * screen. 654 * 655 * "row" holds the actual image, and pixels are placed in it 656 * as they arrive. If the image is displayed after each pass, it will 657 * appear to "sparkle" in. "display_row" can be used to display a 658 * "chunky" progressive image, with finer detail added as it becomes 659 * available. If you do not want this "chunky" display, you may pass 660 * NULL for display_row. If you do not want the sparkle display, and 661 * you have not called png_handle_alpha(), you may pass NULL for rows. 662 * If you have called png_handle_alpha(), and the image has either an 663 * alpha channel or a transparency chunk, you must provide a buffer for 664 * rows. In this case, you do not have to provide a display_row buffer 665 * also, but you may. If the image is not interlaced, or if you have 666 * not called png_set_interlace_handling(), the display_row buffer will 667 * be ignored, so pass NULL to it. 668 * 669 * [*] png_handle_alpha() does not exist yet, as of this version of libpng 670 */ 671 672 void PNGAPI 673 png_read_rows(png_structrp png_ptr, png_bytepp row, 674 png_bytepp display_row, png_uint_32 num_rows) 675 { 676 png_uint_32 i; 677 png_bytepp rp; 678 png_bytepp dp; 679 680 png_debug(1, "in png_read_rows"); 681 682 if (png_ptr == NULL) 683 return; 684 685 rp = row; 686 dp = display_row; 687 if (rp != NULL && dp != NULL) 688 for (i = 0; i < num_rows; i++) 689 { 690 png_bytep rptr = *rp++; 691 png_bytep dptr = *dp++; 692 693 png_read_row(png_ptr, rptr, dptr); 694 } 695 696 else if (rp != NULL) 697 for (i = 0; i < num_rows; i++) 698 { 699 png_bytep rptr = *rp; 700 png_read_row(png_ptr, rptr, NULL); 701 rp++; 702 } 703 704 else if (dp != NULL) 705 for (i = 0; i < num_rows; i++) 706 { 707 png_bytep dptr = *dp; 708 png_read_row(png_ptr, NULL, dptr); 709 dp++; 710 } 711 } 712 #endif /* SEQUENTIAL_READ */ 713 714 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 715 /* Read the entire image. If the image has an alpha channel or a tRNS 716 * chunk, and you have called png_handle_alpha()[*], you will need to 717 * initialize the image to the current image that PNG will be overlaying. 718 * We set the num_rows again here, in case it was incorrectly set in 719 * png_read_start_row() by a call to png_read_update_info() or 720 * png_start_read_image() if png_set_interlace_handling() wasn't called 721 * prior to either of these functions like it should have been. You can 722 * only call this function once. If you desire to have an image for 723 * each pass of a interlaced image, use png_read_rows() instead. 724 * 725 * [*] png_handle_alpha() does not exist yet, as of this version of libpng 726 */ 727 void PNGAPI 728 png_read_image(png_structrp png_ptr, png_bytepp image) 729 { 730 png_uint_32 i, image_height; 731 int pass, j; 732 png_bytepp rp; 733 734 png_debug(1, "in png_read_image"); 735 736 if (png_ptr == NULL) 737 return; 738 739 #ifdef PNG_READ_INTERLACING_SUPPORTED 740 if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) 741 { 742 pass = png_set_interlace_handling(png_ptr); 743 /* And make sure transforms are initialized. */ 744 png_start_read_image(png_ptr); 745 } 746 else 747 { 748 if (png_ptr->interlaced != 0 && 749 (png_ptr->transformations & PNG_INTERLACE) == 0) 750 { 751 /* Caller called png_start_read_image or png_read_update_info without 752 * first turning on the PNG_INTERLACE transform. We can fix this here, 753 * but the caller should do it! 754 */ 755 png_warning(png_ptr, "Interlace handling should be turned on when " 756 "using png_read_image"); 757 /* Make sure this is set correctly */ 758 png_ptr->num_rows = png_ptr->height; 759 } 760 761 /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in 762 * the above error case. 763 */ 764 pass = png_set_interlace_handling(png_ptr); 765 } 766 #else 767 if (png_ptr->interlaced) 768 png_error(png_ptr, 769 "Cannot read interlaced image -- interlace handler disabled"); 770 771 pass = 1; 772 #endif 773 774 image_height=png_ptr->height; 775 776 for (j = 0; j < pass; j++) 777 { 778 rp = image; 779 for (i = 0; i < image_height; i++) 780 { 781 png_read_row(png_ptr, *rp, NULL); 782 rp++; 783 } 784 } 785 } 786 #endif /* SEQUENTIAL_READ */ 787 788 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 789 /* Read the end of the PNG file. Will not read past the end of the 790 * file, will verify the end is accurate, and will read any comments 791 * or time information at the end of the file, if info is not NULL. 792 */ 793 void PNGAPI 794 png_read_end(png_structrp png_ptr, png_inforp info_ptr) 795 { 796 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 797 int keep; 798 #endif 799 800 png_debug(1, "in png_read_end"); 801 802 if (png_ptr == NULL) 803 return; 804 805 /* If png_read_end is called in the middle of reading the rows there may 806 * still be pending IDAT data and an owned zstream. Deal with this here. 807 */ 808 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 809 if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0) 810 #endif 811 png_read_finish_IDAT(png_ptr); 812 813 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED 814 /* Report invalid palette index; added at libng-1.5.10 */ 815 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && 816 png_ptr->num_palette_max > png_ptr->num_palette) 817 png_benign_error(png_ptr, "Read palette index exceeding num_palette"); 818 #endif 819 820 do 821 { 822 png_uint_32 length = png_read_chunk_header(png_ptr); 823 png_uint_32 chunk_name = png_ptr->chunk_name; 824 825 if (chunk_name != png_IDAT) 826 png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; 827 828 if (chunk_name == png_IEND) 829 png_handle_IEND(png_ptr, info_ptr, length); 830 831 else if (chunk_name == png_IHDR) 832 png_handle_IHDR(png_ptr, info_ptr, length); 833 834 else if (info_ptr == NULL) 835 png_crc_finish(png_ptr, length); 836 837 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 838 else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0) 839 { 840 if (chunk_name == png_IDAT) 841 { 842 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) 843 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0) 844 png_benign_error(png_ptr, ".Too many IDATs found"); 845 } 846 png_handle_unknown(png_ptr, info_ptr, length, keep); 847 if (chunk_name == png_PLTE) 848 png_ptr->mode |= PNG_HAVE_PLTE; 849 } 850 #endif 851 852 else if (chunk_name == png_IDAT) 853 { 854 /* Zero length IDATs are legal after the last IDAT has been 855 * read, but not after other chunks have been read. 1.6 does not 856 * always read all the deflate data; specifically it cannot be relied 857 * upon to read the Adler32 at the end. If it doesn't ignore IDAT 858 * chunks which are longer than zero as well: 859 */ 860 if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) 861 || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0) 862 png_benign_error(png_ptr, "..Too many IDATs found"); 863 864 png_crc_finish(png_ptr, length); 865 } 866 else if (chunk_name == png_PLTE) 867 png_handle_PLTE(png_ptr, info_ptr, length); 868 869 #ifdef PNG_READ_bKGD_SUPPORTED 870 else if (chunk_name == png_bKGD) 871 png_handle_bKGD(png_ptr, info_ptr, length); 872 #endif 873 874 #ifdef PNG_READ_cHRM_SUPPORTED 875 else if (chunk_name == png_cHRM) 876 png_handle_cHRM(png_ptr, info_ptr, length); 877 #endif 878 879 #ifdef PNG_READ_eXIf_SUPPORTED 880 else if (chunk_name == png_eXIf) 881 png_handle_eXIf(png_ptr, info_ptr, length); 882 #endif 883 884 #ifdef PNG_READ_gAMA_SUPPORTED 885 else if (chunk_name == png_gAMA) 886 png_handle_gAMA(png_ptr, info_ptr, length); 887 #endif 888 889 #ifdef PNG_READ_hIST_SUPPORTED 890 else if (chunk_name == png_hIST) 891 png_handle_hIST(png_ptr, info_ptr, length); 892 #endif 893 894 #ifdef PNG_READ_oFFs_SUPPORTED 895 else if (chunk_name == png_oFFs) 896 png_handle_oFFs(png_ptr, info_ptr, length); 897 #endif 898 899 #ifdef PNG_READ_pCAL_SUPPORTED 900 else if (chunk_name == png_pCAL) 901 png_handle_pCAL(png_ptr, info_ptr, length); 902 #endif 903 904 #ifdef PNG_READ_sCAL_SUPPORTED 905 else if (chunk_name == png_sCAL) 906 png_handle_sCAL(png_ptr, info_ptr, length); 907 #endif 908 909 #ifdef PNG_READ_pHYs_SUPPORTED 910 else if (chunk_name == png_pHYs) 911 png_handle_pHYs(png_ptr, info_ptr, length); 912 #endif 913 914 #ifdef PNG_READ_sBIT_SUPPORTED 915 else if (chunk_name == png_sBIT) 916 png_handle_sBIT(png_ptr, info_ptr, length); 917 #endif 918 919 #ifdef PNG_READ_sRGB_SUPPORTED 920 else if (chunk_name == png_sRGB) 921 png_handle_sRGB(png_ptr, info_ptr, length); 922 #endif 923 924 #ifdef PNG_READ_iCCP_SUPPORTED 925 else if (chunk_name == png_iCCP) 926 png_handle_iCCP(png_ptr, info_ptr, length); 927 #endif 928 929 #ifdef PNG_READ_sPLT_SUPPORTED 930 else if (chunk_name == png_sPLT) 931 png_handle_sPLT(png_ptr, info_ptr, length); 932 #endif 933 934 #ifdef PNG_READ_tEXt_SUPPORTED 935 else if (chunk_name == png_tEXt) 936 png_handle_tEXt(png_ptr, info_ptr, length); 937 #endif 938 939 #ifdef PNG_READ_tIME_SUPPORTED 940 else if (chunk_name == png_tIME) 941 png_handle_tIME(png_ptr, info_ptr, length); 942 #endif 943 944 #ifdef PNG_READ_tRNS_SUPPORTED 945 else if (chunk_name == png_tRNS) 946 png_handle_tRNS(png_ptr, info_ptr, length); 947 #endif 948 949 #ifdef PNG_READ_zTXt_SUPPORTED 950 else if (chunk_name == png_zTXt) 951 png_handle_zTXt(png_ptr, info_ptr, length); 952 #endif 953 954 #ifdef PNG_READ_iTXt_SUPPORTED 955 else if (chunk_name == png_iTXt) 956 png_handle_iTXt(png_ptr, info_ptr, length); 957 #endif 958 959 else 960 png_handle_unknown(png_ptr, info_ptr, length, 961 PNG_HANDLE_CHUNK_AS_DEFAULT); 962 } while ((png_ptr->mode & PNG_HAVE_IEND) == 0); 963 } 964 #endif /* SEQUENTIAL_READ */ 965 966 /* Free all memory used in the read struct */ 967 static void 968 png_read_destroy(png_structrp png_ptr) 969 { 970 png_debug(1, "in png_read_destroy"); 971 972 #ifdef PNG_READ_GAMMA_SUPPORTED 973 png_destroy_gamma_table(png_ptr); 974 #endif 975 976 png_free(png_ptr, png_ptr->big_row_buf); 977 png_ptr->big_row_buf = NULL; 978 png_free(png_ptr, png_ptr->big_prev_row); 979 png_ptr->big_prev_row = NULL; 980 png_free(png_ptr, png_ptr->read_buffer); 981 png_ptr->read_buffer = NULL; 982 983 #ifdef PNG_READ_QUANTIZE_SUPPORTED 984 png_free(png_ptr, png_ptr->palette_lookup); 985 png_ptr->palette_lookup = NULL; 986 png_free(png_ptr, png_ptr->quantize_index); 987 png_ptr->quantize_index = NULL; 988 #endif 989 990 if ((png_ptr->free_me & PNG_FREE_PLTE) != 0) 991 { 992 png_zfree(png_ptr, png_ptr->palette); 993 png_ptr->palette = NULL; 994 } 995 png_ptr->free_me &= ~PNG_FREE_PLTE; 996 997 #if defined(PNG_tRNS_SUPPORTED) || \ 998 defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) 999 if ((png_ptr->free_me & PNG_FREE_TRNS) != 0) 1000 { 1001 png_free(png_ptr, png_ptr->trans_alpha); 1002 png_ptr->trans_alpha = NULL; 1003 } 1004 png_ptr->free_me &= ~PNG_FREE_TRNS; 1005 #endif 1006 1007 inflateEnd(&png_ptr->zstream); 1008 1009 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED 1010 png_free(png_ptr, png_ptr->save_buffer); 1011 png_ptr->save_buffer = NULL; 1012 #endif 1013 1014 #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) && \ 1015 defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) 1016 png_free(png_ptr, png_ptr->unknown_chunk.data); 1017 png_ptr->unknown_chunk.data = NULL; 1018 #endif 1019 1020 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED 1021 png_free(png_ptr, png_ptr->chunk_list); 1022 png_ptr->chunk_list = NULL; 1023 #endif 1024 1025 /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error 1026 * callbacks are still set at this point. They are required to complete the 1027 * destruction of the png_struct itself. 1028 */ 1029 } 1030 1031 /* Free all memory used by the read */ 1032 void PNGAPI 1033 png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, 1034 png_infopp end_info_ptr_ptr) 1035 { 1036 png_structrp png_ptr = NULL; 1037 1038 png_debug(1, "in png_destroy_read_struct"); 1039 1040 if (png_ptr_ptr != NULL) 1041 png_ptr = *png_ptr_ptr; 1042 1043 if (png_ptr == NULL) 1044 return; 1045 1046 /* libpng 1.6.0: use the API to destroy info structs to ensure consistent 1047 * behavior. Prior to 1.6.0 libpng did extra 'info' destruction in this API. 1048 * The extra was, apparently, unnecessary yet this hides memory leak bugs. 1049 */ 1050 png_destroy_info_struct(png_ptr, end_info_ptr_ptr); 1051 png_destroy_info_struct(png_ptr, info_ptr_ptr); 1052 1053 *png_ptr_ptr = NULL; 1054 png_read_destroy(png_ptr); 1055 png_destroy_png_struct(png_ptr); 1056 } 1057 1058 void PNGAPI 1059 png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn) 1060 { 1061 if (png_ptr == NULL) 1062 return; 1063 1064 png_ptr->read_row_fn = read_row_fn; 1065 } 1066 1067 1068 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1069 #ifdef PNG_INFO_IMAGE_SUPPORTED 1070 void PNGAPI 1071 png_read_png(png_structrp png_ptr, png_inforp info_ptr, 1072 int transforms, voidp params) 1073 { 1074 if (png_ptr == NULL || info_ptr == NULL) 1075 return; 1076 1077 /* png_read_info() gives us all of the information from the 1078 * PNG file before the first IDAT (image data chunk). 1079 */ 1080 png_read_info(png_ptr, info_ptr); 1081 if (info_ptr->height > PNG_UINT_32_MAX/(sizeof (png_bytep))) 1082 png_error(png_ptr, "Image is too high to process with png_read_png()"); 1083 1084 /* -------------- image transformations start here ------------------- */ 1085 /* libpng 1.6.10: add code to cause a png_app_error if a selected TRANSFORM 1086 * is not implemented. This will only happen in de-configured (non-default) 1087 * libpng builds. The results can be unexpected - png_read_png may return 1088 * short or mal-formed rows because the transform is skipped. 1089 */ 1090 1091 /* Tell libpng to strip 16-bit/color files down to 8 bits per color. 1092 */ 1093 if ((transforms & PNG_TRANSFORM_SCALE_16) != 0) 1094 /* Added at libpng-1.5.4. "strip_16" produces the same result that it 1095 * did in earlier versions, while "scale_16" is now more accurate. 1096 */ 1097 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED 1098 png_set_scale_16(png_ptr); 1099 #else 1100 png_app_error(png_ptr, "PNG_TRANSFORM_SCALE_16 not supported"); 1101 #endif 1102 1103 /* If both SCALE and STRIP are required pngrtran will effectively cancel the 1104 * latter by doing SCALE first. This is ok and allows apps not to check for 1105 * which is supported to get the right answer. 1106 */ 1107 if ((transforms & PNG_TRANSFORM_STRIP_16) != 0) 1108 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED 1109 png_set_strip_16(png_ptr); 1110 #else 1111 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_16 not supported"); 1112 #endif 1113 1114 /* Strip alpha bytes from the input data without combining with 1115 * the background (not recommended). 1116 */ 1117 if ((transforms & PNG_TRANSFORM_STRIP_ALPHA) != 0) 1118 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED 1119 png_set_strip_alpha(png_ptr); 1120 #else 1121 png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_ALPHA not supported"); 1122 #endif 1123 1124 /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single 1125 * byte into separate bytes (useful for paletted and grayscale images). 1126 */ 1127 if ((transforms & PNG_TRANSFORM_PACKING) != 0) 1128 #ifdef PNG_READ_PACK_SUPPORTED 1129 png_set_packing(png_ptr); 1130 #else 1131 png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported"); 1132 #endif 1133 1134 /* Change the order of packed pixels to least significant bit first 1135 * (not useful if you are using png_set_packing). 1136 */ 1137 if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0) 1138 #ifdef PNG_READ_PACKSWAP_SUPPORTED 1139 png_set_packswap(png_ptr); 1140 #else 1141 png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported"); 1142 #endif 1143 1144 /* Expand paletted colors into true RGB triplets 1145 * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel 1146 * Expand paletted or RGB images with transparency to full alpha 1147 * channels so the data will be available as RGBA quartets. 1148 */ 1149 if ((transforms & PNG_TRANSFORM_EXPAND) != 0) 1150 #ifdef PNG_READ_EXPAND_SUPPORTED 1151 png_set_expand(png_ptr); 1152 #else 1153 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND not supported"); 1154 #endif 1155 1156 /* We don't handle background color or gamma transformation or quantizing. 1157 */ 1158 1159 /* Invert monochrome files to have 0 as white and 1 as black 1160 */ 1161 if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0) 1162 #ifdef PNG_READ_INVERT_SUPPORTED 1163 png_set_invert_mono(png_ptr); 1164 #else 1165 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_MONO not supported"); 1166 #endif 1167 1168 /* If you want to shift the pixel values from the range [0,255] or 1169 * [0,65535] to the original [0,7] or [0,31], or whatever range the 1170 * colors were originally in: 1171 */ 1172 if ((transforms & PNG_TRANSFORM_SHIFT) != 0) 1173 #ifdef PNG_READ_SHIFT_SUPPORTED 1174 if ((info_ptr->valid & PNG_INFO_sBIT) != 0) 1175 png_set_shift(png_ptr, &info_ptr->sig_bit); 1176 #else 1177 png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported"); 1178 #endif 1179 1180 /* Flip the RGB pixels to BGR (or RGBA to BGRA) */ 1181 if ((transforms & PNG_TRANSFORM_BGR) != 0) 1182 #ifdef PNG_READ_BGR_SUPPORTED 1183 png_set_bgr(png_ptr); 1184 #else 1185 png_app_error(png_ptr, "PNG_TRANSFORM_BGR not supported"); 1186 #endif 1187 1188 /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ 1189 if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0) 1190 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED 1191 png_set_swap_alpha(png_ptr); 1192 #else 1193 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ALPHA not supported"); 1194 #endif 1195 1196 /* Swap bytes of 16-bit files to least significant byte first */ 1197 if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0) 1198 #ifdef PNG_READ_SWAP_SUPPORTED 1199 png_set_swap(png_ptr); 1200 #else 1201 png_app_error(png_ptr, "PNG_TRANSFORM_SWAP_ENDIAN not supported"); 1202 #endif 1203 1204 /* Added at libpng-1.2.41 */ 1205 /* Invert the alpha channel from opacity to transparency */ 1206 if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0) 1207 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED 1208 png_set_invert_alpha(png_ptr); 1209 #else 1210 png_app_error(png_ptr, "PNG_TRANSFORM_INVERT_ALPHA not supported"); 1211 #endif 1212 1213 /* Added at libpng-1.2.41 */ 1214 /* Expand grayscale image to RGB */ 1215 if ((transforms & PNG_TRANSFORM_GRAY_TO_RGB) != 0) 1216 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED 1217 png_set_gray_to_rgb(png_ptr); 1218 #else 1219 png_app_error(png_ptr, "PNG_TRANSFORM_GRAY_TO_RGB not supported"); 1220 #endif 1221 1222 /* Added at libpng-1.5.4 */ 1223 if ((transforms & PNG_TRANSFORM_EXPAND_16) != 0) 1224 #ifdef PNG_READ_EXPAND_16_SUPPORTED 1225 png_set_expand_16(png_ptr); 1226 #else 1227 png_app_error(png_ptr, "PNG_TRANSFORM_EXPAND_16 not supported"); 1228 #endif 1229 1230 /* We don't handle adding filler bytes */ 1231 1232 /* We use png_read_image and rely on that for interlace handling, but we also 1233 * call png_read_update_info therefore must turn on interlace handling now: 1234 */ 1235 (void)png_set_interlace_handling(png_ptr); 1236 1237 /* Optional call to gamma correct and add the background to the palette 1238 * and update info structure. REQUIRED if you are expecting libpng to 1239 * update the palette for you (i.e., you selected such a transform above). 1240 */ 1241 png_read_update_info(png_ptr, info_ptr); 1242 1243 /* -------------- image transformations end here ------------------- */ 1244 1245 png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); 1246 if (info_ptr->row_pointers == NULL) 1247 { 1248 png_uint_32 iptr; 1249 1250 info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr, 1251 info_ptr->height * (sizeof (png_bytep)))); 1252 1253 for (iptr=0; iptr<info_ptr->height; iptr++) 1254 info_ptr->row_pointers[iptr] = NULL; 1255 1256 info_ptr->free_me |= PNG_FREE_ROWS; 1257 1258 for (iptr = 0; iptr < info_ptr->height; iptr++) 1259 info_ptr->row_pointers[iptr] = png_voidcast(png_bytep, 1260 png_malloc(png_ptr, info_ptr->rowbytes)); 1261 } 1262 1263 png_read_image(png_ptr, info_ptr->row_pointers); 1264 info_ptr->valid |= PNG_INFO_IDAT; 1265 1266 /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ 1267 png_read_end(png_ptr, info_ptr); 1268 1269 PNG_UNUSED(params) 1270 } 1271 #endif /* INFO_IMAGE */ 1272 #endif /* SEQUENTIAL_READ */ 1273 1274 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED 1275 /* SIMPLIFIED READ 1276 * 1277 * This code currently relies on the sequential reader, though it could easily 1278 * be made to work with the progressive one. 1279 */ 1280 /* Arguments to png_image_finish_read: */ 1281 1282 /* Encoding of PNG data (used by the color-map code) */ 1283 # define P_NOTSET 0 /* File encoding not yet known */ 1284 # define P_sRGB 1 /* 8-bit encoded to sRGB gamma */ 1285 # define P_LINEAR 2 /* 16-bit linear: not encoded, NOT pre-multiplied! */ 1286 # define P_FILE 3 /* 8-bit encoded to file gamma, not sRGB or linear */ 1287 # define P_LINEAR8 4 /* 8-bit linear: only from a file value */ 1288 1289 /* Color-map processing: after libpng has run on the PNG image further 1290 * processing may be needed to convert the data to color-map indices. 1291 */ 1292 #define PNG_CMAP_NONE 0 1293 #define PNG_CMAP_GA 1 /* Process GA data to a color-map with alpha */ 1294 #define PNG_CMAP_TRANS 2 /* Process GA data to a background index */ 1295 #define PNG_CMAP_RGB 3 /* Process RGB data */ 1296 #define PNG_CMAP_RGB_ALPHA 4 /* Process RGBA data */ 1297 1298 /* The following document where the background is for each processing case. */ 1299 #define PNG_CMAP_NONE_BACKGROUND 256 1300 #define PNG_CMAP_GA_BACKGROUND 231 1301 #define PNG_CMAP_TRANS_BACKGROUND 254 1302 #define PNG_CMAP_RGB_BACKGROUND 256 1303 #define PNG_CMAP_RGB_ALPHA_BACKGROUND 216 1304 1305 typedef struct 1306 { 1307 /* Arguments: */ 1308 png_imagep image; 1309 png_voidp buffer; 1310 png_int_32 row_stride; 1311 png_voidp colormap; 1312 png_const_colorp background; 1313 /* Local variables: */ 1314 png_voidp local_row; 1315 png_voidp first_row; 1316 ptrdiff_t row_bytes; /* step between rows */ 1317 int file_encoding; /* E_ values above */ 1318 png_fixed_point gamma_to_linear; /* For P_FILE, reciprocal of gamma */ 1319 int colormap_processing; /* PNG_CMAP_ values above */ 1320 } png_image_read_control; 1321 1322 /* Do all the *safe* initialization - 'safe' means that png_error won't be 1323 * called, so setting up the jmp_buf is not required. This means that anything 1324 * called from here must *not* call png_malloc - it has to call png_malloc_warn 1325 * instead so that control is returned safely back to this routine. 1326 */ 1327 static int 1328 png_image_read_init(png_imagep image) 1329 { 1330 if (image->opaque == NULL) 1331 { 1332 png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image, 1333 png_safe_error, png_safe_warning); 1334 1335 /* And set the rest of the structure to NULL to ensure that the various 1336 * fields are consistent. 1337 */ 1338 memset(image, 0, (sizeof *image)); 1339 image->version = PNG_IMAGE_VERSION; 1340 1341 if (png_ptr != NULL) 1342 { 1343 png_infop info_ptr = png_create_info_struct(png_ptr); 1344 1345 if (info_ptr != NULL) 1346 { 1347 png_controlp control = png_voidcast(png_controlp, 1348 png_malloc_warn(png_ptr, (sizeof *control))); 1349 1350 if (control != NULL) 1351 { 1352 memset(control, 0, (sizeof *control)); 1353 1354 control->png_ptr = png_ptr; 1355 control->info_ptr = info_ptr; 1356 control->for_write = 0; 1357 1358 image->opaque = control; 1359 return 1; 1360 } 1361 1362 /* Error clean up */ 1363 png_destroy_info_struct(png_ptr, &info_ptr); 1364 } 1365 1366 png_destroy_read_struct(&png_ptr, NULL, NULL); 1367 } 1368 1369 return png_image_error(image, "png_image_read: out of memory"); 1370 } 1371 1372 return png_image_error(image, "png_image_read: opaque pointer not NULL"); 1373 } 1374 1375 /* Utility to find the base format of a PNG file from a png_struct. */ 1376 static png_uint_32 1377 png_image_format(png_structrp png_ptr) 1378 { 1379 png_uint_32 format = 0; 1380 1381 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) 1382 format |= PNG_FORMAT_FLAG_COLOR; 1383 1384 if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0) 1385 format |= PNG_FORMAT_FLAG_ALPHA; 1386 1387 /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS 1388 * sets the png_struct fields; that's all we are interested in here. The 1389 * precise interaction with an app call to png_set_tRNS and PNG file reading 1390 * is unclear. 1391 */ 1392 else if (png_ptr->num_trans > 0) 1393 format |= PNG_FORMAT_FLAG_ALPHA; 1394 1395 if (png_ptr->bit_depth == 16) 1396 format |= PNG_FORMAT_FLAG_LINEAR; 1397 1398 if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0) 1399 format |= PNG_FORMAT_FLAG_COLORMAP; 1400 1401 return format; 1402 } 1403 1404 /* Is the given gamma significantly different from sRGB? The test is the same 1405 * one used in pngrtran.c when deciding whether to do gamma correction. The 1406 * arithmetic optimizes the division by using the fact that the inverse of the 1407 * file sRGB gamma is 2.2 1408 */ 1409 static int 1410 png_gamma_not_sRGB(png_fixed_point g) 1411 { 1412 if (g < PNG_FP_1) 1413 { 1414 /* An uninitialized gamma is assumed to be sRGB for the simplified API. */ 1415 if (g == 0) 1416 return 0; 1417 1418 return png_gamma_significant((g * 11 + 2)/5 /* i.e. *2.2, rounded */); 1419 } 1420 1421 return 1; 1422 } 1423 1424 /* Do the main body of a 'png_image_begin_read' function; read the PNG file 1425 * header and fill in all the information. This is executed in a safe context, 1426 * unlike the init routine above. 1427 */ 1428 static int 1429 png_image_read_header(png_voidp argument) 1430 { 1431 png_imagep image = png_voidcast(png_imagep, argument); 1432 png_structrp png_ptr = image->opaque->png_ptr; 1433 png_inforp info_ptr = image->opaque->info_ptr; 1434 1435 #ifdef PNG_BENIGN_ERRORS_SUPPORTED 1436 png_set_benign_errors(png_ptr, 1/*warn*/); 1437 #endif 1438 png_read_info(png_ptr, info_ptr); 1439 1440 /* Do this the fast way; just read directly out of png_struct. */ 1441 image->width = png_ptr->width; 1442 image->height = png_ptr->height; 1443 1444 { 1445 png_uint_32 format = png_image_format(png_ptr); 1446 1447 image->format = format; 1448 1449 #ifdef PNG_COLORSPACE_SUPPORTED 1450 /* Does the colorspace match sRGB? If there is no color endpoint 1451 * (colorant) information assume yes, otherwise require the 1452 * 'ENDPOINTS_MATCHP_sRGB' colorspace flag to have been set. If the 1453 * colorspace has been determined to be invalid ignore it. 1454 */ 1455 if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags 1456 & (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB| 1457 PNG_COLORSPACE_INVALID)) == PNG_COLORSPACE_HAVE_ENDPOINTS)) 1458 image->flags |= PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB; 1459 #endif 1460 } 1461 1462 /* We need the maximum number of entries regardless of the format the 1463 * application sets here. 1464 */ 1465 { 1466 png_uint_32 cmap_entries; 1467 1468 switch (png_ptr->color_type) 1469 { 1470 case PNG_COLOR_TYPE_GRAY: 1471 cmap_entries = 1U << png_ptr->bit_depth; 1472 break; 1473 1474 case PNG_COLOR_TYPE_PALETTE: 1475 cmap_entries = (png_uint_32)png_ptr->num_palette; 1476 break; 1477 1478 default: 1479 cmap_entries = 256; 1480 break; 1481 } 1482 1483 if (cmap_entries > 256) 1484 cmap_entries = 256; 1485 1486 image->colormap_entries = cmap_entries; 1487 } 1488 1489 return 1; 1490 } 1491 1492 #ifdef PNG_STDIO_SUPPORTED 1493 int PNGAPI 1494 png_image_begin_read_from_stdio(png_imagep image, FILE* file) 1495 { 1496 if (image != NULL && image->version == PNG_IMAGE_VERSION) 1497 { 1498 if (file != NULL) 1499 { 1500 if (png_image_read_init(image) != 0) 1501 { 1502 /* This is slightly evil, but png_init_io doesn't do anything other 1503 * than this and we haven't changed the standard IO functions so 1504 * this saves a 'safe' function. 1505 */ 1506 image->opaque->png_ptr->io_ptr = file; 1507 return png_safe_execute(image, png_image_read_header, image); 1508 } 1509 } 1510 1511 else 1512 return png_image_error(image, 1513 "png_image_begin_read_from_stdio: invalid argument"); 1514 } 1515 1516 else if (image != NULL) 1517 return png_image_error(image, 1518 "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION"); 1519 1520 return 0; 1521 } 1522 1523 int PNGAPI 1524 png_image_begin_read_from_file(png_imagep image, const char *file_name) 1525 { 1526 if (image != NULL && image->version == PNG_IMAGE_VERSION) 1527 { 1528 if (file_name != NULL) 1529 { 1530 FILE *fp = fopen(file_name, "rb"); 1531 1532 if (fp != NULL) 1533 { 1534 if (png_image_read_init(image) != 0) 1535 { 1536 image->opaque->png_ptr->io_ptr = fp; 1537 image->opaque->owned_file = 1; 1538 return png_safe_execute(image, png_image_read_header, image); 1539 } 1540 1541 /* Clean up: just the opened file. */ 1542 (void)fclose(fp); 1543 } 1544 1545 else 1546 return png_image_error(image, strerror(errno)); 1547 } 1548 1549 else 1550 return png_image_error(image, 1551 "png_image_begin_read_from_file: invalid argument"); 1552 } 1553 1554 else if (image != NULL) 1555 return png_image_error(image, 1556 "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION"); 1557 1558 return 0; 1559 } 1560 #endif /* STDIO */ 1561 1562 static void PNGCBAPI 1563 png_image_memory_read(png_structp png_ptr, png_bytep out, size_t need) 1564 { 1565 if (png_ptr != NULL) 1566 { 1567 png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr); 1568 if (image != NULL) 1569 { 1570 png_controlp cp = image->opaque; 1571 if (cp != NULL) 1572 { 1573 png_const_bytep memory = cp->memory; 1574 size_t size = cp->size; 1575 1576 if (memory != NULL && size >= need) 1577 { 1578 memcpy(out, memory, need); 1579 cp->memory = memory + need; 1580 cp->size = size - need; 1581 return; 1582 } 1583 1584 png_error(png_ptr, "read beyond end of data"); 1585 } 1586 } 1587 1588 png_error(png_ptr, "invalid memory read"); 1589 } 1590 } 1591 1592 int PNGAPI png_image_begin_read_from_memory(png_imagep image, 1593 png_const_voidp memory, size_t size) 1594 { 1595 if (image != NULL && image->version == PNG_IMAGE_VERSION) 1596 { 1597 if (memory != NULL && size > 0) 1598 { 1599 if (png_image_read_init(image) != 0) 1600 { 1601 /* Now set the IO functions to read from the memory buffer and 1602 * store it into io_ptr. Again do this in-place to avoid calling a 1603 * libpng function that requires error handling. 1604 */ 1605 image->opaque->memory = png_voidcast(png_const_bytep, memory); 1606 image->opaque->size = size; 1607 image->opaque->png_ptr->io_ptr = image; 1608 image->opaque->png_ptr->read_data_fn = png_image_memory_read; 1609 1610 return png_safe_execute(image, png_image_read_header, image); 1611 } 1612 } 1613 1614 else 1615 return png_image_error(image, 1616 "png_image_begin_read_from_memory: invalid argument"); 1617 } 1618 1619 else if (image != NULL) 1620 return png_image_error(image, 1621 "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION"); 1622 1623 return 0; 1624 } 1625 1626 /* Utility function to skip chunks that are not used by the simplified image 1627 * read functions and an appropriate macro to call it. 1628 */ 1629 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED 1630 static void 1631 png_image_skip_unused_chunks(png_structrp png_ptr) 1632 { 1633 /* Prepare the reader to ignore all recognized chunks whose data will not 1634 * be used, i.e., all chunks recognized by libpng except for those 1635 * involved in basic image reading: 1636 * 1637 * IHDR, PLTE, IDAT, IEND 1638 * 1639 * Or image data handling: 1640 * 1641 * tRNS, bKGD, gAMA, cHRM, sRGB, [iCCP] and sBIT. 1642 * 1643 * This provides a small performance improvement and eliminates any 1644 * potential vulnerability to security problems in the unused chunks. 1645 * 1646 * At present the iCCP chunk data isn't used, so iCCP chunk can be ignored 1647 * too. This allows the simplified API to be compiled without iCCP support, 1648 * however if the support is there the chunk is still checked to detect 1649 * errors (which are unfortunately quite common.) 1650 */ 1651 { 1652 static PNG_CONST png_byte chunks_to_process[] = { 1653 98, 75, 71, 68, '\0', /* bKGD */ 1654 99, 72, 82, 77, '\0', /* cHRM */ 1655 103, 65, 77, 65, '\0', /* gAMA */ 1656 # ifdef PNG_READ_iCCP_SUPPORTED 1657 105, 67, 67, 80, '\0', /* iCCP */ 1658 # endif 1659 115, 66, 73, 84, '\0', /* sBIT */ 1660 115, 82, 71, 66, '\0', /* sRGB */ 1661 }; 1662 1663 /* Ignore unknown chunks and all other chunks except for the 1664 * IHDR, PLTE, tRNS, IDAT, and IEND chunks. 1665 */ 1666 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER, 1667 NULL, -1); 1668 1669 /* But do not ignore image data handling chunks */ 1670 png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT, 1671 chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5); 1672 } 1673 } 1674 1675 # define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p) 1676 #else 1677 # define PNG_SKIP_CHUNKS(p) ((void)0) 1678 #endif /* HANDLE_AS_UNKNOWN */ 1679 1680 /* The following macro gives the exact rounded answer for all values in the 1681 * range 0..255 (it actually divides by 51.2, but the rounding still generates 1682 * the correct numbers 0..5 1683 */ 1684 #define PNG_DIV51(v8) (((v8) * 5 + 130) >> 8) 1685 1686 /* Utility functions to make particular color-maps */ 1687 static void 1688 set_file_encoding(png_image_read_control *display) 1689 { 1690 png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma; 1691 if (png_gamma_significant(g) != 0) 1692 { 1693 if (png_gamma_not_sRGB(g) != 0) 1694 { 1695 display->file_encoding = P_FILE; 1696 display->gamma_to_linear = png_reciprocal(g); 1697 } 1698 1699 else 1700 display->file_encoding = P_sRGB; 1701 } 1702 1703 else 1704 display->file_encoding = P_LINEAR8; 1705 } 1706 1707 static unsigned int 1708 decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding) 1709 { 1710 if (encoding == P_FILE) /* double check */ 1711 encoding = display->file_encoding; 1712 1713 if (encoding == P_NOTSET) /* must be the file encoding */ 1714 { 1715 set_file_encoding(display); 1716 encoding = display->file_encoding; 1717 } 1718 1719 switch (encoding) 1720 { 1721 case P_FILE: 1722 value = png_gamma_16bit_correct(value*257, display->gamma_to_linear); 1723 break; 1724 1725 case P_sRGB: 1726 value = png_sRGB_table[value]; 1727 break; 1728 1729 case P_LINEAR: 1730 break; 1731 1732 case P_LINEAR8: 1733 value *= 257; 1734 break; 1735 1736 #ifdef __GNUC__ 1737 default: 1738 png_error(display->image->opaque->png_ptr, 1739 "unexpected encoding (internal error)"); 1740 #endif 1741 } 1742 1743 return value; 1744 } 1745 1746 static png_uint_32 1747 png_colormap_compose(png_image_read_control *display, 1748 png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha, 1749 png_uint_32 background, int encoding) 1750 { 1751 /* The file value is composed on the background, the background has the given 1752 * encoding and so does the result, the file is encoded with P_FILE and the 1753 * file and alpha are 8-bit values. The (output) encoding will always be 1754 * P_LINEAR or P_sRGB. 1755 */ 1756 png_uint_32 f = decode_gamma(display, foreground, foreground_encoding); 1757 png_uint_32 b = decode_gamma(display, background, encoding); 1758 1759 /* The alpha is always an 8-bit value (it comes from the palette), the value 1760 * scaled by 255 is what PNG_sRGB_FROM_LINEAR requires. 1761 */ 1762 f = f * alpha + b * (255-alpha); 1763 1764 if (encoding == P_LINEAR) 1765 { 1766 /* Scale to 65535; divide by 255, approximately (in fact this is extremely 1767 * accurate, it divides by 255.00000005937181414556, with no overflow.) 1768 */ 1769 f *= 257; /* Now scaled by 65535 */ 1770 f += f >> 16; 1771 f = (f+32768) >> 16; 1772 } 1773 1774 else /* P_sRGB */ 1775 f = PNG_sRGB_FROM_LINEAR(f); 1776 1777 return f; 1778 } 1779 1780 /* NOTE: P_LINEAR values to this routine must be 16-bit, but P_FILE values must 1781 * be 8-bit. 1782 */ 1783 static void 1784 png_create_colormap_entry(png_image_read_control *display, 1785 png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue, 1786 png_uint_32 alpha, int encoding) 1787 { 1788 png_imagep image = display->image; 1789 const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ? 1790 P_LINEAR : P_sRGB; 1791 const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 && 1792 (red != green || green != blue); 1793 1794 if (ip > 255) 1795 png_error(image->opaque->png_ptr, "color-map index out of range"); 1796 1797 /* Update the cache with whether the file gamma is significantly different 1798 * from sRGB. 1799 */ 1800 if (encoding == P_FILE) 1801 { 1802 if (display->file_encoding == P_NOTSET) 1803 set_file_encoding(display); 1804 1805 /* Note that the cached value may be P_FILE too, but if it is then the 1806 * gamma_to_linear member has been set. 1807 */ 1808 encoding = display->file_encoding; 1809 } 1810 1811 if (encoding == P_FILE) 1812 { 1813 png_fixed_point g = display->gamma_to_linear; 1814 1815 red = png_gamma_16bit_correct(red*257, g); 1816 green = png_gamma_16bit_correct(green*257, g); 1817 blue = png_gamma_16bit_correct(blue*257, g); 1818 1819 if (convert_to_Y != 0 || output_encoding == P_LINEAR) 1820 { 1821 alpha *= 257; 1822 encoding = P_LINEAR; 1823 } 1824 1825 else 1826 { 1827 red = PNG_sRGB_FROM_LINEAR(red * 255); 1828 green = PNG_sRGB_FROM_LINEAR(green * 255); 1829 blue = PNG_sRGB_FROM_LINEAR(blue * 255); 1830 encoding = P_sRGB; 1831 } 1832 } 1833 1834 else if (encoding == P_LINEAR8) 1835 { 1836 /* This encoding occurs quite frequently in test cases because PngSuite 1837 * includes a gAMA 1.0 chunk with most images. 1838 */ 1839 red *= 257; 1840 green *= 257; 1841 blue *= 257; 1842 alpha *= 257; 1843 encoding = P_LINEAR; 1844 } 1845 1846 else if (encoding == P_sRGB && 1847 (convert_to_Y != 0 || output_encoding == P_LINEAR)) 1848 { 1849 /* The values are 8-bit sRGB values, but must be converted to 16-bit 1850 * linear. 1851 */ 1852 red = png_sRGB_table[red]; 1853 green = png_sRGB_table[green]; 1854 blue = png_sRGB_table[blue]; 1855 alpha *= 257; 1856 encoding = P_LINEAR; 1857 } 1858 1859 /* This is set if the color isn't gray but the output is. */ 1860 if (encoding == P_LINEAR) 1861 { 1862 if (convert_to_Y != 0) 1863 { 1864 /* NOTE: these values are copied from png_do_rgb_to_gray */ 1865 png_uint_32 y = (png_uint_32)6968 * red + (png_uint_32)23434 * green + 1866 (png_uint_32)2366 * blue; 1867 1868 if (output_encoding == P_LINEAR) 1869 y = (y + 16384) >> 15; 1870 1871 else 1872 { 1873 /* y is scaled by 32768, we need it scaled by 255: */ 1874 y = (y + 128) >> 8; 1875 y *= 255; 1876 y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7); 1877 alpha = PNG_DIV257(alpha); 1878 encoding = P_sRGB; 1879 } 1880 1881 blue = red = green = y; 1882 } 1883 1884 else if (output_encoding == P_sRGB) 1885 { 1886 red = PNG_sRGB_FROM_LINEAR(red * 255); 1887 green = PNG_sRGB_FROM_LINEAR(green * 255); 1888 blue = PNG_sRGB_FROM_LINEAR(blue * 255); 1889 alpha = PNG_DIV257(alpha); 1890 encoding = P_sRGB; 1891 } 1892 } 1893 1894 if (encoding != output_encoding) 1895 png_error(image->opaque->png_ptr, "bad encoding (internal error)"); 1896 1897 /* Store the value. */ 1898 { 1899 # ifdef PNG_FORMAT_AFIRST_SUPPORTED 1900 const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 && 1901 (image->format & PNG_FORMAT_FLAG_ALPHA) != 0; 1902 # else 1903 # define afirst 0 1904 # endif 1905 # ifdef PNG_FORMAT_BGR_SUPPORTED 1906 const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0; 1907 # else 1908 # define bgr 0 1909 # endif 1910 1911 if (output_encoding == P_LINEAR) 1912 { 1913 png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap); 1914 1915 entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format); 1916 1917 /* The linear 16-bit values must be pre-multiplied by the alpha channel 1918 * value, if less than 65535 (this is, effectively, composite on black 1919 * if the alpha channel is removed.) 1920 */ 1921 switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format)) 1922 { 1923 case 4: 1924 entry[afirst ? 0 : 3] = (png_uint_16)alpha; 1925 /* FALLTHROUGH */ 1926 1927 case 3: 1928 if (alpha < 65535) 1929 { 1930 if (alpha > 0) 1931 { 1932 blue = (blue * alpha + 32767U)/65535U; 1933 green = (green * alpha + 32767U)/65535U; 1934 red = (red * alpha + 32767U)/65535U; 1935 } 1936 1937 else 1938 red = green = blue = 0; 1939 } 1940 entry[afirst + (2 ^ bgr)] = (png_uint_16)blue; 1941 entry[afirst + 1] = (png_uint_16)green; 1942 entry[afirst + bgr] = (png_uint_16)red; 1943 break; 1944 1945 case 2: 1946 entry[1 ^ afirst] = (png_uint_16)alpha; 1947 /* FALLTHROUGH */ 1948 1949 case 1: 1950 if (alpha < 65535) 1951 { 1952 if (alpha > 0) 1953 green = (green * alpha + 32767U)/65535U; 1954 1955 else 1956 green = 0; 1957 } 1958 entry[afirst] = (png_uint_16)green; 1959 break; 1960 1961 default: 1962 break; 1963 } 1964 } 1965 1966 else /* output encoding is P_sRGB */ 1967 { 1968 png_bytep entry = png_voidcast(png_bytep, display->colormap); 1969 1970 entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format); 1971 1972 switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format)) 1973 { 1974 case 4: 1975 entry[afirst ? 0 : 3] = (png_byte)alpha; 1976 /* FALLTHROUGH */ 1977 case 3: 1978 entry[afirst + (2 ^ bgr)] = (png_byte)blue; 1979 entry[afirst + 1] = (png_byte)green; 1980 entry[afirst + bgr] = (png_byte)red; 1981 break; 1982 1983 case 2: 1984 entry[1 ^ afirst] = (png_byte)alpha; 1985 /* FALLTHROUGH */ 1986 case 1: 1987 entry[afirst] = (png_byte)green; 1988 break; 1989 1990 default: 1991 break; 1992 } 1993 } 1994 1995 # ifdef afirst 1996 # undef afirst 1997 # endif 1998 # ifdef bgr 1999 # undef bgr 2000 # endif 2001 } 2002 } 2003 2004 static int 2005 make_gray_file_colormap(png_image_read_control *display) 2006 { 2007 unsigned int i; 2008 2009 for (i=0; i<256; ++i) 2010 png_create_colormap_entry(display, i, i, i, i, 255, P_FILE); 2011 2012 return (int)i; 2013 } 2014 2015 static int 2016 make_gray_colormap(png_image_read_control *display) 2017 { 2018 unsigned int i; 2019 2020 for (i=0; i<256; ++i) 2021 png_create_colormap_entry(display, i, i, i, i, 255, P_sRGB); 2022 2023 return (int)i; 2024 } 2025 #define PNG_GRAY_COLORMAP_ENTRIES 256 2026 2027 static int 2028 make_ga_colormap(png_image_read_control *display) 2029 { 2030 unsigned int i, a; 2031 2032 /* Alpha is retained, the output will be a color-map with entries 2033 * selected by six levels of alpha. One transparent entry, 6 gray 2034 * levels for all the intermediate alpha values, leaving 230 entries 2035 * for the opaque grays. The color-map entries are the six values 2036 * [0..5]*51, the GA processing uses PNG_DIV51(value) to find the 2037 * relevant entry. 2038 * 2039 * if (alpha > 229) // opaque 2040 * { 2041 * // The 231 entries are selected to make the math below work: 2042 * base = 0; 2043 * entry = (231 * gray + 128) >> 8; 2044 * } 2045 * else if (alpha < 26) // transparent 2046 * { 2047 * base = 231; 2048 * entry = 0; 2049 * } 2050 * else // partially opaque 2051 * { 2052 * base = 226 + 6 * PNG_DIV51(alpha); 2053 * entry = PNG_DIV51(gray); 2054 * } 2055 */ 2056 i = 0; 2057 while (i < 231) 2058 { 2059 unsigned int gray = (i * 256 + 115) / 231; 2060 png_create_colormap_entry(display, i++, gray, gray, gray, 255, P_sRGB); 2061 } 2062 2063 /* 255 is used here for the component values for consistency with the code 2064 * that undoes premultiplication in pngwrite.c. 2065 */ 2066 png_create_colormap_entry(display, i++, 255, 255, 255, 0, P_sRGB); 2067 2068 for (a=1; a<5; ++a) 2069 { 2070 unsigned int g; 2071 2072 for (g=0; g<6; ++g) 2073 png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51, 2074 P_sRGB); 2075 } 2076 2077 return (int)i; 2078 } 2079 2080 #define PNG_GA_COLORMAP_ENTRIES 256 2081 2082 static int 2083 make_rgb_colormap(png_image_read_control *display) 2084 { 2085 unsigned int i, r; 2086 2087 /* Build a 6x6x6 opaque RGB cube */ 2088 for (i=r=0; r<6; ++r) 2089 { 2090 unsigned int g; 2091 2092 for (g=0; g<6; ++g) 2093 { 2094 unsigned int b; 2095 2096 for (b=0; b<6; ++b) 2097 png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255, 2098 P_sRGB); 2099 } 2100 } 2101 2102 return (int)i; 2103 } 2104 2105 #define PNG_RGB_COLORMAP_ENTRIES 216 2106 2107 /* Return a palette index to the above palette given three 8-bit sRGB values. */ 2108 #define PNG_RGB_INDEX(r,g,b) \ 2109 ((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b))) 2110 2111 static int 2112 png_image_read_colormap(png_voidp argument) 2113 { 2114 png_image_read_control *display = 2115 png_voidcast(png_image_read_control*, argument); 2116 const png_imagep image = display->image; 2117 2118 const png_structrp png_ptr = image->opaque->png_ptr; 2119 const png_uint_32 output_format = image->format; 2120 const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ? 2121 P_LINEAR : P_sRGB; 2122 2123 unsigned int cmap_entries; 2124 unsigned int output_processing; /* Output processing option */ 2125 unsigned int data_encoding = P_NOTSET; /* Encoding libpng must produce */ 2126 2127 /* Background information; the background color and the index of this color 2128 * in the color-map if it exists (else 256). 2129 */ 2130 unsigned int background_index = 256; 2131 png_uint_32 back_r, back_g, back_b; 2132 2133 /* Flags to accumulate things that need to be done to the input. */ 2134 int expand_tRNS = 0; 2135 2136 /* Exclude the NYI feature of compositing onto a color-mapped buffer; it is 2137 * very difficult to do, the results look awful, and it is difficult to see 2138 * what possible use it is because the application can't control the 2139 * color-map. 2140 */ 2141 if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 || 2142 png_ptr->num_trans > 0) /* alpha in input */ && 2143 ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */) 2144 { 2145 if (output_encoding == P_LINEAR) /* compose on black */ 2146 back_b = back_g = back_r = 0; 2147 2148 else if (display->background == NULL /* no way to remove it */) 2149 png_error(png_ptr, 2150 "background color must be supplied to remove alpha/transparency"); 2151 2152 /* Get a copy of the background color (this avoids repeating the checks 2153 * below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the 2154 * output format. 2155 */ 2156 else 2157 { 2158 back_g = display->background->green; 2159 if ((output_format & PNG_FORMAT_FLAG_COLOR) != 0) 2160 { 2161 back_r = display->background->red; 2162 back_b = display->background->blue; 2163 } 2164 else 2165 back_b = back_r = back_g; 2166 } 2167 } 2168 2169 else if (output_encoding == P_LINEAR) 2170 back_b = back_r = back_g = 65535; 2171 2172 else 2173 back_b = back_r = back_g = 255; 2174 2175 /* Default the input file gamma if required - this is necessary because 2176 * libpng assumes that if no gamma information is present the data is in the 2177 * output format, but the simplified API deduces the gamma from the input 2178 * format. 2179 */ 2180 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0) 2181 { 2182 /* Do this directly, not using the png_colorspace functions, to ensure 2183 * that it happens even if the colorspace is invalid (though probably if 2184 * it is the setting will be ignored) Note that the same thing can be 2185 * achieved at the application interface with png_set_gAMA. 2186 */ 2187 if (png_ptr->bit_depth == 16 && 2188 (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0) 2189 png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR; 2190 2191 else 2192 png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE; 2193 2194 png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; 2195 } 2196 2197 /* Decide what to do based on the PNG color type of the input data. The 2198 * utility function png_create_colormap_entry deals with most aspects of the 2199 * output transformations; this code works out how to produce bytes of 2200 * color-map entries from the original format. 2201 */ 2202 switch (png_ptr->color_type) 2203 { 2204 case PNG_COLOR_TYPE_GRAY: 2205 if (png_ptr->bit_depth <= 8) 2206 { 2207 /* There at most 256 colors in the output, regardless of 2208 * transparency. 2209 */ 2210 unsigned int step, i, val, trans = 256/*ignore*/, back_alpha = 0; 2211 2212 cmap_entries = 1U << png_ptr->bit_depth; 2213 if (cmap_entries > image->colormap_entries) 2214 png_error(png_ptr, "gray[8] color-map: too few entries"); 2215 2216 step = 255 / (cmap_entries - 1); 2217 output_processing = PNG_CMAP_NONE; 2218 2219 /* If there is a tRNS chunk then this either selects a transparent 2220 * value or, if the output has no alpha, the background color. 2221 */ 2222 if (png_ptr->num_trans > 0) 2223 { 2224 trans = png_ptr->trans_color.gray; 2225 2226 if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) 2227 back_alpha = output_encoding == P_LINEAR ? 65535 : 255; 2228 } 2229 2230 /* png_create_colormap_entry just takes an RGBA and writes the 2231 * corresponding color-map entry using the format from 'image', 2232 * including the required conversion to sRGB or linear as 2233 * appropriate. The input values are always either sRGB (if the 2234 * gamma correction flag is 0) or 0..255 scaled file encoded values 2235 * (if the function must gamma correct them). 2236 */ 2237 for (i=val=0; i<cmap_entries; ++i, val += step) 2238 { 2239 /* 'i' is a file value. While this will result in duplicated 2240 * entries for 8-bit non-sRGB encoded files it is necessary to 2241 * have non-gamma corrected values to do tRNS handling. 2242 */ 2243 if (i != trans) 2244 png_create_colormap_entry(display, i, val, val, val, 255, 2245 P_FILE/*8-bit with file gamma*/); 2246 2247 /* Else this entry is transparent. The colors don't matter if 2248 * there is an alpha channel (back_alpha == 0), but it does no 2249 * harm to pass them in; the values are not set above so this 2250 * passes in white. 2251 * 2252 * NOTE: this preserves the full precision of the application 2253 * supplied background color when it is used. 2254 */ 2255 else 2256 png_create_colormap_entry(display, i, back_r, back_g, back_b, 2257 back_alpha, output_encoding); 2258 } 2259 2260 /* We need libpng to preserve the original encoding. */ 2261 data_encoding = P_FILE; 2262 2263 /* The rows from libpng, while technically gray values, are now also 2264 * color-map indices; however, they may need to be expanded to 1 2265 * byte per pixel. This is what png_set_packing does (i.e., it 2266 * unpacks the bit values into bytes.) 2267 */ 2268 if (png_ptr->bit_depth < 8) 2269 png_set_packing(png_ptr); 2270 } 2271 2272 else /* bit depth is 16 */ 2273 { 2274 /* The 16-bit input values can be converted directly to 8-bit gamma 2275 * encoded values; however, if a tRNS chunk is present 257 color-map 2276 * entries are required. This means that the extra entry requires 2277 * special processing; add an alpha channel, sacrifice gray level 2278 * 254 and convert transparent (alpha==0) entries to that. 2279 * 2280 * Use libpng to chop the data to 8 bits. Convert it to sRGB at the 2281 * same time to minimize quality loss. If a tRNS chunk is present 2282 * this means libpng must handle it too; otherwise it is impossible 2283 * to do the exact match on the 16-bit value. 2284 * 2285 * If the output has no alpha channel *and* the background color is 2286 * gray then it is possible to let libpng handle the substitution by 2287 * ensuring that the corresponding gray level matches the background 2288 * color exactly. 2289 */ 2290 data_encoding = P_sRGB; 2291 2292 if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) 2293 png_error(png_ptr, "gray[16] color-map: too few entries"); 2294 2295 cmap_entries = (unsigned int)make_gray_colormap(display); 2296 2297 if (png_ptr->num_trans > 0) 2298 { 2299 unsigned int back_alpha; 2300 2301 if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0) 2302 back_alpha = 0; 2303 2304 else 2305 { 2306 if (back_r == back_g && back_g == back_b) 2307 { 2308 /* Background is gray; no special processing will be 2309 * required. 2310 */ 2311 png_color_16 c; 2312 png_uint_32 gray = back_g; 2313 2314 if (output_encoding == P_LINEAR) 2315 { 2316 gray = PNG_sRGB_FROM_LINEAR(gray * 255); 2317 2318 /* And make sure the corresponding palette entry 2319 * matches. 2320 */ 2321 png_create_colormap_entry(display, gray, back_g, back_g, 2322 back_g, 65535, P_LINEAR); 2323 } 2324 2325 /* The background passed to libpng, however, must be the 2326 * sRGB value. 2327 */ 2328 c.index = 0; /*unused*/ 2329 c.gray = c.red = c.green = c.blue = (png_uint_16)gray; 2330 2331 /* NOTE: does this work without expanding tRNS to alpha? 2332 * It should be the color->gray case below apparently 2333 * doesn't. 2334 */ 2335 png_set_background_fixed(png_ptr, &c, 2336 PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, 2337 0/*gamma: not used*/); 2338 2339 output_processing = PNG_CMAP_NONE; 2340 break; 2341 } 2342 #ifdef __COVERITY__ 2343 /* Coverity claims that output_encoding cannot be 2 (P_LINEAR) 2344 * here. 2345 */ 2346 back_alpha = 255; 2347 #else 2348 back_alpha = output_encoding == P_LINEAR ? 65535 : 255; 2349 #endif 2350 } 2351 2352 /* output_processing means that the libpng-processed row will be 2353 * 8-bit GA and it has to be processing to single byte color-map 2354 * values. Entry 254 is replaced by either a completely 2355 * transparent entry or by the background color at full 2356 * precision (and the background color is not a simple gray 2357 * level in this case.) 2358 */ 2359 expand_tRNS = 1; 2360 output_processing = PNG_CMAP_TRANS; 2361 background_index = 254; 2362 2363 /* And set (overwrite) color-map entry 254 to the actual 2364 * background color at full precision. 2365 */ 2366 png_create_colormap_entry(display, 254, back_r, back_g, back_b, 2367 back_alpha, output_encoding); 2368 } 2369 2370 else 2371 output_processing = PNG_CMAP_NONE; 2372 } 2373 break; 2374 2375 case PNG_COLOR_TYPE_GRAY_ALPHA: 2376 /* 8-bit or 16-bit PNG with two channels - gray and alpha. A minimum 2377 * of 65536 combinations. If, however, the alpha channel is to be 2378 * removed there are only 256 possibilities if the background is gray. 2379 * (Otherwise there is a subset of the 65536 possibilities defined by 2380 * the triangle between black, white and the background color.) 2381 * 2382 * Reduce 16-bit files to 8-bit and sRGB encode the result. No need to 2383 * worry about tRNS matching - tRNS is ignored if there is an alpha 2384 * channel. 2385 */ 2386 data_encoding = P_sRGB; 2387 2388 if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0) 2389 { 2390 if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) 2391 png_error(png_ptr, "gray+alpha color-map: too few entries"); 2392 2393 cmap_entries = (unsigned int)make_ga_colormap(display); 2394 2395 background_index = PNG_CMAP_GA_BACKGROUND; 2396 output_processing = PNG_CMAP_GA; 2397 } 2398 2399 else /* alpha is removed */ 2400 { 2401 /* Alpha must be removed as the PNG data is processed when the 2402 * background is a color because the G and A channels are 2403 * independent and the vector addition (non-parallel vectors) is a 2404 * 2-D problem. 2405 * 2406 * This can be reduced to the same algorithm as above by making a 2407 * colormap containing gray levels (for the opaque grays), a 2408 * background entry (for a transparent pixel) and a set of four six 2409 * level color values, one set for each intermediate alpha value. 2410 * See the comments in make_ga_colormap for how this works in the 2411 * per-pixel processing. 2412 * 2413 * If the background is gray, however, we only need a 256 entry gray 2414 * level color map. It is sufficient to make the entry generated 2415 * for the background color be exactly the color specified. 2416 */ 2417 if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0 || 2418 (back_r == back_g && back_g == back_b)) 2419 { 2420 /* Background is gray; no special processing will be required. */ 2421 png_color_16 c; 2422 png_uint_32 gray = back_g; 2423 2424 if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) 2425 png_error(png_ptr, "gray-alpha color-map: too few entries"); 2426 2427 cmap_entries = (unsigned int)make_gray_colormap(display); 2428 2429 if (output_encoding == P_LINEAR) 2430 { 2431 gray = PNG_sRGB_FROM_LINEAR(gray * 255); 2432 2433 /* And make sure the corresponding palette entry matches. */ 2434 png_create_colormap_entry(display, gray, back_g, back_g, 2435 back_g, 65535, P_LINEAR); 2436 } 2437 2438 /* The background passed to libpng, however, must be the sRGB 2439 * value. 2440 */ 2441 c.index = 0; /*unused*/ 2442 c.gray = c.red = c.green = c.blue = (png_uint_16)gray; 2443 2444 png_set_background_fixed(png_ptr, &c, 2445 PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, 2446 0/*gamma: not used*/); 2447 2448 output_processing = PNG_CMAP_NONE; 2449 } 2450 2451 else 2452 { 2453 png_uint_32 i, a; 2454 2455 /* This is the same as png_make_ga_colormap, above, except that 2456 * the entries are all opaque. 2457 */ 2458 if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) 2459 png_error(png_ptr, "ga-alpha color-map: too few entries"); 2460 2461 i = 0; 2462 while (i < 231) 2463 { 2464 png_uint_32 gray = (i * 256 + 115) / 231; 2465 png_create_colormap_entry(display, i++, gray, gray, gray, 2466 255, P_sRGB); 2467 } 2468 2469 /* NOTE: this preserves the full precision of the application 2470 * background color. 2471 */ 2472 background_index = i; 2473 png_create_colormap_entry(display, i++, back_r, back_g, back_b, 2474 #ifdef __COVERITY__ 2475 /* Coverity claims that output_encoding 2476 * cannot be 2 (P_LINEAR) here. 2477 */ 255U, 2478 #else 2479 output_encoding == P_LINEAR ? 65535U : 255U, 2480 #endif 2481 output_encoding); 2482 2483 /* For non-opaque input composite on the sRGB background - this 2484 * requires inverting the encoding for each component. The input 2485 * is still converted to the sRGB encoding because this is a 2486 * reasonable approximate to the logarithmic curve of human 2487 * visual sensitivity, at least over the narrow range which PNG 2488 * represents. Consequently 'G' is always sRGB encoded, while 2489 * 'A' is linear. We need the linear background colors. 2490 */ 2491 if (output_encoding == P_sRGB) /* else already linear */ 2492 { 2493 /* This may produce a value not exactly matching the 2494 * background, but that's ok because these numbers are only 2495 * used when alpha != 0 2496 */ 2497 back_r = png_sRGB_table[back_r]; 2498 back_g = png_sRGB_table[back_g]; 2499 back_b = png_sRGB_table[back_b]; 2500 } 2501 2502 for (a=1; a<5; ++a) 2503 { 2504 unsigned int g; 2505 2506 /* PNG_sRGB_FROM_LINEAR expects a 16-bit linear value scaled 2507 * by an 8-bit alpha value (0..255). 2508 */ 2509 png_uint_32 alpha = 51 * a; 2510 png_uint_32 back_rx = (255-alpha) * back_r; 2511 png_uint_32 back_gx = (255-alpha) * back_g; 2512 png_uint_32 back_bx = (255-alpha) * back_b; 2513 2514 for (g=0; g<6; ++g) 2515 { 2516 png_uint_32 gray = png_sRGB_table[g*51] * alpha; 2517 2518 png_create_colormap_entry(display, i++, 2519 PNG_sRGB_FROM_LINEAR(gray + back_rx), 2520 PNG_sRGB_FROM_LINEAR(gray + back_gx), 2521 PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB); 2522 } 2523 } 2524 2525 cmap_entries = i; 2526 output_processing = PNG_CMAP_GA; 2527 } 2528 } 2529 break; 2530 2531 case PNG_COLOR_TYPE_RGB: 2532 case PNG_COLOR_TYPE_RGB_ALPHA: 2533 /* Exclude the case where the output is gray; we can always handle this 2534 * with the cases above. 2535 */ 2536 if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0) 2537 { 2538 /* The color-map will be grayscale, so we may as well convert the 2539 * input RGB values to a simple grayscale and use the grayscale 2540 * code above. 2541 * 2542 * NOTE: calling this apparently damages the recognition of the 2543 * transparent color in background color handling; call 2544 * png_set_tRNS_to_alpha before png_set_background_fixed. 2545 */ 2546 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1, 2547 -1); 2548 data_encoding = P_sRGB; 2549 2550 /* The output will now be one or two 8-bit gray or gray+alpha 2551 * channels. The more complex case arises when the input has alpha. 2552 */ 2553 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2554 png_ptr->num_trans > 0) && 2555 (output_format & PNG_FORMAT_FLAG_ALPHA) != 0) 2556 { 2557 /* Both input and output have an alpha channel, so no background 2558 * processing is required; just map the GA bytes to the right 2559 * color-map entry. 2560 */ 2561 expand_tRNS = 1; 2562 2563 if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) 2564 png_error(png_ptr, "rgb[ga] color-map: too few entries"); 2565 2566 cmap_entries = (unsigned int)make_ga_colormap(display); 2567 background_index = PNG_CMAP_GA_BACKGROUND; 2568 output_processing = PNG_CMAP_GA; 2569 } 2570 2571 else 2572 { 2573 /* Either the input or the output has no alpha channel, so there 2574 * will be no non-opaque pixels in the color-map; it will just be 2575 * grayscale. 2576 */ 2577 if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) 2578 png_error(png_ptr, "rgb[gray] color-map: too few entries"); 2579 2580 /* Ideally this code would use libpng to do the gamma correction, 2581 * but if an input alpha channel is to be removed we will hit the 2582 * libpng bug in gamma+compose+rgb-to-gray (the double gamma 2583 * correction bug). Fix this by dropping the gamma correction in 2584 * this case and doing it in the palette; this will result in 2585 * duplicate palette entries, but that's better than the 2586 * alternative of double gamma correction. 2587 */ 2588 if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2589 png_ptr->num_trans > 0) && 2590 png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0) 2591 { 2592 cmap_entries = (unsigned int)make_gray_file_colormap(display); 2593 data_encoding = P_FILE; 2594 } 2595 2596 else 2597 cmap_entries = (unsigned int)make_gray_colormap(display); 2598 2599 /* But if the input has alpha or transparency it must be removed 2600 */ 2601 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2602 png_ptr->num_trans > 0) 2603 { 2604 png_color_16 c; 2605 png_uint_32 gray = back_g; 2606 2607 /* We need to ensure that the application background exists in 2608 * the colormap and that completely transparent pixels map to 2609 * it. Achieve this simply by ensuring that the entry 2610 * selected for the background really is the background color. 2611 */ 2612 if (data_encoding == P_FILE) /* from the fixup above */ 2613 { 2614 /* The app supplied a gray which is in output_encoding, we 2615 * need to convert it to a value of the input (P_FILE) 2616 * encoding then set this palette entry to the required 2617 * output encoding. 2618 */ 2619 if (output_encoding == P_sRGB) 2620 gray = png_sRGB_table[gray]; /* now P_LINEAR */ 2621 2622 gray = PNG_DIV257(png_gamma_16bit_correct(gray, 2623 png_ptr->colorspace.gamma)); /* now P_FILE */ 2624 2625 /* And make sure the corresponding palette entry contains 2626 * exactly the required sRGB value. 2627 */ 2628 png_create_colormap_entry(display, gray, back_g, back_g, 2629 back_g, 0/*unused*/, output_encoding); 2630 } 2631 2632 else if (output_encoding == P_LINEAR) 2633 { 2634 gray = PNG_sRGB_FROM_LINEAR(gray * 255); 2635 2636 /* And make sure the corresponding palette entry matches. 2637 */ 2638 png_create_colormap_entry(display, gray, back_g, back_g, 2639 back_g, 0/*unused*/, P_LINEAR); 2640 } 2641 2642 /* The background passed to libpng, however, must be the 2643 * output (normally sRGB) value. 2644 */ 2645 c.index = 0; /*unused*/ 2646 c.gray = c.red = c.green = c.blue = (png_uint_16)gray; 2647 2648 /* NOTE: the following is apparently a bug in libpng. Without 2649 * it the transparent color recognition in 2650 * png_set_background_fixed seems to go wrong. 2651 */ 2652 expand_tRNS = 1; 2653 png_set_background_fixed(png_ptr, &c, 2654 PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, 2655 0/*gamma: not used*/); 2656 } 2657 2658 output_processing = PNG_CMAP_NONE; 2659 } 2660 } 2661 2662 else /* output is color */ 2663 { 2664 /* We could use png_quantize here so long as there is no transparent 2665 * color or alpha; png_quantize ignores alpha. Easier overall just 2666 * to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube. 2667 * Consequently we always want libpng to produce sRGB data. 2668 */ 2669 data_encoding = P_sRGB; 2670 2671 /* Is there any transparency or alpha? */ 2672 if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || 2673 png_ptr->num_trans > 0) 2674 { 2675 /* Is there alpha in the output too? If so all four channels are 2676 * processed into a special RGB cube with alpha support. 2677 */ 2678 if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0) 2679 { 2680 png_uint_32 r; 2681 2682 if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries) 2683 png_error(png_ptr, "rgb+alpha color-map: too few entries"); 2684 2685 cmap_entries = (unsigned int)make_rgb_colormap(display); 2686 2687 /* Add a transparent entry. */ 2688 png_create_colormap_entry(display, cmap_entries, 255, 255, 2689 255, 0, P_sRGB); 2690 2691 /* This is stored as the background index for the processing 2692 * algorithm. 2693 */ 2694 background_index = cmap_entries++; 2695 2696 /* Add 27 r,g,b entries each with alpha 0.5. */ 2697 for (r=0; r<256; r = (r << 1) | 0x7f) 2698 { 2699 png_uint_32 g; 2700 2701 for (g=0; g<256; g = (g << 1) | 0x7f) 2702 { 2703 png_uint_32 b; 2704 2705 /* This generates components with the values 0, 127 and 2706 * 255 2707 */ 2708 for (b=0; b<256; b = (b << 1) | 0x7f) 2709 png_create_colormap_entry(display, cmap_entries++, 2710 r, g, b, 128, P_sRGB); 2711 } 2712 } 2713 2714 expand_tRNS = 1; 2715 output_processing = PNG_CMAP_RGB_ALPHA; 2716 } 2717 2718 else 2719 { 2720 /* Alpha/transparency must be removed. The background must 2721 * exist in the color map (achieved by setting adding it after 2722 * the 666 color-map). If the standard processing code will 2723 * pick up this entry automatically that's all that is 2724 * required; libpng can be called to do the background 2725 * processing. 2726 */ 2727 unsigned int sample_size = 2728 PNG_IMAGE_SAMPLE_SIZE(output_format); 2729 png_uint_32 r, g, b; /* sRGB background */ 2730 2731 if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries) 2732 png_error(png_ptr, "rgb-alpha color-map: too few entries"); 2733 2734 cmap_entries = (unsigned int)make_rgb_colormap(display); 2735 2736 png_create_colormap_entry(display, cmap_entries, back_r, 2737 back_g, back_b, 0/*unused*/, output_encoding); 2738 2739 if (output_encoding == P_LINEAR) 2740 { 2741 r = PNG_sRGB_FROM_LINEAR(back_r * 255); 2742 g = PNG_sRGB_FROM_LINEAR(back_g * 255); 2743 b = PNG_sRGB_FROM_LINEAR(back_b * 255); 2744 } 2745 2746 else 2747 { 2748 r = back_r; 2749 g = back_g; 2750 b = back_g; 2751 } 2752 2753 /* Compare the newly-created color-map entry with the one the 2754 * PNG_CMAP_RGB algorithm will use. If the two entries don't 2755 * match, add the new one and set this as the background 2756 * index. 2757 */ 2758 if (memcmp((png_const_bytep)display->colormap + 2759 sample_size * cmap_entries, 2760 (png_const_bytep)display->colormap + 2761 sample_size * PNG_RGB_INDEX(r,g,b), 2762 sample_size) != 0) 2763 { 2764 /* The background color must be added. */ 2765 background_index = cmap_entries++; 2766 2767 /* Add 27 r,g,b entries each with created by composing with 2768 * the background at alpha 0.5. 2769 */ 2770 for (r=0; r<256; r = (r << 1) | 0x7f) 2771 { 2772 for (g=0; g<256; g = (g << 1) | 0x7f) 2773 { 2774 /* This generates components with the values 0, 127 2775 * and 255 2776 */ 2777 for (b=0; b<256; b = (b << 1) | 0x7f) 2778 png_create_colormap_entry(display, cmap_entries++, 2779 png_colormap_compose(display, r, P_sRGB, 128, 2780 back_r, output_encoding), 2781 png_colormap_compose(display, g, P_sRGB, 128, 2782 back_g, output_encoding), 2783 png_colormap_compose(display, b, P_sRGB, 128, 2784 back_b, output_encoding), 2785 0/*unused*/, output_encoding); 2786 } 2787 } 2788 2789 expand_tRNS = 1; 2790 output_processing = PNG_CMAP_RGB_ALPHA; 2791 } 2792 2793 else /* background color is in the standard color-map */ 2794 { 2795 png_color_16 c; 2796 2797 c.index = 0; /*unused*/ 2798 c.red = (png_uint_16)back_r; 2799 c.gray = c.green = (png_uint_16)back_g; 2800 c.blue = (png_uint_16)back_b; 2801 2802 png_set_background_fixed(png_ptr, &c, 2803 PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, 2804 0/*gamma: not used*/); 2805 2806 output_processing = PNG_CMAP_RGB; 2807 } 2808 } 2809 } 2810 2811 else /* no alpha or transparency in the input */ 2812 { 2813 /* Alpha in the output is irrelevant, simply map the opaque input 2814 * pixels to the 6x6x6 color-map. 2815 */ 2816 if (PNG_RGB_COLORMAP_ENTRIES > image->colormap_entries) 2817 png_error(png_ptr, "rgb color-map: too few entries"); 2818 2819 cmap_entries = (unsigned int)make_rgb_colormap(display); 2820 output_processing = PNG_CMAP_RGB; 2821 } 2822 } 2823 break; 2824 2825 case PNG_COLOR_TYPE_PALETTE: 2826 /* It's already got a color-map. It may be necessary to eliminate the 2827 * tRNS entries though. 2828 */ 2829 { 2830 unsigned int num_trans = png_ptr->num_trans; 2831 png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL; 2832 png_const_colorp colormap = png_ptr->palette; 2833 const int do_background = trans != NULL && 2834 (output_format & PNG_FORMAT_FLAG_ALPHA) == 0; 2835 unsigned int i; 2836 2837 /* Just in case: */ 2838 if (trans == NULL) 2839 num_trans = 0; 2840 2841 output_processing = PNG_CMAP_NONE; 2842 data_encoding = P_FILE; /* Don't change from color-map indices */ 2843 cmap_entries = (unsigned int)png_ptr->num_palette; 2844 if (cmap_entries > 256) 2845 cmap_entries = 256; 2846 2847 if (cmap_entries > (unsigned int)image->colormap_entries) 2848 png_error(png_ptr, "palette color-map: too few entries"); 2849 2850 for (i=0; i < cmap_entries; ++i) 2851 { 2852 if (do_background != 0 && i < num_trans && trans[i] < 255) 2853 { 2854 if (trans[i] == 0) 2855 png_create_colormap_entry(display, i, back_r, back_g, 2856 back_b, 0, output_encoding); 2857 2858 else 2859 { 2860 /* Must compose the PNG file color in the color-map entry 2861 * on the sRGB color in 'back'. 2862 */ 2863 png_create_colormap_entry(display, i, 2864 png_colormap_compose(display, colormap[i].red, 2865 P_FILE, trans[i], back_r, output_encoding), 2866 png_colormap_compose(display, colormap[i].green, 2867 P_FILE, trans[i], back_g, output_encoding), 2868 png_colormap_compose(display, colormap[i].blue, 2869 P_FILE, trans[i], back_b, output_encoding), 2870 output_encoding == P_LINEAR ? trans[i] * 257U : 2871 trans[i], 2872 output_encoding); 2873 } 2874 } 2875 2876 else 2877 png_create_colormap_entry(display, i, colormap[i].red, 2878 colormap[i].green, colormap[i].blue, 2879 i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/); 2880 } 2881 2882 /* The PNG data may have indices packed in fewer than 8 bits, it 2883 * must be expanded if so. 2884 */ 2885 if (png_ptr->bit_depth < 8) 2886 png_set_packing(png_ptr); 2887 } 2888 break; 2889 2890 default: 2891 png_error(png_ptr, "invalid PNG color type"); 2892 /*NOT REACHED*/ 2893 } 2894 2895 /* Now deal with the output processing */ 2896 if (expand_tRNS != 0 && png_ptr->num_trans > 0 && 2897 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0) 2898 png_set_tRNS_to_alpha(png_ptr); 2899 2900 switch (data_encoding) 2901 { 2902 case P_sRGB: 2903 /* Change to 8-bit sRGB */ 2904 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB); 2905 /* FALLTHROUGH */ 2906 2907 case P_FILE: 2908 if (png_ptr->bit_depth > 8) 2909 png_set_scale_16(png_ptr); 2910 break; 2911 2912 #ifdef __GNUC__ 2913 default: 2914 png_error(png_ptr, "bad data option (internal error)"); 2915 #endif 2916 } 2917 2918 if (cmap_entries > 256 || cmap_entries > image->colormap_entries) 2919 png_error(png_ptr, "color map overflow (BAD internal error)"); 2920 2921 image->colormap_entries = cmap_entries; 2922 2923 /* Double check using the recorded background index */ 2924 switch (output_processing) 2925 { 2926 case PNG_CMAP_NONE: 2927 if (background_index != PNG_CMAP_NONE_BACKGROUND) 2928 goto bad_background; 2929 break; 2930 2931 case PNG_CMAP_GA: 2932 if (background_index != PNG_CMAP_GA_BACKGROUND) 2933 goto bad_background; 2934 break; 2935 2936 case PNG_CMAP_TRANS: 2937 if (background_index >= cmap_entries || 2938 background_index != PNG_CMAP_TRANS_BACKGROUND) 2939 goto bad_background; 2940 break; 2941 2942 case PNG_CMAP_RGB: 2943 if (background_index != PNG_CMAP_RGB_BACKGROUND) 2944 goto bad_background; 2945 break; 2946 2947 case PNG_CMAP_RGB_ALPHA: 2948 if (background_index != PNG_CMAP_RGB_ALPHA_BACKGROUND) 2949 goto bad_background; 2950 break; 2951 2952 default: 2953 png_error(png_ptr, "bad processing option (internal error)"); 2954 2955 bad_background: 2956 png_error(png_ptr, "bad background index (internal error)"); 2957 } 2958 2959 display->colormap_processing = (int)output_processing; 2960 2961 return 1/*ok*/; 2962 } 2963 2964 /* The final part of the color-map read called from png_image_finish_read. */ 2965 static int 2966 png_image_read_and_map(png_voidp argument) 2967 { 2968 png_image_read_control *display = png_voidcast(png_image_read_control*, 2969 argument); 2970 png_imagep image = display->image; 2971 png_structrp png_ptr = image->opaque->png_ptr; 2972 int passes; 2973 2974 /* Called when the libpng data must be transformed into the color-mapped 2975 * form. There is a local row buffer in display->local and this routine must 2976 * do the interlace handling. 2977 */ 2978 switch (png_ptr->interlaced) 2979 { 2980 case PNG_INTERLACE_NONE: 2981 passes = 1; 2982 break; 2983 2984 case PNG_INTERLACE_ADAM7: 2985 passes = PNG_INTERLACE_ADAM7_PASSES; 2986 break; 2987 2988 default: 2989 png_error(png_ptr, "unknown interlace type"); 2990 } 2991 2992 { 2993 png_uint_32 height = image->height; 2994 png_uint_32 width = image->width; 2995 int proc = display->colormap_processing; 2996 png_bytep first_row = png_voidcast(png_bytep, display->first_row); 2997 ptrdiff_t step_row = display->row_bytes; 2998 int pass; 2999 3000 for (pass = 0; pass < passes; ++pass) 3001 { 3002 unsigned int startx, stepx, stepy; 3003 png_uint_32 y; 3004 3005 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) 3006 { 3007 /* The row may be empty for a short image: */ 3008 if (PNG_PASS_COLS(width, pass) == 0) 3009 continue; 3010 3011 startx = PNG_PASS_START_COL(pass); 3012 stepx = PNG_PASS_COL_OFFSET(pass); 3013 y = PNG_PASS_START_ROW(pass); 3014 stepy = PNG_PASS_ROW_OFFSET(pass); 3015 } 3016 3017 else 3018 { 3019 y = 0; 3020 startx = 0; 3021 stepx = stepy = 1; 3022 } 3023 3024 for (; y<height; y += stepy) 3025 { 3026 png_bytep inrow = png_voidcast(png_bytep, display->local_row); 3027 png_bytep outrow = first_row + y * step_row; 3028 png_const_bytep end_row = outrow + width; 3029 3030 /* Read read the libpng data into the temporary buffer. */ 3031 png_read_row(png_ptr, inrow, NULL); 3032 3033 /* Now process the row according to the processing option, note 3034 * that the caller verifies that the format of the libpng output 3035 * data is as required. 3036 */ 3037 outrow += startx; 3038 switch (proc) 3039 { 3040 case PNG_CMAP_GA: 3041 for (; outrow < end_row; outrow += stepx) 3042 { 3043 /* The data is always in the PNG order */ 3044 unsigned int gray = *inrow++; 3045 unsigned int alpha = *inrow++; 3046 unsigned int entry; 3047 3048 /* NOTE: this code is copied as a comment in 3049 * make_ga_colormap above. Please update the 3050 * comment if you change this code! 3051 */ 3052 if (alpha > 229) /* opaque */ 3053 { 3054 entry = (231 * gray + 128) >> 8; 3055 } 3056 else if (alpha < 26) /* transparent */ 3057 { 3058 entry = 231; 3059 } 3060 else /* partially opaque */ 3061 { 3062 entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray); 3063 } 3064 3065 *outrow = (png_byte)entry; 3066 } 3067 break; 3068 3069 case PNG_CMAP_TRANS: 3070 for (; outrow < end_row; outrow += stepx) 3071 { 3072 png_byte gray = *inrow++; 3073 png_byte alpha = *inrow++; 3074 3075 if (alpha == 0) 3076 *outrow = PNG_CMAP_TRANS_BACKGROUND; 3077 3078 else if (gray != PNG_CMAP_TRANS_BACKGROUND) 3079 *outrow = gray; 3080 3081 else 3082 *outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1); 3083 } 3084 break; 3085 3086 case PNG_CMAP_RGB: 3087 for (; outrow < end_row; outrow += stepx) 3088 { 3089 *outrow = PNG_RGB_INDEX(inrow[0], inrow[1], inrow[2]); 3090 inrow += 3; 3091 } 3092 break; 3093 3094 case PNG_CMAP_RGB_ALPHA: 3095 for (; outrow < end_row; outrow += stepx) 3096 { 3097 unsigned int alpha = inrow[3]; 3098 3099 /* Because the alpha entries only hold alpha==0.5 values 3100 * split the processing at alpha==0.25 (64) and 0.75 3101 * (196). 3102 */ 3103 3104 if (alpha >= 196) 3105 *outrow = PNG_RGB_INDEX(inrow[0], inrow[1], 3106 inrow[2]); 3107 3108 else if (alpha < 64) 3109 *outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND; 3110 3111 else 3112 { 3113 /* Likewise there are three entries for each of r, g 3114 * and b. We could select the entry by popcount on 3115 * the top two bits on those architectures that 3116 * support it, this is what the code below does, 3117 * crudely. 3118 */ 3119 unsigned int back_i = PNG_CMAP_RGB_ALPHA_BACKGROUND+1; 3120 3121 /* Here are how the values map: 3122 * 3123 * 0x00 .. 0x3f -> 0 3124 * 0x40 .. 0xbf -> 1 3125 * 0xc0 .. 0xff -> 2 3126 * 3127 * So, as above with the explicit alpha checks, the 3128 * breakpoints are at 64 and 196. 3129 */ 3130 if (inrow[0] & 0x80) back_i += 9; /* red */ 3131 if (inrow[0] & 0x40) back_i += 9; 3132 if (inrow[0] & 0x80) back_i += 3; /* green */ 3133 if (inrow[0] & 0x40) back_i += 3; 3134 if (inrow[0] & 0x80) back_i += 1; /* blue */ 3135 if (inrow[0] & 0x40) back_i += 1; 3136 3137 *outrow = (png_byte)back_i; 3138 } 3139 3140 inrow += 4; 3141 } 3142 break; 3143 3144 default: 3145 break; 3146 } 3147 } 3148 } 3149 } 3150 3151 return 1; 3152 } 3153 3154 static int 3155 png_image_read_colormapped(png_voidp argument) 3156 { 3157 png_image_read_control *display = png_voidcast(png_image_read_control*, 3158 argument); 3159 png_imagep image = display->image; 3160 png_controlp control = image->opaque; 3161 png_structrp png_ptr = control->png_ptr; 3162 png_inforp info_ptr = control->info_ptr; 3163 3164 int passes = 0; /* As a flag */ 3165 3166 PNG_SKIP_CHUNKS(png_ptr); 3167 3168 /* Update the 'info' structure and make sure the result is as required; first 3169 * make sure to turn on the interlace handling if it will be required 3170 * (because it can't be turned on *after* the call to png_read_update_info!) 3171 */ 3172 if (display->colormap_processing == PNG_CMAP_NONE) 3173 passes = png_set_interlace_handling(png_ptr); 3174 3175 png_read_update_info(png_ptr, info_ptr); 3176 3177 /* The expected output can be deduced from the colormap_processing option. */ 3178 switch (display->colormap_processing) 3179 { 3180 case PNG_CMAP_NONE: 3181 /* Output must be one channel and one byte per pixel, the output 3182 * encoding can be anything. 3183 */ 3184 if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE || 3185 info_ptr->color_type == PNG_COLOR_TYPE_GRAY) && 3186 info_ptr->bit_depth == 8) 3187 break; 3188 3189 goto bad_output; 3190 3191 case PNG_CMAP_TRANS: 3192 case PNG_CMAP_GA: 3193 /* Output must be two channels and the 'G' one must be sRGB, the latter 3194 * can be checked with an exact number because it should have been set 3195 * to this number above! 3196 */ 3197 if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && 3198 info_ptr->bit_depth == 8 && 3199 png_ptr->screen_gamma == PNG_GAMMA_sRGB && 3200 image->colormap_entries == 256) 3201 break; 3202 3203 goto bad_output; 3204 3205 case PNG_CMAP_RGB: 3206 /* Output must be 8-bit sRGB encoded RGB */ 3207 if (info_ptr->color_type == PNG_COLOR_TYPE_RGB && 3208 info_ptr->bit_depth == 8 && 3209 png_ptr->screen_gamma == PNG_GAMMA_sRGB && 3210 image->colormap_entries == 216) 3211 break; 3212 3213 goto bad_output; 3214 3215 case PNG_CMAP_RGB_ALPHA: 3216 /* Output must be 8-bit sRGB encoded RGBA */ 3217 if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA && 3218 info_ptr->bit_depth == 8 && 3219 png_ptr->screen_gamma == PNG_GAMMA_sRGB && 3220 image->colormap_entries == 244 /* 216 + 1 + 27 */) 3221 break; 3222 3223 goto bad_output; 3224 3225 default: 3226 bad_output: 3227 png_error(png_ptr, "bad color-map processing (internal error)"); 3228 } 3229 3230 /* Now read the rows. Do this here if it is possible to read directly into 3231 * the output buffer, otherwise allocate a local row buffer of the maximum 3232 * size libpng requires and call the relevant processing routine safely. 3233 */ 3234 { 3235 png_voidp first_row = display->buffer; 3236 ptrdiff_t row_bytes = display->row_stride; 3237 3238 /* The following expression is designed to work correctly whether it gives 3239 * a signed or an unsigned result. 3240 */ 3241 if (row_bytes < 0) 3242 { 3243 char *ptr = png_voidcast(char*, first_row); 3244 ptr += (image->height-1) * (-row_bytes); 3245 first_row = png_voidcast(png_voidp, ptr); 3246 } 3247 3248 display->first_row = first_row; 3249 display->row_bytes = row_bytes; 3250 } 3251 3252 if (passes == 0) 3253 { 3254 int result; 3255 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); 3256 3257 display->local_row = row; 3258 result = png_safe_execute(image, png_image_read_and_map, display); 3259 display->local_row = NULL; 3260 png_free(png_ptr, row); 3261 3262 return result; 3263 } 3264 3265 else 3266 { 3267 png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes; 3268 3269 while (--passes >= 0) 3270 { 3271 png_uint_32 y = image->height; 3272 png_bytep row = png_voidcast(png_bytep, display->first_row); 3273 3274 for (; y > 0; --y) 3275 { 3276 png_read_row(png_ptr, row, NULL); 3277 row += row_bytes; 3278 } 3279 } 3280 3281 return 1; 3282 } 3283 } 3284 3285 /* Just the row reading part of png_image_read. */ 3286 static int 3287 png_image_read_composite(png_voidp argument) 3288 { 3289 png_image_read_control *display = png_voidcast(png_image_read_control*, 3290 argument); 3291 png_imagep image = display->image; 3292 png_structrp png_ptr = image->opaque->png_ptr; 3293 int passes; 3294 3295 switch (png_ptr->interlaced) 3296 { 3297 case PNG_INTERLACE_NONE: 3298 passes = 1; 3299 break; 3300 3301 case PNG_INTERLACE_ADAM7: 3302 passes = PNG_INTERLACE_ADAM7_PASSES; 3303 break; 3304 3305 default: 3306 png_error(png_ptr, "unknown interlace type"); 3307 } 3308 3309 { 3310 png_uint_32 height = image->height; 3311 png_uint_32 width = image->width; 3312 ptrdiff_t step_row = display->row_bytes; 3313 unsigned int channels = 3314 (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1; 3315 int pass; 3316 3317 for (pass = 0; pass < passes; ++pass) 3318 { 3319 unsigned int startx, stepx, stepy; 3320 png_uint_32 y; 3321 3322 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) 3323 { 3324 /* The row may be empty for a short image: */ 3325 if (PNG_PASS_COLS(width, pass) == 0) 3326 continue; 3327 3328 startx = PNG_PASS_START_COL(pass) * channels; 3329 stepx = PNG_PASS_COL_OFFSET(pass) * channels; 3330 y = PNG_PASS_START_ROW(pass); 3331 stepy = PNG_PASS_ROW_OFFSET(pass); 3332 } 3333 3334 else 3335 { 3336 y = 0; 3337 startx = 0; 3338 stepx = channels; 3339 stepy = 1; 3340 } 3341 3342 for (; y<height; y += stepy) 3343 { 3344 png_bytep inrow = png_voidcast(png_bytep, display->local_row); 3345 png_bytep outrow; 3346 png_const_bytep end_row; 3347 3348 /* Read the row, which is packed: */ 3349 png_read_row(png_ptr, inrow, NULL); 3350 3351 outrow = png_voidcast(png_bytep, display->first_row); 3352 outrow += y * step_row; 3353 end_row = outrow + width * channels; 3354 3355 /* Now do the composition on each pixel in this row. */ 3356 outrow += startx; 3357 for (; outrow < end_row; outrow += stepx) 3358 { 3359 png_byte alpha = inrow[channels]; 3360 3361 if (alpha > 0) /* else no change to the output */ 3362 { 3363 unsigned int c; 3364 3365 for (c=0; c<channels; ++c) 3366 { 3367 png_uint_32 component = inrow[c]; 3368 3369 if (alpha < 255) /* else just use component */ 3370 { 3371 /* This is PNG_OPTIMIZED_ALPHA, the component value 3372 * is a linear 8-bit value. Combine this with the 3373 * current outrow[c] value which is sRGB encoded. 3374 * Arithmetic here is 16-bits to preserve the output 3375 * values correctly. 3376 */ 3377 component *= 257*255; /* =65535 */ 3378 component += (255-alpha)*png_sRGB_table[outrow[c]]; 3379 3380 /* So 'component' is scaled by 255*65535 and is 3381 * therefore appropriate for the sRGB to linear 3382 * conversion table. 3383 */ 3384 component = PNG_sRGB_FROM_LINEAR(component); 3385 } 3386 3387 outrow[c] = (png_byte)component; 3388 } 3389 } 3390 3391 inrow += channels+1; /* components and alpha channel */ 3392 } 3393 } 3394 } 3395 } 3396 3397 return 1; 3398 } 3399 3400 /* The do_local_background case; called when all the following transforms are to 3401 * be done: 3402 * 3403 * PNG_RGB_TO_GRAY 3404 * PNG_COMPOSITE 3405 * PNG_GAMMA 3406 * 3407 * This is a work-around for the fact that both the PNG_RGB_TO_GRAY and 3408 * PNG_COMPOSITE code performs gamma correction, so we get double gamma 3409 * correction. The fix-up is to prevent the PNG_COMPOSITE operation from 3410 * happening inside libpng, so this routine sees an 8 or 16-bit gray+alpha 3411 * row and handles the removal or pre-multiplication of the alpha channel. 3412 */ 3413 static int 3414 png_image_read_background(png_voidp argument) 3415 { 3416 png_image_read_control *display = png_voidcast(png_image_read_control*, 3417 argument); 3418 png_imagep image = display->image; 3419 png_structrp png_ptr = image->opaque->png_ptr; 3420 png_inforp info_ptr = image->opaque->info_ptr; 3421 png_uint_32 height = image->height; 3422 png_uint_32 width = image->width; 3423 int pass, passes; 3424 3425 /* Double check the convoluted logic below. We expect to get here with 3426 * libpng doing rgb to gray and gamma correction but background processing 3427 * left to the png_image_read_background function. The rows libpng produce 3428 * might be 8 or 16-bit but should always have two channels; gray plus alpha. 3429 */ 3430 if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0) 3431 png_error(png_ptr, "lost rgb to gray"); 3432 3433 if ((png_ptr->transformations & PNG_COMPOSE) != 0) 3434 png_error(png_ptr, "unexpected compose"); 3435 3436 if (png_get_channels(png_ptr, info_ptr) != 2) 3437 png_error(png_ptr, "lost/gained channels"); 3438 3439 /* Expect the 8-bit case to always remove the alpha channel */ 3440 if ((image->format & PNG_FORMAT_FLAG_LINEAR) == 0 && 3441 (image->format & PNG_FORMAT_FLAG_ALPHA) != 0) 3442 png_error(png_ptr, "unexpected 8-bit transformation"); 3443 3444 switch (png_ptr->interlaced) 3445 { 3446 case PNG_INTERLACE_NONE: 3447 passes = 1; 3448 break; 3449 3450 case PNG_INTERLACE_ADAM7: 3451 passes = PNG_INTERLACE_ADAM7_PASSES; 3452 break; 3453 3454 default: 3455 png_error(png_ptr, "unknown interlace type"); 3456 } 3457 3458 /* Use direct access to info_ptr here because otherwise the simplified API 3459 * would require PNG_EASY_ACCESS_SUPPORTED (just for this.) Note this is 3460 * checking the value after libpng expansions, not the original value in the 3461 * PNG. 3462 */ 3463 switch (info_ptr->bit_depth) 3464 { 3465 case 8: 3466 /* 8-bit sRGB gray values with an alpha channel; the alpha channel is 3467 * to be removed by composing on a background: either the row if 3468 * display->background is NULL or display->background->green if not. 3469 * Unlike the code above ALPHA_OPTIMIZED has *not* been done. 3470 */ 3471 { 3472 png_bytep first_row = png_voidcast(png_bytep, display->first_row); 3473 ptrdiff_t step_row = display->row_bytes; 3474 3475 for (pass = 0; pass < passes; ++pass) 3476 { 3477 png_bytep row = png_voidcast(png_bytep, display->first_row); 3478 unsigned int startx, stepx, stepy; 3479 png_uint_32 y; 3480 3481 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) 3482 { 3483 /* The row may be empty for a short image: */ 3484 if (PNG_PASS_COLS(width, pass) == 0) 3485 continue; 3486 3487 startx = PNG_PASS_START_COL(pass); 3488 stepx = PNG_PASS_COL_OFFSET(pass); 3489 y = PNG_PASS_START_ROW(pass); 3490 stepy = PNG_PASS_ROW_OFFSET(pass); 3491 } 3492 3493 else 3494 { 3495 y = 0; 3496 startx = 0; 3497 stepx = stepy = 1; 3498 } 3499 3500 if (display->background == NULL) 3501 { 3502 for (; y<height; y += stepy) 3503 { 3504 png_bytep inrow = png_voidcast(png_bytep, 3505 display->local_row); 3506 png_bytep outrow = first_row + y * step_row; 3507 png_const_bytep end_row = outrow + width; 3508 3509 /* Read the row, which is packed: */ 3510 png_read_row(png_ptr, inrow, NULL); 3511 3512 /* Now do the composition on each pixel in this row. */ 3513 outrow += startx; 3514 for (; outrow < end_row; outrow += stepx) 3515 { 3516 png_byte alpha = inrow[1]; 3517 3518 if (alpha > 0) /* else no change to the output */ 3519 { 3520 png_uint_32 component = inrow[0]; 3521 3522 if (alpha < 255) /* else just use component */ 3523 { 3524 /* Since PNG_OPTIMIZED_ALPHA was not set it is 3525 * necessary to invert the sRGB transfer 3526 * function and multiply the alpha out. 3527 */ 3528 component = png_sRGB_table[component] * alpha; 3529 component += png_sRGB_table[outrow[0]] * 3530 (255-alpha); 3531 component = PNG_sRGB_FROM_LINEAR(component); 3532 } 3533 3534 outrow[0] = (png_byte)component; 3535 } 3536 3537 inrow += 2; /* gray and alpha channel */ 3538 } 3539 } 3540 } 3541 3542 else /* constant background value */ 3543 { 3544 png_byte background8 = display->background->green; 3545 png_uint_16 background = png_sRGB_table[background8]; 3546 3547 for (; y<height; y += stepy) 3548 { 3549 png_bytep inrow = png_voidcast(png_bytep, 3550 display->local_row); 3551 png_bytep outrow = first_row + y * step_row; 3552 png_const_bytep end_row = outrow + width; 3553 3554 /* Read the row, which is packed: */ 3555 png_read_row(png_ptr, inrow, NULL); 3556 3557 /* Now do the composition on each pixel in this row. */ 3558 outrow += startx; 3559 for (; outrow < end_row; outrow += stepx) 3560 { 3561 png_byte alpha = inrow[1]; 3562 3563 if (alpha > 0) /* else use background */ 3564 { 3565 png_uint_32 component = inrow[0]; 3566 3567 if (alpha < 255) /* else just use component */ 3568 { 3569 component = png_sRGB_table[component] * alpha; 3570 component += background * (255-alpha); 3571 component = PNG_sRGB_FROM_LINEAR(component); 3572 } 3573 3574 outrow[0] = (png_byte)component; 3575 } 3576 3577 else 3578 outrow[0] = background8; 3579 3580 inrow += 2; /* gray and alpha channel */ 3581 } 3582 3583 row += display->row_bytes; 3584 } 3585 } 3586 } 3587 } 3588 break; 3589 3590 case 16: 3591 /* 16-bit linear with pre-multiplied alpha; the pre-multiplication must 3592 * still be done and, maybe, the alpha channel removed. This code also 3593 * handles the alpha-first option. 3594 */ 3595 { 3596 png_uint_16p first_row = png_voidcast(png_uint_16p, 3597 display->first_row); 3598 /* The division by two is safe because the caller passed in a 3599 * stride which was multiplied by 2 (below) to get row_bytes. 3600 */ 3601 ptrdiff_t step_row = display->row_bytes / 2; 3602 unsigned int preserve_alpha = (image->format & 3603 PNG_FORMAT_FLAG_ALPHA) != 0; 3604 unsigned int outchannels = 1U+preserve_alpha; 3605 int swap_alpha = 0; 3606 3607 # ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED 3608 if (preserve_alpha != 0 && 3609 (image->format & PNG_FORMAT_FLAG_AFIRST) != 0) 3610 swap_alpha = 1; 3611 # endif 3612 3613 for (pass = 0; pass < passes; ++pass) 3614 { 3615 unsigned int startx, stepx, stepy; 3616 png_uint_32 y; 3617 3618 /* The 'x' start and step are adjusted to output components here. 3619 */ 3620 if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) 3621 { 3622 /* The row may be empty for a short image: */ 3623 if (PNG_PASS_COLS(width, pass) == 0) 3624 continue; 3625 3626 startx = PNG_PASS_START_COL(pass) * outchannels; 3627 stepx = PNG_PASS_COL_OFFSET(pass) * outchannels; 3628 y = PNG_PASS_START_ROW(pass); 3629 stepy = PNG_PASS_ROW_OFFSET(pass); 3630 } 3631 3632 else 3633 { 3634 y = 0; 3635 startx = 0; 3636 stepx = outchannels; 3637 stepy = 1; 3638 } 3639 3640 for (; y<height; y += stepy) 3641 { 3642 png_const_uint_16p inrow; 3643 png_uint_16p outrow = first_row + y*step_row; 3644 png_uint_16p end_row = outrow + width * outchannels; 3645 3646 /* Read the row, which is packed: */ 3647 png_read_row(png_ptr, png_voidcast(png_bytep, 3648 display->local_row), NULL); 3649 inrow = png_voidcast(png_const_uint_16p, display->local_row); 3650 3651 /* Now do the pre-multiplication on each pixel in this row. 3652 */ 3653 outrow += startx; 3654 for (; outrow < end_row; outrow += stepx) 3655 { 3656 png_uint_32 component = inrow[0]; 3657 png_uint_16 alpha = inrow[1]; 3658 3659 if (alpha > 0) /* else 0 */ 3660 { 3661 if (alpha < 65535) /* else just use component */ 3662 { 3663 component *= alpha; 3664 component += 32767; 3665 component /= 65535; 3666 } 3667 } 3668 3669 else 3670 component = 0; 3671 3672 outrow[swap_alpha] = (png_uint_16)component; 3673 if (preserve_alpha != 0) 3674 outrow[1 ^ swap_alpha] = alpha; 3675 3676 inrow += 2; /* components and alpha channel */ 3677 } 3678 } 3679 } 3680 } 3681 break; 3682 3683 #ifdef __GNUC__ 3684 default: 3685 png_error(png_ptr, "unexpected bit depth"); 3686 #endif 3687 } 3688 3689 return 1; 3690 } 3691 3692 /* The guts of png_image_finish_read as a png_safe_execute callback. */ 3693 static int 3694 png_image_read_direct(png_voidp argument) 3695 { 3696 png_image_read_control *display = png_voidcast(png_image_read_control*, 3697 argument); 3698 png_imagep image = display->image; 3699 png_structrp png_ptr = image->opaque->png_ptr; 3700 png_inforp info_ptr = image->opaque->info_ptr; 3701 3702 png_uint_32 format = image->format; 3703 int linear = (format & PNG_FORMAT_FLAG_LINEAR) != 0; 3704 int do_local_compose = 0; 3705 int do_local_background = 0; /* to avoid double gamma correction bug */ 3706 int passes = 0; 3707 3708 /* Add transforms to ensure the correct output format is produced then check 3709 * that the required implementation support is there. Always expand; always 3710 * need 8 bits minimum, no palette and expanded tRNS. 3711 */ 3712 png_set_expand(png_ptr); 3713 3714 /* Now check the format to see if it was modified. */ 3715 { 3716 png_uint_32 base_format = png_image_format(png_ptr) & 3717 ~PNG_FORMAT_FLAG_COLORMAP /* removed by png_set_expand */; 3718 png_uint_32 change = format ^ base_format; 3719 png_fixed_point output_gamma; 3720 int mode; /* alpha mode */ 3721 3722 /* Do this first so that we have a record if rgb to gray is happening. */ 3723 if ((change & PNG_FORMAT_FLAG_COLOR) != 0) 3724 { 3725 /* gray<->color transformation required. */ 3726 if ((format & PNG_FORMAT_FLAG_COLOR) != 0) 3727 png_set_gray_to_rgb(png_ptr); 3728 3729 else 3730 { 3731 /* libpng can't do both rgb to gray and 3732 * background/pre-multiplication if there is also significant gamma 3733 * correction, because both operations require linear colors and 3734 * the code only supports one transform doing the gamma correction. 3735 * Handle this by doing the pre-multiplication or background 3736 * operation in this code, if necessary. 3737 * 3738 * TODO: fix this by rewriting pngrtran.c (!) 3739 * 3740 * For the moment (given that fixing this in pngrtran.c is an 3741 * enormous change) 'do_local_background' is used to indicate that 3742 * the problem exists. 3743 */ 3744 if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0) 3745 do_local_background = 1/*maybe*/; 3746 3747 png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, 3748 PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT); 3749 } 3750 3751 change &= ~PNG_FORMAT_FLAG_COLOR; 3752 } 3753 3754 /* Set the gamma appropriately, linear for 16-bit input, sRGB otherwise. 3755 */ 3756 { 3757 png_fixed_point input_gamma_default; 3758 3759 if ((base_format & PNG_FORMAT_FLAG_LINEAR) != 0 && 3760 (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0) 3761 input_gamma_default = PNG_GAMMA_LINEAR; 3762 else 3763 input_gamma_default = PNG_DEFAULT_sRGB; 3764 3765 /* Call png_set_alpha_mode to set the default for the input gamma; the 3766 * output gamma is set by a second call below. 3767 */ 3768 png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default); 3769 } 3770 3771 if (linear != 0) 3772 { 3773 /* If there *is* an alpha channel in the input it must be multiplied 3774 * out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG. 3775 */ 3776 if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0) 3777 mode = PNG_ALPHA_STANDARD; /* associated alpha */ 3778 3779 else 3780 mode = PNG_ALPHA_PNG; 3781 3782 output_gamma = PNG_GAMMA_LINEAR; 3783 } 3784 3785 else 3786 { 3787 mode = PNG_ALPHA_PNG; 3788 output_gamma = PNG_DEFAULT_sRGB; 3789 } 3790 3791 if ((change & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0) 3792 { 3793 mode = PNG_ALPHA_OPTIMIZED; 3794 change &= ~PNG_FORMAT_FLAG_ASSOCIATED_ALPHA; 3795 } 3796 3797 /* If 'do_local_background' is set check for the presence of gamma 3798 * correction; this is part of the work-round for the libpng bug 3799 * described above. 3800 * 3801 * TODO: fix libpng and remove this. 3802 */ 3803 if (do_local_background != 0) 3804 { 3805 png_fixed_point gtest; 3806 3807 /* This is 'png_gamma_threshold' from pngrtran.c; the test used for 3808 * gamma correction, the screen gamma hasn't been set on png_struct 3809 * yet; it's set below. png_struct::gamma, however, is set to the 3810 * final value. 3811 */ 3812 if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma, 3813 PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0) 3814 do_local_background = 0; 3815 3816 else if (mode == PNG_ALPHA_STANDARD) 3817 { 3818 do_local_background = 2/*required*/; 3819 mode = PNG_ALPHA_PNG; /* prevent libpng doing it */ 3820 } 3821 3822 /* else leave as 1 for the checks below */ 3823 } 3824 3825 /* If the bit-depth changes then handle that here. */ 3826 if ((change & PNG_FORMAT_FLAG_LINEAR) != 0) 3827 { 3828 if (linear != 0 /*16-bit output*/) 3829 png_set_expand_16(png_ptr); 3830 3831 else /* 8-bit output */ 3832 png_set_scale_16(png_ptr); 3833 3834 change &= ~PNG_FORMAT_FLAG_LINEAR; 3835 } 3836 3837 /* Now the background/alpha channel changes. */ 3838 if ((change & PNG_FORMAT_FLAG_ALPHA) != 0) 3839 { 3840 /* Removing an alpha channel requires composition for the 8-bit 3841 * formats; for the 16-bit it is already done, above, by the 3842 * pre-multiplication and the channel just needs to be stripped. 3843 */ 3844 if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0) 3845 { 3846 /* If RGB->gray is happening the alpha channel must be left and the 3847 * operation completed locally. 3848 * 3849 * TODO: fix libpng and remove this. 3850 */ 3851 if (do_local_background != 0) 3852 do_local_background = 2/*required*/; 3853 3854 /* 16-bit output: just remove the channel */ 3855 else if (linear != 0) /* compose on black (well, pre-multiply) */ 3856 png_set_strip_alpha(png_ptr); 3857 3858 /* 8-bit output: do an appropriate compose */ 3859 else if (display->background != NULL) 3860 { 3861 png_color_16 c; 3862 3863 c.index = 0; /*unused*/ 3864 c.red = display->background->red; 3865 c.green = display->background->green; 3866 c.blue = display->background->blue; 3867 c.gray = display->background->green; 3868 3869 /* This is always an 8-bit sRGB value, using the 'green' channel 3870 * for gray is much better than calculating the luminance here; 3871 * we can get off-by-one errors in that calculation relative to 3872 * the app expectations and that will show up in transparent 3873 * pixels. 3874 */ 3875 png_set_background_fixed(png_ptr, &c, 3876 PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, 3877 0/*gamma: not used*/); 3878 } 3879 3880 else /* compose on row: implemented below. */ 3881 { 3882 do_local_compose = 1; 3883 /* This leaves the alpha channel in the output, so it has to be 3884 * removed by the code below. Set the encoding to the 'OPTIMIZE' 3885 * one so the code only has to hack on the pixels that require 3886 * composition. 3887 */ 3888 mode = PNG_ALPHA_OPTIMIZED; 3889 } 3890 } 3891 3892 else /* output needs an alpha channel */ 3893 { 3894 /* This is tricky because it happens before the swap operation has 3895 * been accomplished; however, the swap does *not* swap the added 3896 * alpha channel (weird API), so it must be added in the correct 3897 * place. 3898 */ 3899 png_uint_32 filler; /* opaque filler */ 3900 int where; 3901 3902 if (linear != 0) 3903 filler = 65535; 3904 3905 else 3906 filler = 255; 3907 3908 #ifdef PNG_FORMAT_AFIRST_SUPPORTED 3909 if ((format & PNG_FORMAT_FLAG_AFIRST) != 0) 3910 { 3911 where = PNG_FILLER_BEFORE; 3912 change &= ~PNG_FORMAT_FLAG_AFIRST; 3913 } 3914 3915 else 3916 #endif 3917 where = PNG_FILLER_AFTER; 3918 3919 png_set_add_alpha(png_ptr, filler, where); 3920 } 3921 3922 /* This stops the (irrelevant) call to swap_alpha below. */ 3923 change &= ~PNG_FORMAT_FLAG_ALPHA; 3924 } 3925 3926 /* Now set the alpha mode correctly; this is always done, even if there is 3927 * no alpha channel in either the input or the output because it correctly 3928 * sets the output gamma. 3929 */ 3930 png_set_alpha_mode_fixed(png_ptr, mode, output_gamma); 3931 3932 # ifdef PNG_FORMAT_BGR_SUPPORTED 3933 if ((change & PNG_FORMAT_FLAG_BGR) != 0) 3934 { 3935 /* Check only the output format; PNG is never BGR; don't do this if 3936 * the output is gray, but fix up the 'format' value in that case. 3937 */ 3938 if ((format & PNG_FORMAT_FLAG_COLOR) != 0) 3939 png_set_bgr(png_ptr); 3940 3941 else 3942 format &= ~PNG_FORMAT_FLAG_BGR; 3943 3944 change &= ~PNG_FORMAT_FLAG_BGR; 3945 } 3946 # endif 3947 3948 # ifdef PNG_FORMAT_AFIRST_SUPPORTED 3949 if ((change & PNG_FORMAT_FLAG_AFIRST) != 0) 3950 { 3951 /* Only relevant if there is an alpha channel - it's particularly 3952 * important to handle this correctly because do_local_compose may 3953 * be set above and then libpng will keep the alpha channel for this 3954 * code to remove. 3955 */ 3956 if ((format & PNG_FORMAT_FLAG_ALPHA) != 0) 3957 { 3958 /* Disable this if doing a local background, 3959 * TODO: remove this when local background is no longer required. 3960 */ 3961 if (do_local_background != 2) 3962 png_set_swap_alpha(png_ptr); 3963 } 3964 3965 else 3966 format &= ~PNG_FORMAT_FLAG_AFIRST; 3967 3968 change &= ~PNG_FORMAT_FLAG_AFIRST; 3969 } 3970 # endif 3971 3972 /* If the *output* is 16-bit then we need to check for a byte-swap on this 3973 * architecture. 3974 */ 3975 if (linear != 0) 3976 { 3977 PNG_CONST png_uint_16 le = 0x0001; 3978 3979 if ((*(png_const_bytep) & le) != 0) 3980 png_set_swap(png_ptr); 3981 } 3982 3983 /* If change is not now 0 some transformation is missing - error out. */ 3984 if (change != 0) 3985 png_error(png_ptr, "png_read_image: unsupported transformation"); 3986 } 3987 3988 PNG_SKIP_CHUNKS(png_ptr); 3989 3990 /* Update the 'info' structure and make sure the result is as required; first 3991 * make sure to turn on the interlace handling if it will be required 3992 * (because it can't be turned on *after* the call to png_read_update_info!) 3993 * 3994 * TODO: remove the do_local_background fixup below. 3995 */ 3996 if (do_local_compose == 0 && do_local_background != 2) 3997 passes = png_set_interlace_handling(png_ptr); 3998 3999 png_read_update_info(png_ptr, info_ptr); 4000 4001 { 4002 png_uint_32 info_format = 0; 4003 4004 if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) 4005 info_format |= PNG_FORMAT_FLAG_COLOR; 4006 4007 if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0) 4008 { 4009 /* do_local_compose removes this channel below. */ 4010 if (do_local_compose == 0) 4011 { 4012 /* do_local_background does the same if required. */ 4013 if (do_local_background != 2 || 4014 (format & PNG_FORMAT_FLAG_ALPHA) != 0) 4015 info_format |= PNG_FORMAT_FLAG_ALPHA; 4016 } 4017 } 4018 4019 else if (do_local_compose != 0) /* internal error */ 4020 png_error(png_ptr, "png_image_read: alpha channel lost"); 4021 4022 if ((format & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0) { 4023 info_format |= PNG_FORMAT_FLAG_ASSOCIATED_ALPHA; 4024 } 4025 4026 if (info_ptr->bit_depth == 16) 4027 info_format |= PNG_FORMAT_FLAG_LINEAR; 4028 4029 #ifdef PNG_FORMAT_BGR_SUPPORTED 4030 if ((png_ptr->transformations & PNG_BGR) != 0) 4031 info_format |= PNG_FORMAT_FLAG_BGR; 4032 #endif 4033 4034 #ifdef PNG_FORMAT_AFIRST_SUPPORTED 4035 if (do_local_background == 2) 4036 { 4037 if ((format & PNG_FORMAT_FLAG_AFIRST) != 0) 4038 info_format |= PNG_FORMAT_FLAG_AFIRST; 4039 } 4040 4041 if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 || 4042 ((png_ptr->transformations & PNG_ADD_ALPHA) != 0 && 4043 (png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0)) 4044 { 4045 if (do_local_background == 2) 4046 png_error(png_ptr, "unexpected alpha swap transformation"); 4047 4048 info_format |= PNG_FORMAT_FLAG_AFIRST; 4049 } 4050 # endif 4051 4052 /* This is actually an internal error. */ 4053 if (info_format != format) 4054 png_error(png_ptr, "png_read_image: invalid transformations"); 4055 } 4056 4057 /* Now read the rows. If do_local_compose is set then it is necessary to use 4058 * a local row buffer. The output will be GA, RGBA or BGRA and must be 4059 * converted to G, RGB or BGR as appropriate. The 'local_row' member of the 4060 * display acts as a flag. 4061 */ 4062 { 4063 png_voidp first_row = display->buffer; 4064 ptrdiff_t row_bytes = display->row_stride; 4065 4066 if (linear != 0) 4067 row_bytes *= 2; 4068 4069 /* The following expression is designed to work correctly whether it gives 4070 * a signed or an unsigned result. 4071 */ 4072 if (row_bytes < 0) 4073 { 4074 char *ptr = png_voidcast(char*, first_row); 4075 ptr += (image->height-1) * (-row_bytes); 4076 first_row = png_voidcast(png_voidp, ptr); 4077 } 4078 4079 display->first_row = first_row; 4080 display->row_bytes = row_bytes; 4081 } 4082 4083 if (do_local_compose != 0) 4084 { 4085 int result; 4086 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); 4087 4088 display->local_row = row; 4089 result = png_safe_execute(image, png_image_read_composite, display); 4090 display->local_row = NULL; 4091 png_free(png_ptr, row); 4092 4093 return result; 4094 } 4095 4096 else if (do_local_background == 2) 4097 { 4098 int result; 4099 png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); 4100 4101 display->local_row = row; 4102 result = png_safe_execute(image, png_image_read_background, display); 4103 display->local_row = NULL; 4104 png_free(png_ptr, row); 4105 4106 return result; 4107 } 4108 4109 else 4110 { 4111 png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes; 4112 4113 while (--passes >= 0) 4114 { 4115 png_uint_32 y = image->height; 4116 png_bytep row = png_voidcast(png_bytep, display->first_row); 4117 4118 for (; y > 0; --y) 4119 { 4120 png_read_row(png_ptr, row, NULL); 4121 row += row_bytes; 4122 } 4123 } 4124 4125 return 1; 4126 } 4127 } 4128 4129 int PNGAPI 4130 png_image_finish_read(png_imagep image, png_const_colorp background, 4131 void *buffer, png_int_32 row_stride, void *colormap) 4132 { 4133 if (image != NULL && image->version == PNG_IMAGE_VERSION) 4134 { 4135 /* Check for row_stride overflow. This check is not performed on the 4136 * original PNG format because it may not occur in the output PNG format 4137 * and libpng deals with the issues of reading the original. 4138 */ 4139 const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format); 4140 4141 /* The following checks just the 'row_stride' calculation to ensure it 4142 * fits in a signed 32-bit value. Because channels/components can be 4143 * either 1 or 2 bytes in size the length of a row can still overflow 32 4144 * bits; this is just to verify that the 'row_stride' argument can be 4145 * represented. 4146 */ 4147 if (image->width <= 0x7fffffffU/channels) /* no overflow */ 4148 { 4149 png_uint_32 check; 4150 const png_uint_32 png_row_stride = image->width * channels; 4151 4152 if (row_stride == 0) 4153 row_stride = (png_int_32)/*SAFE*/png_row_stride; 4154 4155 if (row_stride < 0) 4156 check = (png_uint_32)(-row_stride); 4157 4158 else 4159 check = (png_uint_32)row_stride; 4160 4161 /* This verifies 'check', the absolute value of the actual stride 4162 * passed in and detects overflow in the application calculation (i.e. 4163 * if the app did actually pass in a non-zero 'row_stride'. 4164 */ 4165 if (image->opaque != NULL && buffer != NULL && check >= png_row_stride) 4166 { 4167 /* Now check for overflow of the image buffer calculation; this 4168 * limits the whole image size to 32 bits for API compatibility with 4169 * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro. 4170 * 4171 * The PNG_IMAGE_BUFFER_SIZE macro is: 4172 * 4173 * (PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)*height*(row_stride)) 4174 * 4175 * And the component size is always 1 or 2, so make sure that the 4176 * number of *bytes* that the application is saying are available 4177 * does actually fit into a 32-bit number. 4178 * 4179 * NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE 4180 * will be changed to use png_alloc_size_t; bigger images can be 4181 * accommodated on 64-bit systems. 4182 */ 4183 if (image->height <= 4184 0xffffffffU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check) 4185 { 4186 if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 || 4187 (image->colormap_entries > 0 && colormap != NULL)) 4188 { 4189 int result; 4190 png_image_read_control display; 4191 4192 memset(&display, 0, (sizeof display)); 4193 display.image = image; 4194 display.buffer = buffer; 4195 display.row_stride = row_stride; 4196 display.colormap = colormap; 4197 display.background = background; 4198 display.local_row = NULL; 4199 4200 /* Choose the correct 'end' routine; for the color-map case 4201 * all the setup has already been done. 4202 */ 4203 if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0) 4204 result = 4205 png_safe_execute(image, 4206 png_image_read_colormap, &display) && 4207 png_safe_execute(image, 4208 png_image_read_colormapped, &display); 4209 4210 else 4211 result = 4212 png_safe_execute(image, 4213 png_image_read_direct, &display); 4214 4215 png_image_free(image); 4216 return result; 4217 } 4218 4219 else 4220 return png_image_error(image, 4221 "png_image_finish_read[color-map]: no color-map"); 4222 } 4223 4224 else 4225 return png_image_error(image, 4226 "png_image_finish_read: image too large"); 4227 } 4228 4229 else 4230 return png_image_error(image, 4231 "png_image_finish_read: invalid argument"); 4232 } 4233 4234 else 4235 return png_image_error(image, 4236 "png_image_finish_read: row_stride too large"); 4237 } 4238 4239 else if (image != NULL) 4240 return png_image_error(image, 4241 "png_image_finish_read: damaged PNG_IMAGE_VERSION"); 4242 4243 return 0; 4244 } 4245 4246 #endif /* SIMPLIFIED_READ */ 4247 #endif /* READ */