1 2 /* png.c - location for general purpose libpng functions 3 * 4 * Last changed in libpng 1.6.19 [November 12, 2015] 5 * Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson 6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) 7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) 8 * 9 * This code is released under the libpng license. 10 * For conditions of distribution and use, see the disclaimer 11 * and license in png.h 12 */ 13 14 #include "pngpriv.h" 15 16 /* Generate a compiler error if there is an old png.h in the search path. */ 17 typedef png_libpng_version_1_6_22 Your_png_h_is_not_version_1_6_22; 18 19 /* Tells libpng that we have already handled the first "num_bytes" bytes 20 * of the PNG file signature. If the PNG data is embedded into another 21 * stream we can set num_bytes = 8 so that libpng will not attempt to read 22 * or write any of the magic bytes before it starts on the IHDR. 23 */ 24 25 #ifdef PNG_READ_SUPPORTED 26 void PNGAPI 27 png_set_sig_bytes(png_structrp png_ptr, int num_bytes) 28 { 29 unsigned int nb = (unsigned int)num_bytes; 30 31 png_debug(1, "in png_set_sig_bytes"); 32 33 if (png_ptr == NULL) 34 return; 35 36 if (num_bytes < 0) 37 nb = 0; 38 39 if (nb > 8) 40 png_error(png_ptr, "Too many bytes for PNG signature"); 41 42 png_ptr->sig_bytes = (png_byte)nb; 43 } 44 45 /* Checks whether the supplied bytes match the PNG signature. We allow 46 * checking less than the full 8-byte signature so that those apps that 47 * already read the first few bytes of a file to determine the file type 48 * can simply check the remaining bytes for extra assurance. Returns 49 * an integer less than, equal to, or greater than zero if sig is found, 50 * respectively, to be less than, to match, or be greater than the correct 51 * PNG signature (this is the same behavior as strcmp, memcmp, etc). 52 */ 53 int PNGAPI 54 png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check) 55 { 56 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; 57 58 if (num_to_check > 8) 59 num_to_check = 8; 60 61 else if (num_to_check < 1) 62 return (-1); 63 64 if (start > 7) 65 return (-1); 66 67 if (start + num_to_check > 8) 68 num_to_check = 8 - start; 69 70 return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check))); 71 } 72 73 #endif /* READ */ 74 75 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) 76 /* Function to allocate memory for zlib */ 77 PNG_FUNCTION(voidpf /* PRIVATE */, 78 png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED) 79 { 80 png_alloc_size_t num_bytes = size; 81 82 if (png_ptr == NULL) 83 return NULL; 84 85 if (items >= (~(png_alloc_size_t)0)/size) 86 { 87 png_warning (png_voidcast(png_structrp, png_ptr), 88 "Potential overflow in png_zalloc()"); 89 return NULL; 90 } 91 92 num_bytes *= items; 93 return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes); 94 } 95 96 /* Function to free memory for zlib */ 97 void /* PRIVATE */ 98 png_zfree(voidpf png_ptr, voidpf ptr) 99 { 100 png_free(png_voidcast(png_const_structrp,png_ptr), ptr); 101 } 102 103 /* Reset the CRC variable to 32 bits of 1's. Care must be taken 104 * in case CRC is > 32 bits to leave the top bits 0. 105 */ 106 void /* PRIVATE */ 107 png_reset_crc(png_structrp png_ptr) 108 { 109 /* The cast is safe because the crc is a 32-bit value. */ 110 png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0); 111 } 112 113 /* Calculate the CRC over a section of data. We can only pass as 114 * much data to this routine as the largest single buffer size. We 115 * also check that this data will actually be used before going to the 116 * trouble of calculating it. 117 */ 118 void /* PRIVATE */ 119 png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length) 120 { 121 int need_crc = 1; 122 123 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0) 124 { 125 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == 126 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) 127 need_crc = 0; 128 } 129 130 else /* critical */ 131 { 132 if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0) 133 need_crc = 0; 134 } 135 136 /* 'uLong' is defined in zlib.h as unsigned long; this means that on some 137 * systems it is a 64-bit value. crc32, however, returns 32 bits so the 138 * following cast is safe. 'uInt' may be no more than 16 bits, so it is 139 * necessary to perform a loop here. 140 */ 141 if (need_crc != 0 && length > 0) 142 { 143 uLong crc = png_ptr->crc; /* Should never issue a warning */ 144 145 do 146 { 147 uInt safe_length = (uInt)length; 148 #ifndef __COVERITY__ 149 if (safe_length == 0) 150 safe_length = (uInt)-1; /* evil, but safe */ 151 #endif 152 153 crc = crc32(crc, ptr, safe_length); 154 155 /* The following should never issue compiler warnings; if they do the 156 * target system has characteristics that will probably violate other 157 * assumptions within the libpng code. 158 */ 159 ptr += safe_length; 160 length -= safe_length; 161 } 162 while (length > 0); 163 164 /* And the following is always safe because the crc is only 32 bits. */ 165 png_ptr->crc = (png_uint_32)crc; 166 } 167 } 168 169 /* Check a user supplied version number, called from both read and write 170 * functions that create a png_struct. 171 */ 172 int 173 png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver) 174 { 175 /* Libpng versions 1.0.0 and later are binary compatible if the version 176 * string matches through the second '.'; we must recompile any 177 * applications that use any older library version. 178 */ 179 180 if (user_png_ver != NULL) 181 { 182 int i = -1; 183 int found_dots = 0; 184 185 do 186 { 187 i++; 188 if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i]) 189 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 190 if (user_png_ver[i] == '.') 191 found_dots++; 192 } while (found_dots < 2 && user_png_ver[i] != 0 && 193 PNG_LIBPNG_VER_STRING[i] != 0); 194 } 195 196 else 197 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; 198 199 if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0) 200 { 201 #ifdef PNG_WARNINGS_SUPPORTED 202 size_t pos = 0; 203 char m[128]; 204 205 pos = png_safecat(m, (sizeof m), pos, 206 "Application built with libpng-"); 207 pos = png_safecat(m, (sizeof m), pos, user_png_ver); 208 pos = png_safecat(m, (sizeof m), pos, " but running with "); 209 pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING); 210 PNG_UNUSED(pos) 211 212 png_warning(png_ptr, m); 213 #endif 214 215 #ifdef PNG_ERROR_NUMBERS_SUPPORTED 216 png_ptr->flags = 0; 217 #endif 218 219 return 0; 220 } 221 222 /* Success return. */ 223 return 1; 224 } 225 226 /* Generic function to create a png_struct for either read or write - this 227 * contains the common initialization. 228 */ 229 PNG_FUNCTION(png_structp /* PRIVATE */, 230 png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr, 231 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, 232 png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) 233 { 234 png_struct create_struct; 235 # ifdef PNG_SETJMP_SUPPORTED 236 jmp_buf create_jmp_buf; 237 # endif 238 239 /* This temporary stack-allocated structure is used to provide a place to 240 * build enough context to allow the user provided memory allocator (if any) 241 * to be called. 242 */ 243 memset(&create_struct, 0, (sizeof create_struct)); 244 245 /* Added at libpng-1.2.6 */ 246 # ifdef PNG_USER_LIMITS_SUPPORTED 247 create_struct.user_width_max = PNG_USER_WIDTH_MAX; 248 create_struct.user_height_max = PNG_USER_HEIGHT_MAX; 249 250 # ifdef PNG_USER_CHUNK_CACHE_MAX 251 /* Added at libpng-1.2.43 and 1.4.0 */ 252 create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; 253 # endif 254 255 # ifdef PNG_USER_CHUNK_MALLOC_MAX 256 /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists 257 * in png_struct regardless. 258 */ 259 create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; 260 # endif 261 # endif 262 263 /* The following two API calls simply set fields in png_struct, so it is safe 264 * to do them now even though error handling is not yet set up. 265 */ 266 # ifdef PNG_USER_MEM_SUPPORTED 267 png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn); 268 # else 269 PNG_UNUSED(mem_ptr) 270 PNG_UNUSED(malloc_fn) 271 PNG_UNUSED(free_fn) 272 # endif 273 274 /* (*error_fn) can return control to the caller after the error_ptr is set, 275 * this will result in a memory leak unless the error_fn does something 276 * extremely sophisticated. The design lacks merit but is implicit in the 277 * API. 278 */ 279 png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn); 280 281 # ifdef PNG_SETJMP_SUPPORTED 282 if (!setjmp(create_jmp_buf)) 283 # endif 284 { 285 # ifdef PNG_SETJMP_SUPPORTED 286 /* Temporarily fake out the longjmp information until we have 287 * successfully completed this function. This only works if we have 288 * setjmp() support compiled in, but it is safe - this stuff should 289 * never happen. 290 */ 291 create_struct.jmp_buf_ptr = &create_jmp_buf; 292 create_struct.jmp_buf_size = 0; /*stack allocation*/ 293 create_struct.longjmp_fn = longjmp; 294 # endif 295 /* Call the general version checker (shared with read and write code): 296 */ 297 if (png_user_version_check(&create_struct, user_png_ver) != 0) 298 { 299 png_structrp png_ptr = png_voidcast(png_structrp, 300 png_malloc_warn(&create_struct, (sizeof *png_ptr))); 301 302 if (png_ptr != NULL) 303 { 304 /* png_ptr->zstream holds a back-pointer to the png_struct, so 305 * this can only be done now: 306 */ 307 create_struct.zstream.zalloc = png_zalloc; 308 create_struct.zstream.zfree = png_zfree; 309 create_struct.zstream.opaque = png_ptr; 310 311 # ifdef PNG_SETJMP_SUPPORTED 312 /* Eliminate the local error handling: */ 313 create_struct.jmp_buf_ptr = NULL; 314 create_struct.jmp_buf_size = 0; 315 create_struct.longjmp_fn = 0; 316 # endif 317 318 *png_ptr = create_struct; 319 320 /* This is the successful return point */ 321 return png_ptr; 322 } 323 } 324 } 325 326 /* A longjmp because of a bug in the application storage allocator or a 327 * simple failure to allocate the png_struct. 328 */ 329 return NULL; 330 } 331 332 /* Allocate the memory for an info_struct for the application. */ 333 PNG_FUNCTION(png_infop,PNGAPI 334 png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED) 335 { 336 png_inforp info_ptr; 337 338 png_debug(1, "in png_create_info_struct"); 339 340 if (png_ptr == NULL) 341 return NULL; 342 343 /* Use the internal API that does not (or at least should not) error out, so 344 * that this call always returns ok. The application typically sets up the 345 * error handling *after* creating the info_struct because this is the way it 346 * has always been done in 'example.c'. 347 */ 348 info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr, 349 (sizeof *info_ptr))); 350 351 if (info_ptr != NULL) 352 memset(info_ptr, 0, (sizeof *info_ptr)); 353 354 return info_ptr; 355 } 356 357 /* This function frees the memory associated with a single info struct. 358 * Normally, one would use either png_destroy_read_struct() or 359 * png_destroy_write_struct() to free an info struct, but this may be 360 * useful for some applications. From libpng 1.6.0 this function is also used 361 * internally to implement the png_info release part of the 'struct' destroy 362 * APIs. This ensures that all possible approaches free the same data (all of 363 * it). 364 */ 365 void PNGAPI 366 png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr) 367 { 368 png_inforp info_ptr = NULL; 369 370 png_debug(1, "in png_destroy_info_struct"); 371 372 if (png_ptr == NULL) 373 return; 374 375 if (info_ptr_ptr != NULL) 376 info_ptr = *info_ptr_ptr; 377 378 if (info_ptr != NULL) 379 { 380 /* Do this first in case of an error below; if the app implements its own 381 * memory management this can lead to png_free calling png_error, which 382 * will abort this routine and return control to the app error handler. 383 * An infinite loop may result if it then tries to free the same info 384 * ptr. 385 */ 386 *info_ptr_ptr = NULL; 387 388 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); 389 memset(info_ptr, 0, (sizeof *info_ptr)); 390 png_free(png_ptr, info_ptr); 391 } 392 } 393 394 /* Initialize the info structure. This is now an internal function (0.89) 395 * and applications using it are urged to use png_create_info_struct() 396 * instead. Use deprecated in 1.6.0, internal use removed (used internally it 397 * is just a memset). 398 * 399 * NOTE: it is almost inconceivable that this API is used because it bypasses 400 * the user-memory mechanism and the user error handling/warning mechanisms in 401 * those cases where it does anything other than a memset. 402 */ 403 PNG_FUNCTION(void,PNGAPI 404 png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size), 405 PNG_DEPRECATED) 406 { 407 png_inforp info_ptr = *ptr_ptr; 408 409 png_debug(1, "in png_info_init_3"); 410 411 if (info_ptr == NULL) 412 return; 413 414 if ((sizeof (png_info)) > png_info_struct_size) 415 { 416 *ptr_ptr = NULL; 417 /* The following line is why this API should not be used: */ 418 free(info_ptr); 419 info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL, 420 (sizeof *info_ptr))); 421 if (info_ptr == NULL) 422 return; 423 *ptr_ptr = info_ptr; 424 } 425 426 /* Set everything to 0 */ 427 memset(info_ptr, 0, (sizeof *info_ptr)); 428 } 429 430 /* The following API is not called internally */ 431 void PNGAPI 432 png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr, 433 int freer, png_uint_32 mask) 434 { 435 png_debug(1, "in png_data_freer"); 436 437 if (png_ptr == NULL || info_ptr == NULL) 438 return; 439 440 if (freer == PNG_DESTROY_WILL_FREE_DATA) 441 info_ptr->free_me |= mask; 442 443 else if (freer == PNG_USER_WILL_FREE_DATA) 444 info_ptr->free_me &= ~mask; 445 446 else 447 png_error(png_ptr, "Unknown freer parameter in png_data_freer"); 448 } 449 450 void PNGAPI 451 png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask, 452 int num) 453 { 454 png_debug(1, "in png_free_data"); 455 456 if (png_ptr == NULL || info_ptr == NULL) 457 return; 458 459 #ifdef PNG_TEXT_SUPPORTED 460 /* Free text item num or (if num == -1) all text items */ 461 if (info_ptr->text != 0 && 462 ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0) 463 { 464 if (num != -1) 465 { 466 png_free(png_ptr, info_ptr->text[num].key); 467 info_ptr->text[num].key = NULL; 468 } 469 470 else 471 { 472 int i; 473 474 for (i = 0; i < info_ptr->num_text; i++) 475 png_free(png_ptr, info_ptr->text[i].key); 476 477 png_free(png_ptr, info_ptr->text); 478 info_ptr->text = NULL; 479 info_ptr->num_text = 0; 480 } 481 } 482 #endif 483 484 #ifdef PNG_tRNS_SUPPORTED 485 /* Free any tRNS entry */ 486 if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0) 487 { 488 info_ptr->valid &= ~PNG_INFO_tRNS; 489 png_free(png_ptr, info_ptr->trans_alpha); 490 info_ptr->trans_alpha = NULL; 491 info_ptr->num_trans = 0; 492 } 493 #endif 494 495 #ifdef PNG_sCAL_SUPPORTED 496 /* Free any sCAL entry */ 497 if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0) 498 { 499 png_free(png_ptr, info_ptr->scal_s_width); 500 png_free(png_ptr, info_ptr->scal_s_height); 501 info_ptr->scal_s_width = NULL; 502 info_ptr->scal_s_height = NULL; 503 info_ptr->valid &= ~PNG_INFO_sCAL; 504 } 505 #endif 506 507 #ifdef PNG_pCAL_SUPPORTED 508 /* Free any pCAL entry */ 509 if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0) 510 { 511 png_free(png_ptr, info_ptr->pcal_purpose); 512 png_free(png_ptr, info_ptr->pcal_units); 513 info_ptr->pcal_purpose = NULL; 514 info_ptr->pcal_units = NULL; 515 516 if (info_ptr->pcal_params != NULL) 517 { 518 int i; 519 520 for (i = 0; i < info_ptr->pcal_nparams; i++) 521 png_free(png_ptr, info_ptr->pcal_params[i]); 522 523 png_free(png_ptr, info_ptr->pcal_params); 524 info_ptr->pcal_params = NULL; 525 } 526 info_ptr->valid &= ~PNG_INFO_pCAL; 527 } 528 #endif 529 530 #ifdef PNG_iCCP_SUPPORTED 531 /* Free any profile entry */ 532 if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0) 533 { 534 png_free(png_ptr, info_ptr->iccp_name); 535 png_free(png_ptr, info_ptr->iccp_profile); 536 info_ptr->iccp_name = NULL; 537 info_ptr->iccp_profile = NULL; 538 info_ptr->valid &= ~PNG_INFO_iCCP; 539 } 540 #endif 541 542 #ifdef PNG_sPLT_SUPPORTED 543 /* Free a given sPLT entry, or (if num == -1) all sPLT entries */ 544 if (info_ptr->splt_palettes != 0 && 545 ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0) 546 { 547 if (num != -1) 548 { 549 png_free(png_ptr, info_ptr->splt_palettes[num].name); 550 png_free(png_ptr, info_ptr->splt_palettes[num].entries); 551 info_ptr->splt_palettes[num].name = NULL; 552 info_ptr->splt_palettes[num].entries = NULL; 553 } 554 555 else 556 { 557 int i; 558 559 for (i = 0; i < info_ptr->splt_palettes_num; i++) 560 { 561 png_free(png_ptr, info_ptr->splt_palettes[i].name); 562 png_free(png_ptr, info_ptr->splt_palettes[i].entries); 563 } 564 565 png_free(png_ptr, info_ptr->splt_palettes); 566 info_ptr->splt_palettes = NULL; 567 info_ptr->splt_palettes_num = 0; 568 info_ptr->valid &= ~PNG_INFO_sPLT; 569 } 570 } 571 #endif 572 573 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED 574 if (info_ptr->unknown_chunks != 0 && 575 ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0) 576 { 577 if (num != -1) 578 { 579 png_free(png_ptr, info_ptr->unknown_chunks[num].data); 580 info_ptr->unknown_chunks[num].data = NULL; 581 } 582 583 else 584 { 585 int i; 586 587 for (i = 0; i < info_ptr->unknown_chunks_num; i++) 588 png_free(png_ptr, info_ptr->unknown_chunks[i].data); 589 590 png_free(png_ptr, info_ptr->unknown_chunks); 591 info_ptr->unknown_chunks = NULL; 592 info_ptr->unknown_chunks_num = 0; 593 } 594 } 595 #endif 596 597 #ifdef PNG_hIST_SUPPORTED 598 /* Free any hIST entry */ 599 if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0) 600 { 601 png_free(png_ptr, info_ptr->hist); 602 info_ptr->hist = NULL; 603 info_ptr->valid &= ~PNG_INFO_hIST; 604 } 605 #endif 606 607 /* Free any PLTE entry that was internally allocated */ 608 if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0) 609 { 610 png_free(png_ptr, info_ptr->palette); 611 info_ptr->palette = NULL; 612 info_ptr->valid &= ~PNG_INFO_PLTE; 613 info_ptr->num_palette = 0; 614 } 615 616 #ifdef PNG_INFO_IMAGE_SUPPORTED 617 /* Free any image bits attached to the info structure */ 618 if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0) 619 { 620 if (info_ptr->row_pointers != 0) 621 { 622 png_uint_32 row; 623 for (row = 0; row < info_ptr->height; row++) 624 png_free(png_ptr, info_ptr->row_pointers[row]); 625 626 png_free(png_ptr, info_ptr->row_pointers); 627 info_ptr->row_pointers = NULL; 628 } 629 info_ptr->valid &= ~PNG_INFO_IDAT; 630 } 631 #endif 632 633 if (num != -1) 634 mask &= ~PNG_FREE_MUL; 635 636 info_ptr->free_me &= ~mask; 637 } 638 #endif /* READ || WRITE */ 639 640 /* This function returns a pointer to the io_ptr associated with the user 641 * functions. The application should free any memory associated with this 642 * pointer before png_write_destroy() or png_read_destroy() are called. 643 */ 644 png_voidp PNGAPI 645 png_get_io_ptr(png_const_structrp png_ptr) 646 { 647 if (png_ptr == NULL) 648 return (NULL); 649 650 return (png_ptr->io_ptr); 651 } 652 653 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) 654 # ifdef PNG_STDIO_SUPPORTED 655 /* Initialize the default input/output functions for the PNG file. If you 656 * use your own read or write routines, you can call either png_set_read_fn() 657 * or png_set_write_fn() instead of png_init_io(). If you have defined 658 * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a 659 * function of your own because "FILE *" isn't necessarily available. 660 */ 661 void PNGAPI 662 png_init_io(png_structrp png_ptr, png_FILE_p fp) 663 { 664 png_debug(1, "in png_init_io"); 665 666 if (png_ptr == NULL) 667 return; 668 669 png_ptr->io_ptr = (png_voidp)fp; 670 } 671 # endif 672 673 # ifdef PNG_SAVE_INT_32_SUPPORTED 674 /* PNG signed integers are saved in 32-bit 2's complement format. ANSI C-90 675 * defines a cast of a signed integer to an unsigned integer either to preserve 676 * the value, if it is positive, or to calculate: 677 * 678 * (UNSIGNED_MAX+1) + integer 679 * 680 * Where UNSIGNED_MAX is the appropriate maximum unsigned value, so when the 681 * negative integral value is added the result will be an unsigned value 682 * correspnding to the 2's complement representation. 683 */ 684 void PNGAPI 685 png_save_int_32(png_bytep buf, png_int_32 i) 686 { 687 png_save_uint_32(buf, i); 688 } 689 # endif 690 691 # ifdef PNG_TIME_RFC1123_SUPPORTED 692 /* Convert the supplied time into an RFC 1123 string suitable for use in 693 * a "Creation Time" or other text-based time string. 694 */ 695 int PNGAPI 696 png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime) 697 { 698 static PNG_CONST char short_months[12][4] = 699 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", 700 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; 701 702 if (out == NULL) 703 return 0; 704 705 if (ptime->year > 9999 /* RFC1123 limitation */ || 706 ptime->month == 0 || ptime->month > 12 || 707 ptime->day == 0 || ptime->day > 31 || 708 ptime->hour > 23 || ptime->minute > 59 || 709 ptime->second > 60) 710 return 0; 711 712 { 713 size_t pos = 0; 714 char number_buf[5]; /* enough for a four-digit year */ 715 716 # define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string)) 717 # define APPEND_NUMBER(format, value)\ 718 APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value))) 719 # define APPEND(ch) if (pos < 28) out[pos++] = (ch) 720 721 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day); 722 APPEND(' '); 723 APPEND_STRING(short_months[(ptime->month - 1)]); 724 APPEND(' '); 725 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year); 726 APPEND(' '); 727 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour); 728 APPEND(':'); 729 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute); 730 APPEND(':'); 731 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second); 732 APPEND_STRING(" +0000"); /* This reliably terminates the buffer */ 733 PNG_UNUSED (pos) 734 735 # undef APPEND 736 # undef APPEND_NUMBER 737 # undef APPEND_STRING 738 } 739 740 return 1; 741 } 742 743 # if PNG_LIBPNG_VER < 10700 744 /* To do: remove the following from libpng-1.7 */ 745 /* Original API that uses a private buffer in png_struct. 746 * Deprecated because it causes png_struct to carry a spurious temporary 747 * buffer (png_struct::time_buffer), better to have the caller pass this in. 748 */ 749 png_const_charp PNGAPI 750 png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime) 751 { 752 if (png_ptr != NULL) 753 { 754 /* The only failure above if png_ptr != NULL is from an invalid ptime */ 755 if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0) 756 png_warning(png_ptr, "Ignoring invalid time value"); 757 758 else 759 return png_ptr->time_buffer; 760 } 761 762 return NULL; 763 } 764 # endif /* LIBPNG_VER < 10700 */ 765 # endif /* TIME_RFC1123 */ 766 767 #endif /* READ || WRITE */ 768 769 png_const_charp PNGAPI 770 png_get_copyright(png_const_structrp png_ptr) 771 { 772 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ 773 #ifdef PNG_STRING_COPYRIGHT 774 return PNG_STRING_COPYRIGHT 775 #else 776 # ifdef __STDC__ 777 return PNG_STRING_NEWLINE \ 778 "libpng version 1.6.22 - May 26, 2016" PNG_STRING_NEWLINE \ 779 "Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson" \ 780 PNG_STRING_NEWLINE \ 781 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ 782 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ 783 PNG_STRING_NEWLINE; 784 # else 785 return "libpng version 1.6.22 - May 26, 2016\ 786 Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson\ 787 Copyright (c) 1996-1997 Andreas Dilger\ 788 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; 789 # endif 790 #endif 791 } 792 793 /* The following return the library version as a short string in the 794 * format 1.0.0 through 99.99.99zz. To get the version of *.h files 795 * used with your application, print out PNG_LIBPNG_VER_STRING, which 796 * is defined in png.h. 797 * Note: now there is no difference between png_get_libpng_ver() and 798 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, 799 * it is guaranteed that png.c uses the correct version of png.h. 800 */ 801 png_const_charp PNGAPI 802 png_get_libpng_ver(png_const_structrp png_ptr) 803 { 804 /* Version of *.c files used when building libpng */ 805 return png_get_header_ver(png_ptr); 806 } 807 808 png_const_charp PNGAPI 809 png_get_header_ver(png_const_structrp png_ptr) 810 { 811 /* Version of *.h files used when building libpng */ 812 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ 813 return PNG_LIBPNG_VER_STRING; 814 } 815 816 png_const_charp PNGAPI 817 png_get_header_version(png_const_structrp png_ptr) 818 { 819 /* Returns longer string containing both version and date */ 820 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ 821 #ifdef __STDC__ 822 return PNG_HEADER_VERSION_STRING 823 # ifndef PNG_READ_SUPPORTED 824 " (NO READ SUPPORT)" 825 # endif 826 PNG_STRING_NEWLINE; 827 #else 828 return PNG_HEADER_VERSION_STRING; 829 #endif 830 } 831 832 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED 833 /* NOTE: this routine is not used internally! */ 834 /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth 835 * large of png_color. This lets grayscale images be treated as 836 * paletted. Most useful for gamma correction and simplification 837 * of code. This API is not used internally. 838 */ 839 void PNGAPI 840 png_build_grayscale_palette(int bit_depth, png_colorp palette) 841 { 842 int num_palette; 843 int color_inc; 844 int i; 845 int v; 846 847 png_debug(1, "in png_do_build_grayscale_palette"); 848 849 if (palette == NULL) 850 return; 851 852 switch (bit_depth) 853 { 854 case 1: 855 num_palette = 2; 856 color_inc = 0xff; 857 break; 858 859 case 2: 860 num_palette = 4; 861 color_inc = 0x55; 862 break; 863 864 case 4: 865 num_palette = 16; 866 color_inc = 0x11; 867 break; 868 869 case 8: 870 num_palette = 256; 871 color_inc = 1; 872 break; 873 874 default: 875 num_palette = 0; 876 color_inc = 0; 877 break; 878 } 879 880 for (i = 0, v = 0; i < num_palette; i++, v += color_inc) 881 { 882 palette[i].red = (png_byte)(v & 0xff); 883 palette[i].green = (png_byte)(v & 0xff); 884 palette[i].blue = (png_byte)(v & 0xff); 885 } 886 } 887 #endif 888 889 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED 890 int PNGAPI 891 png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name) 892 { 893 /* Check chunk_name and return "keep" value if it's on the list, else 0 */ 894 png_const_bytep p, p_end; 895 896 if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0) 897 return PNG_HANDLE_CHUNK_AS_DEFAULT; 898 899 p_end = png_ptr->chunk_list; 900 p = p_end + png_ptr->num_chunk_list*5; /* beyond end */ 901 902 /* The code is the fifth byte after each four byte string. Historically this 903 * code was always searched from the end of the list, this is no longer 904 * necessary because the 'set' routine handles duplicate entries correcty. 905 */ 906 do /* num_chunk_list > 0, so at least one */ 907 { 908 p -= 5; 909 910 if (memcmp(chunk_name, p, 4) == 0) 911 return p[4]; 912 } 913 while (p > p_end); 914 915 /* This means that known chunks should be processed and unknown chunks should 916 * be handled according to the value of png_ptr->unknown_default; this can be 917 * confusing because, as a result, there are two levels of defaulting for 918 * unknown chunks. 919 */ 920 return PNG_HANDLE_CHUNK_AS_DEFAULT; 921 } 922 923 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\ 924 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) 925 int /* PRIVATE */ 926 png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name) 927 { 928 png_byte chunk_string[5]; 929 930 PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name); 931 return png_handle_as_unknown(png_ptr, chunk_string); 932 } 933 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */ 934 #endif /* SET_UNKNOWN_CHUNKS */ 935 936 #ifdef PNG_READ_SUPPORTED 937 /* This function, added to libpng-1.0.6g, is untested. */ 938 int PNGAPI 939 png_reset_zstream(png_structrp png_ptr) 940 { 941 if (png_ptr == NULL) 942 return Z_STREAM_ERROR; 943 944 /* WARNING: this resets the window bits to the maximum! */ 945 return (inflateReset(&png_ptr->zstream)); 946 } 947 #endif /* READ */ 948 949 /* This function was added to libpng-1.0.7 */ 950 png_uint_32 PNGAPI 951 png_access_version_number(void) 952 { 953 /* Version of *.c files used when building libpng */ 954 return((png_uint_32)PNG_LIBPNG_VER); 955 } 956 957 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) 958 /* Ensure that png_ptr->zstream.msg holds some appropriate error message string. 959 * If it doesn't 'ret' is used to set it to something appropriate, even in cases 960 * like Z_OK or Z_STREAM_END where the error code is apparently a success code. 961 */ 962 void /* PRIVATE */ 963 png_zstream_error(png_structrp png_ptr, int ret) 964 { 965 /* Translate 'ret' into an appropriate error string, priority is given to the 966 * one in zstream if set. This always returns a string, even in cases like 967 * Z_OK or Z_STREAM_END where the error code is a success code. 968 */ 969 if (png_ptr->zstream.msg == NULL) switch (ret) 970 { 971 default: 972 case Z_OK: 973 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code"); 974 break; 975 976 case Z_STREAM_END: 977 /* Normal exit */ 978 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream"); 979 break; 980 981 case Z_NEED_DICT: 982 /* This means the deflate stream did not have a dictionary; this 983 * indicates a bogus PNG. 984 */ 985 png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary"); 986 break; 987 988 case Z_ERRNO: 989 /* gz APIs only: should not happen */ 990 png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error"); 991 break; 992 993 case Z_STREAM_ERROR: 994 /* internal libpng error */ 995 png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib"); 996 break; 997 998 case Z_DATA_ERROR: 999 png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream"); 1000 break; 1001 1002 case Z_MEM_ERROR: 1003 png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory"); 1004 break; 1005 1006 case Z_BUF_ERROR: 1007 /* End of input or output; not a problem if the caller is doing 1008 * incremental read or write. 1009 */ 1010 png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated"); 1011 break; 1012 1013 case Z_VERSION_ERROR: 1014 png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version"); 1015 break; 1016 1017 case PNG_UNEXPECTED_ZLIB_RETURN: 1018 /* Compile errors here mean that zlib now uses the value co-opted in 1019 * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above 1020 * and change pngpriv.h. Note that this message is "... return", 1021 * whereas the default/Z_OK one is "... return code". 1022 */ 1023 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return"); 1024 break; 1025 } 1026 } 1027 1028 /* png_convert_size: a PNGAPI but no longer in png.h, so deleted 1029 * at libpng 1.5.5! 1030 */ 1031 1032 /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ 1033 #ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */ 1034 static int 1035 png_colorspace_check_gamma(png_const_structrp png_ptr, 1036 png_colorspacerp colorspace, png_fixed_point gAMA, int from) 1037 /* This is called to check a new gamma value against an existing one. The 1038 * routine returns false if the new gamma value should not be written. 1039 * 1040 * 'from' says where the new gamma value comes from: 1041 * 1042 * 0: the new gamma value is the libpng estimate for an ICC profile 1043 * 1: the new gamma value comes from a gAMA chunk 1044 * 2: the new gamma value comes from an sRGB chunk 1045 */ 1046 { 1047 png_fixed_point gtest; 1048 1049 if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && 1050 (png_muldiv(>est, colorspace->gamma, PNG_FP_1, gAMA) == 0 || 1051 png_gamma_significant(gtest) != 0)) 1052 { 1053 /* Either this is an sRGB image, in which case the calculated gamma 1054 * approximation should match, or this is an image with a profile and the 1055 * value libpng calculates for the gamma of the profile does not match the 1056 * value recorded in the file. The former, sRGB, case is an error, the 1057 * latter is just a warning. 1058 */ 1059 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2) 1060 { 1061 png_chunk_report(png_ptr, "gamma value does not match sRGB", 1062 PNG_CHUNK_ERROR); 1063 /* Do not overwrite an sRGB value */ 1064 return from == 2; 1065 } 1066 1067 else /* sRGB tag not involved */ 1068 { 1069 png_chunk_report(png_ptr, "gamma value does not match libpng estimate", 1070 PNG_CHUNK_WARNING); 1071 return from == 1; 1072 } 1073 } 1074 1075 return 1; 1076 } 1077 1078 void /* PRIVATE */ 1079 png_colorspace_set_gamma(png_const_structrp png_ptr, 1080 png_colorspacerp colorspace, png_fixed_point gAMA) 1081 { 1082 /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't 1083 * occur. Since the fixed point representation is asymetrical it is 1084 * possible for 1/gamma to overflow the limit of 21474 and this means the 1085 * gamma value must be at least 5/100000 and hence at most 20000.0. For 1086 * safety the limits here are a little narrower. The values are 0.00016 to 1087 * 6250.0, which are truly ridiculous gamma values (and will produce 1088 * displays that are all black or all white.) 1089 * 1090 * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk 1091 * handling code, which only required the value to be >0. 1092 */ 1093 png_const_charp errmsg; 1094 1095 if (gAMA < 16 || gAMA > 625000000) 1096 errmsg = "gamma value out of range"; 1097 1098 # ifdef PNG_READ_gAMA_SUPPORTED 1099 /* Allow the application to set the gamma value more than once */ 1100 else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && 1101 (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0) 1102 errmsg = "duplicate"; 1103 # endif 1104 1105 /* Do nothing if the colorspace is already invalid */ 1106 else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) 1107 return; 1108 1109 else 1110 { 1111 if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1112 1/*from gAMA*/) != 0) 1113 { 1114 /* Store this gamma value. */ 1115 colorspace->gamma = gAMA; 1116 colorspace->flags |= 1117 (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA); 1118 } 1119 1120 /* At present if the check_gamma test fails the gamma of the colorspace is 1121 * not updated however the colorspace is not invalidated. This 1122 * corresponds to the case where the existing gamma comes from an sRGB 1123 * chunk or profile. An error message has already been output. 1124 */ 1125 return; 1126 } 1127 1128 /* Error exit - errmsg has been set. */ 1129 colorspace->flags |= PNG_COLORSPACE_INVALID; 1130 png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR); 1131 } 1132 1133 void /* PRIVATE */ 1134 png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr) 1135 { 1136 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0) 1137 { 1138 /* Everything is invalid */ 1139 info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB| 1140 PNG_INFO_iCCP); 1141 1142 # ifdef PNG_COLORSPACE_SUPPORTED 1143 /* Clean up the iCCP profile now if it won't be used. */ 1144 png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/); 1145 # else 1146 PNG_UNUSED(png_ptr) 1147 # endif 1148 } 1149 1150 else 1151 { 1152 # ifdef PNG_COLORSPACE_SUPPORTED 1153 /* Leave the INFO_iCCP flag set if the pngset.c code has already set 1154 * it; this allows a PNG to contain a profile which matches sRGB and 1155 * yet still have that profile retrievable by the application. 1156 */ 1157 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0) 1158 info_ptr->valid |= PNG_INFO_sRGB; 1159 1160 else 1161 info_ptr->valid &= ~PNG_INFO_sRGB; 1162 1163 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) 1164 info_ptr->valid |= PNG_INFO_cHRM; 1165 1166 else 1167 info_ptr->valid &= ~PNG_INFO_cHRM; 1168 # endif 1169 1170 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0) 1171 info_ptr->valid |= PNG_INFO_gAMA; 1172 1173 else 1174 info_ptr->valid &= ~PNG_INFO_gAMA; 1175 } 1176 } 1177 1178 #ifdef PNG_READ_SUPPORTED 1179 void /* PRIVATE */ 1180 png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr) 1181 { 1182 if (info_ptr == NULL) /* reduce code size; check here not in the caller */ 1183 return; 1184 1185 info_ptr->colorspace = png_ptr->colorspace; 1186 png_colorspace_sync_info(png_ptr, info_ptr); 1187 } 1188 #endif 1189 #endif /* GAMMA */ 1190 1191 #ifdef PNG_COLORSPACE_SUPPORTED 1192 /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for 1193 * cHRM, as opposed to using chromaticities. These internal APIs return 1194 * non-zero on a parameter error. The X, Y and Z values are required to be 1195 * positive and less than 1.0. 1196 */ 1197 static int 1198 png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ) 1199 { 1200 png_int_32 d, dwhite, whiteX, whiteY; 1201 1202 d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z; 1203 if (png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d) == 0) 1204 return 1; 1205 if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0) 1206 return 1; 1207 dwhite = d; 1208 whiteX = XYZ->red_X; 1209 whiteY = XYZ->red_Y; 1210 1211 d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z; 1212 if (png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d) == 0) 1213 return 1; 1214 if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0) 1215 return 1; 1216 dwhite += d; 1217 whiteX += XYZ->green_X; 1218 whiteY += XYZ->green_Y; 1219 1220 d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z; 1221 if (png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d) == 0) 1222 return 1; 1223 if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0) 1224 return 1; 1225 dwhite += d; 1226 whiteX += XYZ->blue_X; 1227 whiteY += XYZ->blue_Y; 1228 1229 /* The reference white is simply the sum of the end-point (X,Y,Z) vectors, 1230 * thus: 1231 */ 1232 if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0) 1233 return 1; 1234 if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0) 1235 return 1; 1236 1237 return 0; 1238 } 1239 1240 static int 1241 png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy) 1242 { 1243 png_fixed_point red_inverse, green_inverse, blue_scale; 1244 png_fixed_point left, right, denominator; 1245 1246 /* Check xy and, implicitly, z. Note that wide gamut color spaces typically 1247 * have end points with 0 tristimulus values (these are impossible end 1248 * points, but they are used to cover the possible colors). We check 1249 * xy->whitey against 5, not 0, to avoid a possible integer overflow. 1250 */ 1251 if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1; 1252 if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1; 1253 if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1; 1254 if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1; 1255 if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1; 1256 if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1; 1257 if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1; 1258 if (xy->whitey < 5 || xy->whitey > PNG_FP_1-xy->whitex) return 1; 1259 1260 /* The reverse calculation is more difficult because the original tristimulus 1261 * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8 1262 * derived values were recorded in the cHRM chunk; 1263 * (red,green,blue,white)x(x,y). This loses one degree of freedom and 1264 * therefore an arbitrary ninth value has to be introduced to undo the 1265 * original transformations. 1266 * 1267 * Think of the original end-points as points in (X,Y,Z) space. The 1268 * chromaticity values (c) have the property: 1269 * 1270 * C 1271 * c = --------- 1272 * X + Y + Z 1273 * 1274 * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the 1275 * three chromaticity values (x,y,z) for each end-point obey the 1276 * relationship: 1277 * 1278 * x + y + z = 1 1279 * 1280 * This describes the plane in (X,Y,Z) space that intersects each axis at the 1281 * value 1.0; call this the chromaticity plane. Thus the chromaticity 1282 * calculation has scaled each end-point so that it is on the x+y+z=1 plane 1283 * and chromaticity is the intersection of the vector from the origin to the 1284 * (X,Y,Z) value with the chromaticity plane. 1285 * 1286 * To fully invert the chromaticity calculation we would need the three 1287 * end-point scale factors, (red-scale, green-scale, blue-scale), but these 1288 * were not recorded. Instead we calculated the reference white (X,Y,Z) and 1289 * recorded the chromaticity of this. The reference white (X,Y,Z) would have 1290 * given all three of the scale factors since: 1291 * 1292 * color-C = color-c * color-scale 1293 * white-C = red-C + green-C + blue-C 1294 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale 1295 * 1296 * But cHRM records only white-x and white-y, so we have lost the white scale 1297 * factor: 1298 * 1299 * white-C = white-c*white-scale 1300 * 1301 * To handle this the inverse transformation makes an arbitrary assumption 1302 * about white-scale: 1303 * 1304 * Assume: white-Y = 1.0 1305 * Hence: white-scale = 1/white-y 1306 * Or: red-Y + green-Y + blue-Y = 1.0 1307 * 1308 * Notice the last statement of the assumption gives an equation in three of 1309 * the nine values we want to calculate. 8 more equations come from the 1310 * above routine as summarised at the top above (the chromaticity 1311 * calculation): 1312 * 1313 * Given: color-x = color-X / (color-X + color-Y + color-Z) 1314 * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0 1315 * 1316 * This is 9 simultaneous equations in the 9 variables "color-C" and can be 1317 * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix 1318 * determinants, however this is not as bad as it seems because only 28 of 1319 * the total of 90 terms in the various matrices are non-zero. Nevertheless 1320 * Cramer's rule is notoriously numerically unstable because the determinant 1321 * calculation involves the difference of large, but similar, numbers. It is 1322 * difficult to be sure that the calculation is stable for real world values 1323 * and it is certain that it becomes unstable where the end points are close 1324 * together. 1325 * 1326 * So this code uses the perhaps slightly less optimal but more 1327 * understandable and totally obvious approach of calculating color-scale. 1328 * 1329 * This algorithm depends on the precision in white-scale and that is 1330 * (1/white-y), so we can immediately see that as white-y approaches 0 the 1331 * accuracy inherent in the cHRM chunk drops off substantially. 1332 * 1333 * libpng arithmetic: a simple inversion of the above equations 1334 * ------------------------------------------------------------ 1335 * 1336 * white_scale = 1/white-y 1337 * white-X = white-x * white-scale 1338 * white-Y = 1.0 1339 * white-Z = (1 - white-x - white-y) * white_scale 1340 * 1341 * white-C = red-C + green-C + blue-C 1342 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale 1343 * 1344 * This gives us three equations in (red-scale,green-scale,blue-scale) where 1345 * all the coefficients are now known: 1346 * 1347 * red-x*red-scale + green-x*green-scale + blue-x*blue-scale 1348 * = white-x/white-y 1349 * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1 1350 * red-z*red-scale + green-z*green-scale + blue-z*blue-scale 1351 * = (1 - white-x - white-y)/white-y 1352 * 1353 * In the last equation color-z is (1 - color-x - color-y) so we can add all 1354 * three equations together to get an alternative third: 1355 * 1356 * red-scale + green-scale + blue-scale = 1/white-y = white-scale 1357 * 1358 * So now we have a Cramer's rule solution where the determinants are just 1359 * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve 1360 * multiplication of three coefficients so we can't guarantee to avoid 1361 * overflow in the libpng fixed point representation. Using Cramer's rule in 1362 * floating point is probably a good choice here, but it's not an option for 1363 * fixed point. Instead proceed to simplify the first two equations by 1364 * eliminating what is likely to be the largest value, blue-scale: 1365 * 1366 * blue-scale = white-scale - red-scale - green-scale 1367 * 1368 * Hence: 1369 * 1370 * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale = 1371 * (white-x - blue-x)*white-scale 1372 * 1373 * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale = 1374 * 1 - blue-y*white-scale 1375 * 1376 * And now we can trivially solve for (red-scale,green-scale): 1377 * 1378 * green-scale = 1379 * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale 1380 * ----------------------------------------------------------- 1381 * green-x - blue-x 1382 * 1383 * red-scale = 1384 * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale 1385 * --------------------------------------------------------- 1386 * red-y - blue-y 1387 * 1388 * Hence: 1389 * 1390 * red-scale = 1391 * ( (green-x - blue-x) * (white-y - blue-y) - 1392 * (green-y - blue-y) * (white-x - blue-x) ) / white-y 1393 * ------------------------------------------------------------------------- 1394 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) 1395 * 1396 * green-scale = 1397 * ( (red-y - blue-y) * (white-x - blue-x) - 1398 * (red-x - blue-x) * (white-y - blue-y) ) / white-y 1399 * ------------------------------------------------------------------------- 1400 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) 1401 * 1402 * Accuracy: 1403 * The input values have 5 decimal digits of accuracy. The values are all in 1404 * the range 0 < value < 1, so simple products are in the same range but may 1405 * need up to 10 decimal digits to preserve the original precision and avoid 1406 * underflow. Because we are using a 32-bit signed representation we cannot 1407 * match this; the best is a little over 9 decimal digits, less than 10. 1408 * 1409 * The approach used here is to preserve the maximum precision within the 1410 * signed representation. Because the red-scale calculation above uses the 1411 * difference between two products of values that must be in the range -1..+1 1412 * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The 1413 * factor is irrelevant in the calculation because it is applied to both 1414 * numerator and denominator. 1415 * 1416 * Note that the values of the differences of the products of the 1417 * chromaticities in the above equations tend to be small, for example for 1418 * the sRGB chromaticities they are: 1419 * 1420 * red numerator: -0.04751 1421 * green numerator: -0.08788 1422 * denominator: -0.2241 (without white-y multiplication) 1423 * 1424 * The resultant Y coefficients from the chromaticities of some widely used 1425 * color space definitions are (to 15 decimal places): 1426 * 1427 * sRGB 1428 * 0.212639005871510 0.715168678767756 0.072192315360734 1429 * Kodak ProPhoto 1430 * 0.288071128229293 0.711843217810102 0.000085653960605 1431 * Adobe RGB 1432 * 0.297344975250536 0.627363566255466 0.075291458493998 1433 * Adobe Wide Gamut RGB 1434 * 0.258728243040113 0.724682314948566 0.016589442011321 1435 */ 1436 /* By the argument, above overflow should be impossible here. The return 1437 * value of 2 indicates an internal error to the caller. 1438 */ 1439 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0) 1440 return 2; 1441 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0) 1442 return 2; 1443 denominator = left - right; 1444 1445 /* Now find the red numerator. */ 1446 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0) 1447 return 2; 1448 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0) 1449 return 2; 1450 1451 /* Overflow is possible here and it indicates an extreme set of PNG cHRM 1452 * chunk values. This calculation actually returns the reciprocal of the 1453 * scale value because this allows us to delay the multiplication of white-y 1454 * into the denominator, which tends to produce a small number. 1455 */ 1456 if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 || 1457 red_inverse <= xy->whitey /* r+g+b scales = white scale */) 1458 return 1; 1459 1460 /* Similarly for green_inverse: */ 1461 if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0) 1462 return 2; 1463 if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0) 1464 return 2; 1465 if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 || 1466 green_inverse <= xy->whitey) 1467 return 1; 1468 1469 /* And the blue scale, the checks above guarantee this can't overflow but it 1470 * can still produce 0 for extreme cHRM values. 1471 */ 1472 blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) - 1473 png_reciprocal(green_inverse); 1474 if (blue_scale <= 0) 1475 return 1; 1476 1477 1478 /* And fill in the png_XYZ: */ 1479 if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0) 1480 return 1; 1481 if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0) 1482 return 1; 1483 if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1, 1484 red_inverse) == 0) 1485 return 1; 1486 1487 if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0) 1488 return 1; 1489 if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0) 1490 return 1; 1491 if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1, 1492 green_inverse) == 0) 1493 return 1; 1494 1495 if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0) 1496 return 1; 1497 if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0) 1498 return 1; 1499 if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale, 1500 PNG_FP_1) == 0) 1501 return 1; 1502 1503 return 0; /*success*/ 1504 } 1505 1506 static int 1507 png_XYZ_normalize(png_XYZ *XYZ) 1508 { 1509 png_int_32 Y; 1510 1511 if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 || 1512 XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 || 1513 XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0) 1514 return 1; 1515 1516 /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1. 1517 * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore 1518 * relying on addition of two positive values producing a negative one is not 1519 * safe. 1520 */ 1521 Y = XYZ->red_Y; 1522 if (0x7fffffff - Y < XYZ->green_X) 1523 return 1; 1524 Y += XYZ->green_Y; 1525 if (0x7fffffff - Y < XYZ->blue_X) 1526 return 1; 1527 Y += XYZ->blue_Y; 1528 1529 if (Y != PNG_FP_1) 1530 { 1531 if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0) 1532 return 1; 1533 if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0) 1534 return 1; 1535 if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0) 1536 return 1; 1537 1538 if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0) 1539 return 1; 1540 if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0) 1541 return 1; 1542 if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0) 1543 return 1; 1544 1545 if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0) 1546 return 1; 1547 if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0) 1548 return 1; 1549 if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0) 1550 return 1; 1551 } 1552 1553 return 0; 1554 } 1555 1556 static int 1557 png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta) 1558 { 1559 /* Allow an error of +/-0.01 (absolute value) on each chromaticity */ 1560 if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) || 1561 PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) || 1562 PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) || 1563 PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) || 1564 PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) || 1565 PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) || 1566 PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) || 1567 PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta)) 1568 return 0; 1569 return 1; 1570 } 1571 1572 /* Added in libpng-1.6.0, a different check for the validity of a set of cHRM 1573 * chunk chromaticities. Earlier checks used to simply look for the overflow 1574 * condition (where the determinant of the matrix to solve for XYZ ends up zero 1575 * because the chromaticity values are not all distinct.) Despite this it is 1576 * theoretically possible to produce chromaticities that are apparently valid 1577 * but that rapidly degrade to invalid, potentially crashing, sets because of 1578 * arithmetic inaccuracies when calculations are performed on them. The new 1579 * check is to round-trip xy -> XYZ -> xy and then check that the result is 1580 * within a small percentage of the original. 1581 */ 1582 static int 1583 png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy) 1584 { 1585 int result; 1586 png_xy xy_test; 1587 1588 /* As a side-effect this routine also returns the XYZ endpoints. */ 1589 result = png_XYZ_from_xy(XYZ, xy); 1590 if (result != 0) 1591 return result; 1592 1593 result = png_xy_from_XYZ(&xy_test, XYZ); 1594 if (result != 0) 1595 return result; 1596 1597 if (png_colorspace_endpoints_match(xy, &xy_test, 1598 5/*actually, the math is pretty accurate*/) != 0) 1599 return 0; 1600 1601 /* Too much slip */ 1602 return 1; 1603 } 1604 1605 /* This is the check going the other way. The XYZ is modified to normalize it 1606 * (another side-effect) and the xy chromaticities are returned. 1607 */ 1608 static int 1609 png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ) 1610 { 1611 int result; 1612 png_XYZ XYZtemp; 1613 1614 result = png_XYZ_normalize(XYZ); 1615 if (result != 0) 1616 return result; 1617 1618 result = png_xy_from_XYZ(xy, XYZ); 1619 if (result != 0) 1620 return result; 1621 1622 XYZtemp = *XYZ; 1623 return png_colorspace_check_xy(&XYZtemp, xy); 1624 } 1625 1626 /* Used to check for an endpoint match against sRGB */ 1627 static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */ 1628 { 1629 /* color x y */ 1630 /* red */ 64000, 33000, 1631 /* green */ 30000, 60000, 1632 /* blue */ 15000, 6000, 1633 /* white */ 31270, 32900 1634 }; 1635 1636 static int 1637 png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr, 1638 png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ, 1639 int preferred) 1640 { 1641 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) 1642 return 0; 1643 1644 /* The consistency check is performed on the chromaticities; this factors out 1645 * variations because of the normalization (or not) of the end point Y 1646 * values. 1647 */ 1648 if (preferred < 2 && 1649 (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) 1650 { 1651 /* The end points must be reasonably close to any we already have. The 1652 * following allows an error of up to +/-.001 1653 */ 1654 if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy, 1655 100) == 0) 1656 { 1657 colorspace->flags |= PNG_COLORSPACE_INVALID; 1658 png_benign_error(png_ptr, "inconsistent chromaticities"); 1659 return 0; /* failed */ 1660 } 1661 1662 /* Only overwrite with preferred values */ 1663 if (preferred == 0) 1664 return 1; /* ok, but no change */ 1665 } 1666 1667 colorspace->end_points_xy = *xy; 1668 colorspace->end_points_XYZ = *XYZ; 1669 colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS; 1670 1671 /* The end points are normally quoted to two decimal digits, so allow +/-0.01 1672 * on this test. 1673 */ 1674 if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0) 1675 colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB; 1676 1677 else 1678 colorspace->flags &= PNG_COLORSPACE_CANCEL( 1679 PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB); 1680 1681 return 2; /* ok and changed */ 1682 } 1683 1684 int /* PRIVATE */ 1685 png_colorspace_set_chromaticities(png_const_structrp png_ptr, 1686 png_colorspacerp colorspace, const png_xy *xy, int preferred) 1687 { 1688 /* We must check the end points to ensure they are reasonable - in the past 1689 * color management systems have crashed as a result of getting bogus 1690 * colorant values, while this isn't the fault of libpng it is the 1691 * responsibility of libpng because PNG carries the bomb and libpng is in a 1692 * position to protect against it. 1693 */ 1694 png_XYZ XYZ; 1695 1696 switch (png_colorspace_check_xy(&XYZ, xy)) 1697 { 1698 case 0: /* success */ 1699 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ, 1700 preferred); 1701 1702 case 1: 1703 /* We can't invert the chromaticities so we can't produce value XYZ 1704 * values. Likely as not a color management system will fail too. 1705 */ 1706 colorspace->flags |= PNG_COLORSPACE_INVALID; 1707 png_benign_error(png_ptr, "invalid chromaticities"); 1708 break; 1709 1710 default: 1711 /* libpng is broken; this should be a warning but if it happens we 1712 * want error reports so for the moment it is an error. 1713 */ 1714 colorspace->flags |= PNG_COLORSPACE_INVALID; 1715 png_error(png_ptr, "internal error checking chromaticities"); 1716 } 1717 1718 return 0; /* failed */ 1719 } 1720 1721 int /* PRIVATE */ 1722 png_colorspace_set_endpoints(png_const_structrp png_ptr, 1723 png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred) 1724 { 1725 png_XYZ XYZ = *XYZ_in; 1726 png_xy xy; 1727 1728 switch (png_colorspace_check_XYZ(&xy, &XYZ)) 1729 { 1730 case 0: 1731 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ, 1732 preferred); 1733 1734 case 1: 1735 /* End points are invalid. */ 1736 colorspace->flags |= PNG_COLORSPACE_INVALID; 1737 png_benign_error(png_ptr, "invalid end points"); 1738 break; 1739 1740 default: 1741 colorspace->flags |= PNG_COLORSPACE_INVALID; 1742 png_error(png_ptr, "internal error checking chromaticities"); 1743 } 1744 1745 return 0; /* failed */ 1746 } 1747 1748 #if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED) 1749 /* Error message generation */ 1750 static char 1751 png_icc_tag_char(png_uint_32 byte) 1752 { 1753 byte &= 0xff; 1754 if (byte >= 32 && byte <= 126) 1755 return (char)byte; 1756 else 1757 return '?'; 1758 } 1759 1760 static void 1761 png_icc_tag_name(char *name, png_uint_32 tag) 1762 { 1763 name[0] = '\''; 1764 name[1] = png_icc_tag_char(tag >> 24); 1765 name[2] = png_icc_tag_char(tag >> 16); 1766 name[3] = png_icc_tag_char(tag >> 8); 1767 name[4] = png_icc_tag_char(tag ); 1768 name[5] = '\''; 1769 } 1770 1771 static int 1772 is_ICC_signature_char(png_alloc_size_t it) 1773 { 1774 return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) || 1775 (it >= 97 && it <= 122); 1776 } 1777 1778 static int 1779 is_ICC_signature(png_alloc_size_t it) 1780 { 1781 return is_ICC_signature_char(it >> 24) /* checks all the top bits */ && 1782 is_ICC_signature_char((it >> 16) & 0xff) && 1783 is_ICC_signature_char((it >> 8) & 0xff) && 1784 is_ICC_signature_char(it & 0xff); 1785 } 1786 1787 static int 1788 png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace, 1789 png_const_charp name, png_alloc_size_t value, png_const_charp reason) 1790 { 1791 size_t pos; 1792 char message[196]; /* see below for calculation */ 1793 1794 if (colorspace != NULL) 1795 colorspace->flags |= PNG_COLORSPACE_INVALID; 1796 1797 pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */ 1798 pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */ 1799 pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */ 1800 if (is_ICC_signature(value) != 0) 1801 { 1802 /* So 'value' is at most 4 bytes and the following cast is safe */ 1803 png_icc_tag_name(message+pos, (png_uint_32)value); 1804 pos += 6; /* total +8; less than the else clause */ 1805 message[pos++] = ':'; 1806 message[pos++] = ' '; 1807 } 1808 # ifdef PNG_WARNINGS_SUPPORTED 1809 else 1810 { 1811 char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/ 1812 1813 pos = png_safecat(message, (sizeof message), pos, 1814 png_format_number(number, number+(sizeof number), 1815 PNG_NUMBER_FORMAT_x, value)); 1816 pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/ 1817 } 1818 # endif 1819 /* The 'reason' is an arbitrary message, allow +79 maximum 195 */ 1820 pos = png_safecat(message, (sizeof message), pos, reason); 1821 PNG_UNUSED(pos) 1822 1823 /* This is recoverable, but make it unconditionally an app_error on write to 1824 * avoid writing invalid ICC profiles into PNG files (i.e., we handle them 1825 * on read, with a warning, but on write unless the app turns off 1826 * application errors the PNG won't be written.) 1827 */ 1828 png_chunk_report(png_ptr, message, 1829 (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR); 1830 1831 return 0; 1832 } 1833 #endif /* sRGB || iCCP */ 1834 1835 #ifdef PNG_sRGB_SUPPORTED 1836 int /* PRIVATE */ 1837 png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace, 1838 int intent) 1839 { 1840 /* sRGB sets known gamma, end points and (from the chunk) intent. */ 1841 /* IMPORTANT: these are not necessarily the values found in an ICC profile 1842 * because ICC profiles store values adapted to a D50 environment; it is 1843 * expected that the ICC profile mediaWhitePointTag will be D50; see the 1844 * checks and code elsewhere to understand this better. 1845 * 1846 * These XYZ values, which are accurate to 5dp, produce rgb to gray 1847 * coefficients of (6968,23435,2366), which are reduced (because they add up 1848 * to 32769 not 32768) to (6968,23434,2366). These are the values that 1849 * libpng has traditionally used (and are the best values given the 15bit 1850 * algorithm used by the rgb to gray code.) 1851 */ 1852 static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */ 1853 { 1854 /* color X Y Z */ 1855 /* red */ 41239, 21264, 1933, 1856 /* green */ 35758, 71517, 11919, 1857 /* blue */ 18048, 7219, 95053 1858 }; 1859 1860 /* Do nothing if the colorspace is already invalidated. */ 1861 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) 1862 return 0; 1863 1864 /* Check the intent, then check for existing settings. It is valid for the 1865 * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must 1866 * be consistent with the correct values. If, however, this function is 1867 * called below because an iCCP chunk matches sRGB then it is quite 1868 * conceivable that an older app recorded incorrect gAMA and cHRM because of 1869 * an incorrect calculation based on the values in the profile - this does 1870 * *not* invalidate the profile (though it still produces an error, which can 1871 * be ignored.) 1872 */ 1873 if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST) 1874 return png_icc_profile_error(png_ptr, colorspace, "sRGB", 1875 (unsigned)intent, "invalid sRGB rendering intent"); 1876 1877 if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 && 1878 colorspace->rendering_intent != intent) 1879 return png_icc_profile_error(png_ptr, colorspace, "sRGB", 1880 (unsigned)intent, "inconsistent rendering intents"); 1881 1882 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0) 1883 { 1884 png_benign_error(png_ptr, "duplicate sRGB information ignored"); 1885 return 0; 1886 } 1887 1888 /* If the standard sRGB cHRM chunk does not match the one from the PNG file 1889 * warn but overwrite the value with the correct one. 1890 */ 1891 if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 && 1892 !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy, 1893 100)) 1894 png_chunk_report(png_ptr, "cHRM chunk does not match sRGB", 1895 PNG_CHUNK_ERROR); 1896 1897 /* This check is just done for the error reporting - the routine always 1898 * returns true when the 'from' argument corresponds to sRGB (2). 1899 */ 1900 (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE, 1901 2/*from sRGB*/); 1902 1903 /* intent: bugs in GCC force 'int' to be used as the parameter type. */ 1904 colorspace->rendering_intent = (png_uint_16)intent; 1905 colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT; 1906 1907 /* endpoints */ 1908 colorspace->end_points_xy = sRGB_xy; 1909 colorspace->end_points_XYZ = sRGB_XYZ; 1910 colorspace->flags |= 1911 (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB); 1912 1913 /* gamma */ 1914 colorspace->gamma = PNG_GAMMA_sRGB_INVERSE; 1915 colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA; 1916 1917 /* Finally record that we have an sRGB profile */ 1918 colorspace->flags |= 1919 (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB); 1920 1921 return 1; /* set */ 1922 } 1923 #endif /* sRGB */ 1924 1925 #ifdef PNG_iCCP_SUPPORTED 1926 /* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value 1927 * is XYZ(0.9642,1.0,0.8249), which scales to: 1928 * 1929 * (63189.8112, 65536, 54060.6464) 1930 */ 1931 static const png_byte D50_nCIEXYZ[12] = 1932 { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d }; 1933 1934 static int /* bool */ 1935 icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, 1936 png_const_charp name, png_uint_32 profile_length) 1937 { 1938 if (profile_length < 132) 1939 return png_icc_profile_error(png_ptr, colorspace, name, profile_length, 1940 "too short"); 1941 1942 return 1; 1943 } 1944 1945 #ifdef PNG_READ_iCCP_SUPPORTED 1946 int /* PRIVATE */ 1947 png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, 1948 png_const_charp name, png_uint_32 profile_length) 1949 { 1950 if (!icc_check_length(png_ptr, colorspace, name, profile_length)) 1951 return 0; 1952 1953 /* This needs to be here because the 'normal' check is in 1954 * png_decompress_chunk, yet this happens after the attempt to 1955 * png_malloc_base the required data. We only need this on read; on write 1956 * the caller supplies the profile buffer so libpng doesn't allocate it. See 1957 * the call to icc_check_length below (the write case). 1958 */ 1959 # ifdef PNG_SET_USER_LIMITS_SUPPORTED 1960 else if (png_ptr->user_chunk_malloc_max > 0 && 1961 png_ptr->user_chunk_malloc_max < profile_length) 1962 return png_icc_profile_error(png_ptr, colorspace, name, profile_length, 1963 "exceeds application limits"); 1964 # elif PNG_USER_CHUNK_MALLOC_MAX > 0 1965 else if (PNG_USER_CHUNK_MALLOC_MAX < profile_length) 1966 return png_icc_profile_error(png_ptr, colorspace, name, profile_length, 1967 "exceeds libpng limits"); 1968 # else /* !SET_USER_LIMITS */ 1969 /* This will get compiled out on all 32-bit and better systems. */ 1970 else if (PNG_SIZE_MAX < profile_length) 1971 return png_icc_profile_error(png_ptr, colorspace, name, profile_length, 1972 "exceeds system limits"); 1973 # endif /* !SET_USER_LIMITS */ 1974 1975 return 1; 1976 } 1977 #endif /* READ_iCCP */ 1978 1979 int /* PRIVATE */ 1980 png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace, 1981 png_const_charp name, png_uint_32 profile_length, 1982 png_const_bytep profile/* first 132 bytes only */, int color_type) 1983 { 1984 png_uint_32 temp; 1985 1986 /* Length check; this cannot be ignored in this code because profile_length 1987 * is used later to check the tag table, so even if the profile seems over 1988 * long profile_length from the caller must be correct. The caller can fix 1989 * this up on read or write by just passing in the profile header length. 1990 */ 1991 temp = png_get_uint_32(profile); 1992 if (temp != profile_length) 1993 return png_icc_profile_error(png_ptr, colorspace, name, temp, 1994 "length does not match profile"); 1995 1996 temp = (png_uint_32) (*(profile+8)); 1997 if (temp > 3 && (profile_length & 3)) 1998 return png_icc_profile_error(png_ptr, colorspace, name, profile_length, 1999 "invalid length"); 2000 2001 temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */ 2002 if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */ 2003 profile_length < 132+12*temp) /* truncated tag table */ 2004 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2005 "tag count too large"); 2006 2007 /* The 'intent' must be valid or we can't store it, ICC limits the intent to 2008 * 16 bits. 2009 */ 2010 temp = png_get_uint_32(profile+64); 2011 if (temp >= 0xffff) /* The ICC limit */ 2012 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2013 "invalid rendering intent"); 2014 2015 /* This is just a warning because the profile may be valid in future 2016 * versions. 2017 */ 2018 if (temp >= PNG_sRGB_INTENT_LAST) 2019 (void)png_icc_profile_error(png_ptr, NULL, name, temp, 2020 "intent outside defined range"); 2021 2022 /* At this point the tag table can't be checked because it hasn't necessarily 2023 * been loaded; however, various header fields can be checked. These checks 2024 * are for values permitted by the PNG spec in an ICC profile; the PNG spec 2025 * restricts the profiles that can be passed in an iCCP chunk (they must be 2026 * appropriate to processing PNG data!) 2027 */ 2028 2029 /* Data checks (could be skipped). These checks must be independent of the 2030 * version number; however, the version number doesn't accomodate changes in 2031 * the header fields (just the known tags and the interpretation of the 2032 * data.) 2033 */ 2034 temp = png_get_uint_32(profile+36); /* signature 'ascp' */ 2035 if (temp != 0x61637370) 2036 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2037 "invalid signature"); 2038 2039 /* Currently the PCS illuminant/adopted white point (the computational 2040 * white point) are required to be D50, 2041 * however the profile contains a record of the illuminant so perhaps ICC 2042 * expects to be able to change this in the future (despite the rationale in 2043 * the introduction for using a fixed PCS adopted white.) Consequently the 2044 * following is just a warning. 2045 */ 2046 if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0) 2047 (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/, 2048 "PCS illuminant is not D50"); 2049 2050 /* The PNG spec requires this: 2051 * "If the iCCP chunk is present, the image samples conform to the colour 2052 * space represented by the embedded ICC profile as defined by the 2053 * International Color Consortium [ICC]. The colour space of the ICC profile 2054 * shall be an RGB colour space for colour images (PNG colour types 2, 3, and 2055 * 6), or a greyscale colour space for greyscale images (PNG colour types 0 2056 * and 4)." 2057 * 2058 * This checking code ensures the embedded profile (on either read or write) 2059 * conforms to the specification requirements. Notice that an ICC 'gray' 2060 * color-space profile contains the information to transform the monochrome 2061 * data to XYZ or L*a*b (according to which PCS the profile uses) and this 2062 * should be used in preference to the standard libpng K channel replication 2063 * into R, G and B channels. 2064 * 2065 * Previously it was suggested that an RGB profile on grayscale data could be 2066 * handled. However it it is clear that using an RGB profile in this context 2067 * must be an error - there is no specification of what it means. Thus it is 2068 * almost certainly more correct to ignore the profile. 2069 */ 2070 temp = png_get_uint_32(profile+16); /* data colour space field */ 2071 switch (temp) 2072 { 2073 case 0x52474220: /* 'RGB ' */ 2074 if ((color_type & PNG_COLOR_MASK_COLOR) == 0) 2075 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2076 "RGB color space not permitted on grayscale PNG"); 2077 break; 2078 2079 case 0x47524159: /* 'GRAY' */ 2080 if ((color_type & PNG_COLOR_MASK_COLOR) != 0) 2081 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2082 "Gray color space not permitted on RGB PNG"); 2083 break; 2084 2085 default: 2086 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2087 "invalid ICC profile color space"); 2088 } 2089 2090 /* It is up to the application to check that the profile class matches the 2091 * application requirements; the spec provides no guidance, but it's pretty 2092 * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer 2093 * ('prtr') or 'spac' (for generic color spaces). Issue a warning in these 2094 * cases. Issue an error for device link or abstract profiles - these don't 2095 * contain the records necessary to transform the color-space to anything 2096 * other than the target device (and not even that for an abstract profile). 2097 * Profiles of these classes may not be embedded in images. 2098 */ 2099 temp = png_get_uint_32(profile+12); /* profile/device class */ 2100 switch (temp) 2101 { 2102 case 0x73636e72: /* 'scnr' */ 2103 case 0x6d6e7472: /* 'mntr' */ 2104 case 0x70727472: /* 'prtr' */ 2105 case 0x73706163: /* 'spac' */ 2106 /* All supported */ 2107 break; 2108 2109 case 0x61627374: /* 'abst' */ 2110 /* May not be embedded in an image */ 2111 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2112 "invalid embedded Abstract ICC profile"); 2113 2114 case 0x6c696e6b: /* 'link' */ 2115 /* DeviceLink profiles cannot be interpreted in a non-device specific 2116 * fashion, if an app uses the AToB0Tag in the profile the results are 2117 * undefined unless the result is sent to the intended device, 2118 * therefore a DeviceLink profile should not be found embedded in a 2119 * PNG. 2120 */ 2121 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2122 "unexpected DeviceLink ICC profile class"); 2123 2124 case 0x6e6d636c: /* 'nmcl' */ 2125 /* A NamedColor profile is also device specific, however it doesn't 2126 * contain an AToB0 tag that is open to misinterpretation. Almost 2127 * certainly it will fail the tests below. 2128 */ 2129 (void)png_icc_profile_error(png_ptr, NULL, name, temp, 2130 "unexpected NamedColor ICC profile class"); 2131 break; 2132 2133 default: 2134 /* To allow for future enhancements to the profile accept unrecognized 2135 * profile classes with a warning, these then hit the test below on the 2136 * tag content to ensure they are backward compatible with one of the 2137 * understood profiles. 2138 */ 2139 (void)png_icc_profile_error(png_ptr, NULL, name, temp, 2140 "unrecognized ICC profile class"); 2141 break; 2142 } 2143 2144 /* For any profile other than a device link one the PCS must be encoded 2145 * either in XYZ or Lab. 2146 */ 2147 temp = png_get_uint_32(profile+20); 2148 switch (temp) 2149 { 2150 case 0x58595a20: /* 'XYZ ' */ 2151 case 0x4c616220: /* 'Lab ' */ 2152 break; 2153 2154 default: 2155 return png_icc_profile_error(png_ptr, colorspace, name, temp, 2156 "unexpected ICC PCS encoding"); 2157 } 2158 2159 return 1; 2160 } 2161 2162 int /* PRIVATE */ 2163 png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace, 2164 png_const_charp name, png_uint_32 profile_length, 2165 png_const_bytep profile /* header plus whole tag table */) 2166 { 2167 png_uint_32 tag_count = png_get_uint_32(profile+128); 2168 png_uint_32 itag; 2169 png_const_bytep tag = profile+132; /* The first tag */ 2170 2171 /* First scan all the tags in the table and add bits to the icc_info value 2172 * (temporarily in 'tags'). 2173 */ 2174 for (itag=0; itag < tag_count; ++itag, tag += 12) 2175 { 2176 png_uint_32 tag_id = png_get_uint_32(tag+0); 2177 png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */ 2178 png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */ 2179 2180 /* The ICC specification does not exclude zero length tags, therefore the 2181 * start might actually be anywhere if there is no data, but this would be 2182 * a clear abuse of the intent of the standard so the start is checked for 2183 * being in range. All defined tag types have an 8 byte header - a 4 byte 2184 * type signature then 0. 2185 */ 2186 if ((tag_start & 3) != 0) 2187 { 2188 /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is 2189 * only a warning here because libpng does not care about the 2190 * alignment. 2191 */ 2192 (void)png_icc_profile_error(png_ptr, NULL, name, tag_id, 2193 "ICC profile tag start not a multiple of 4"); 2194 } 2195 2196 /* This is a hard error; potentially it can cause read outside the 2197 * profile. 2198 */ 2199 if (tag_start > profile_length || tag_length > profile_length - tag_start) 2200 return png_icc_profile_error(png_ptr, colorspace, name, tag_id, 2201 "ICC profile tag outside profile"); 2202 } 2203 2204 return 1; /* success, maybe with warnings */ 2205 } 2206 2207 #ifdef PNG_sRGB_SUPPORTED 2208 #if PNG_sRGB_PROFILE_CHECKS >= 0 2209 /* Information about the known ICC sRGB profiles */ 2210 static const struct 2211 { 2212 png_uint_32 adler, crc, length; 2213 png_uint_32 md5[4]; 2214 png_byte have_md5; 2215 png_byte is_broken; 2216 png_uint_16 intent; 2217 2218 # define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0) 2219 # define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\ 2220 { adler, crc, length, md5, broke, intent }, 2221 2222 } png_sRGB_checks[] = 2223 { 2224 /* This data comes from contrib/tools/checksum-icc run on downloads of 2225 * all four ICC sRGB profiles from www.color.org. 2226 */ 2227 /* adler32, crc32, MD5[4], intent, date, length, file-name */ 2228 PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9, 2229 PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0, 2230 "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc") 2231 2232 /* ICC sRGB v2 perceptual no black-compensation: */ 2233 PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21, 2234 PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0, 2235 "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc") 2236 2237 PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae, 2238 PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0, 2239 "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc") 2240 2241 /* ICC sRGB v4 perceptual */ 2242 PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812, 2243 PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0, 2244 "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc") 2245 2246 /* The following profiles have no known MD5 checksum. If there is a match 2247 * on the (empty) MD5 the other fields are used to attempt a match and 2248 * a warning is produced. The first two of these profiles have a 'cprt' tag 2249 * which suggests that they were also made by Hewlett Packard. 2250 */ 2251 PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce, 2252 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0, 2253 "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc") 2254 2255 /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not 2256 * match the D50 PCS illuminant in the header (it is in fact the D65 values, 2257 * so the white point is recorded as the un-adapted value.) The profiles 2258 * below only differ in one byte - the intent - and are basically the same as 2259 * the previous profile except for the mediaWhitePointTag error and a missing 2260 * chromaticAdaptationTag. 2261 */ 2262 PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552, 2263 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/, 2264 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual") 2265 2266 PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d, 2267 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/, 2268 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative") 2269 }; 2270 2271 static int 2272 png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr, 2273 png_const_bytep profile, uLong adler) 2274 { 2275 /* The quick check is to verify just the MD5 signature and trust the 2276 * rest of the data. Because the profile has already been verified for 2277 * correctness this is safe. png_colorspace_set_sRGB will check the 'intent' 2278 * field too, so if the profile has been edited with an intent not defined 2279 * by sRGB (but maybe defined by a later ICC specification) the read of 2280 * the profile will fail at that point. 2281 */ 2282 2283 png_uint_32 length = 0; 2284 png_uint_32 intent = 0x10000; /* invalid */ 2285 #if PNG_sRGB_PROFILE_CHECKS > 1 2286 uLong crc = 0; /* the value for 0 length data */ 2287 #endif 2288 unsigned int i; 2289 2290 #ifdef PNG_SET_OPTION_SUPPORTED 2291 /* First see if PNG_SKIP_sRGB_CHECK_PROFILE has been set to "on" */ 2292 if (((png_ptr->options >> PNG_SKIP_sRGB_CHECK_PROFILE) & 3) == 2293 PNG_OPTION_ON) 2294 return 0; 2295 #endif 2296 2297 for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i) 2298 { 2299 if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] && 2300 png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] && 2301 png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] && 2302 png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3]) 2303 { 2304 /* This may be one of the old HP profiles without an MD5, in that 2305 * case we can only use the length and Adler32 (note that these 2306 * are not used by default if there is an MD5!) 2307 */ 2308 # if PNG_sRGB_PROFILE_CHECKS == 0 2309 if (png_sRGB_checks[i].have_md5 != 0) 2310 return 1+png_sRGB_checks[i].is_broken; 2311 # endif 2312 2313 /* Profile is unsigned or more checks have been configured in. */ 2314 if (length == 0) 2315 { 2316 length = png_get_uint_32(profile); 2317 intent = png_get_uint_32(profile+64); 2318 } 2319 2320 /* Length *and* intent must match */ 2321 if (length == (png_uint_32) png_sRGB_checks[i].length && 2322 intent == (png_uint_32) png_sRGB_checks[i].intent) 2323 { 2324 /* Now calculate the adler32 if not done already. */ 2325 if (adler == 0) 2326 { 2327 adler = adler32(0, NULL, 0); 2328 adler = adler32(adler, profile, length); 2329 } 2330 2331 if (adler == png_sRGB_checks[i].adler) 2332 { 2333 /* These basic checks suggest that the data has not been 2334 * modified, but if the check level is more than 1 perform 2335 * our own crc32 checksum on the data. 2336 */ 2337 # if PNG_sRGB_PROFILE_CHECKS > 1 2338 if (crc == 0) 2339 { 2340 crc = crc32(0, NULL, 0); 2341 crc = crc32(crc, profile, length); 2342 } 2343 2344 /* So this check must pass for the 'return' below to happen. 2345 */ 2346 if (crc == png_sRGB_checks[i].crc) 2347 # endif 2348 { 2349 if (png_sRGB_checks[i].is_broken != 0) 2350 { 2351 /* These profiles are known to have bad data that may cause 2352 * problems if they are used, therefore attempt to 2353 * discourage their use, skip the 'have_md5' warning below, 2354 * which is made irrelevant by this error. 2355 */ 2356 png_chunk_report(png_ptr, "known incorrect sRGB profile", 2357 PNG_CHUNK_ERROR); 2358 } 2359 2360 /* Warn that this being done; this isn't even an error since 2361 * the profile is perfectly valid, but it would be nice if 2362 * people used the up-to-date ones. 2363 */ 2364 else if (png_sRGB_checks[i].have_md5 == 0) 2365 { 2366 png_chunk_report(png_ptr, 2367 "out-of-date sRGB profile with no signature", 2368 PNG_CHUNK_WARNING); 2369 } 2370 2371 return 1+png_sRGB_checks[i].is_broken; 2372 } 2373 } 2374 2375 # if PNG_sRGB_PROFILE_CHECKS > 0 2376 /* The signature matched, but the profile had been changed in some 2377 * way. This probably indicates a data error or uninformed hacking. 2378 * Fall through to "no match". 2379 */ 2380 png_chunk_report(png_ptr, 2381 "Not recognizing known sRGB profile that has been edited", 2382 PNG_CHUNK_WARNING); 2383 break; 2384 # endif 2385 } 2386 } 2387 } 2388 2389 return 0; /* no match */ 2390 } 2391 #endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */ 2392 2393 void /* PRIVATE */ 2394 png_icc_set_sRGB(png_const_structrp png_ptr, 2395 png_colorspacerp colorspace, png_const_bytep profile, uLong adler) 2396 { 2397 /* Is this profile one of the known ICC sRGB profiles? If it is, just set 2398 * the sRGB information. 2399 */ 2400 #if PNG_sRGB_PROFILE_CHECKS >= 0 2401 if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0) 2402 #endif 2403 (void)png_colorspace_set_sRGB(png_ptr, colorspace, 2404 (int)/*already checked*/png_get_uint_32(profile+64)); 2405 } 2406 #endif /* sRGB */ 2407 2408 int /* PRIVATE */ 2409 png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace, 2410 png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, 2411 int color_type) 2412 { 2413 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) 2414 return 0; 2415 2416 if (icc_check_length(png_ptr, colorspace, name, profile_length) != 0 && 2417 png_icc_check_header(png_ptr, colorspace, name, profile_length, profile, 2418 color_type) != 0 && 2419 png_icc_check_tag_table(png_ptr, colorspace, name, profile_length, 2420 profile) != 0) 2421 { 2422 # ifdef PNG_sRGB_SUPPORTED 2423 /* If no sRGB support, don't try storing sRGB information */ 2424 png_icc_set_sRGB(png_ptr, colorspace, profile, 0); 2425 # endif 2426 return 1; 2427 } 2428 2429 /* Failure case */ 2430 return 0; 2431 } 2432 #endif /* iCCP */ 2433 2434 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 2435 void /* PRIVATE */ 2436 png_colorspace_set_rgb_coefficients(png_structrp png_ptr) 2437 { 2438 /* Set the rgb_to_gray coefficients from the colorspace. */ 2439 if (png_ptr->rgb_to_gray_coefficients_set == 0 && 2440 (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) 2441 { 2442 /* png_set_background has not been called, get the coefficients from the Y 2443 * values of the colorspace colorants. 2444 */ 2445 png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y; 2446 png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y; 2447 png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y; 2448 png_fixed_point total = r+g+b; 2449 2450 if (total > 0 && 2451 r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 && 2452 g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 && 2453 b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 && 2454 r+g+b <= 32769) 2455 { 2456 /* We allow 0 coefficients here. r+g+b may be 32769 if two or 2457 * all of the coefficients were rounded up. Handle this by 2458 * reducing the *largest* coefficient by 1; this matches the 2459 * approach used for the default coefficients in pngrtran.c 2460 */ 2461 int add = 0; 2462 2463 if (r+g+b > 32768) 2464 add = -1; 2465 else if (r+g+b < 32768) 2466 add = 1; 2467 2468 if (add != 0) 2469 { 2470 if (g >= r && g >= b) 2471 g += add; 2472 else if (r >= g && r >= b) 2473 r += add; 2474 else 2475 b += add; 2476 } 2477 2478 /* Check for an internal error. */ 2479 if (r+g+b != 32768) 2480 png_error(png_ptr, 2481 "internal error handling cHRM coefficients"); 2482 2483 else 2484 { 2485 png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r; 2486 png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g; 2487 } 2488 } 2489 2490 /* This is a png_error at present even though it could be ignored - 2491 * it should never happen, but it is important that if it does, the 2492 * bug is fixed. 2493 */ 2494 else 2495 png_error(png_ptr, "internal error handling cHRM->XYZ"); 2496 } 2497 } 2498 #endif /* READ_RGB_TO_GRAY */ 2499 2500 #endif /* COLORSPACE */ 2501 2502 /* #ifdef __GNUC__ */ 2503 #if 1 2504 /* This exists solely to work round a warning from GNU C. */ 2505 static int /* PRIVATE */ 2506 png_gt(size_t a, size_t b) 2507 { 2508 return a > b; 2509 } 2510 #else 2511 # define png_gt(a,b) ((a) > (b)) 2512 #endif 2513 2514 void /* PRIVATE */ 2515 png_check_IHDR(png_const_structrp png_ptr, 2516 png_uint_32 width, png_uint_32 height, int bit_depth, 2517 int color_type, int interlace_type, int compression_type, 2518 int filter_type) 2519 { 2520 int error = 0; 2521 2522 /* Check for width and height valid values */ 2523 if (width == 0) 2524 { 2525 png_warning(png_ptr, "Image width is zero in IHDR"); 2526 error = 1; 2527 } 2528 2529 if (width > PNG_UINT_31_MAX) 2530 { 2531 png_warning(png_ptr, "Invalid image width in IHDR"); 2532 error = 1; 2533 } 2534 2535 if (png_gt(((width + 7) & (~7)), 2536 ((PNG_SIZE_MAX 2537 - 48 /* big_row_buf hack */ 2538 - 1) /* filter byte */ 2539 / 8) /* 8-byte RGBA pixels */ 2540 - 1)) /* extra max_pixel_depth pad */ 2541 { 2542 /* The size of the row must be within the limits of this architecture. 2543 * Because the read code can perform arbitrary transformations the 2544 * maximum size is checked here. Because the code in png_read_start_row 2545 * adds extra space "for safety's sake" in several places a conservative 2546 * limit is used here. 2547 * 2548 * NOTE: it would be far better to check the size that is actually used, 2549 * but the effect in the real world is minor and the changes are more 2550 * extensive, therefore much more dangerous and much more difficult to 2551 * write in a way that avoids compiler warnings. 2552 */ 2553 png_warning(png_ptr, "Image width is too large for this architecture"); 2554 error = 1; 2555 } 2556 2557 #ifdef PNG_SET_USER_LIMITS_SUPPORTED 2558 if (width > png_ptr->user_width_max) 2559 #else 2560 if (width > PNG_USER_WIDTH_MAX) 2561 #endif 2562 { 2563 png_warning(png_ptr, "Image width exceeds user limit in IHDR"); 2564 error = 1; 2565 } 2566 2567 if (height == 0) 2568 { 2569 png_warning(png_ptr, "Image height is zero in IHDR"); 2570 error = 1; 2571 } 2572 2573 if (height > PNG_UINT_31_MAX) 2574 { 2575 png_warning(png_ptr, "Invalid image height in IHDR"); 2576 error = 1; 2577 } 2578 2579 #ifdef PNG_SET_USER_LIMITS_SUPPORTED 2580 if (height > png_ptr->user_height_max) 2581 #else 2582 if (height > PNG_USER_HEIGHT_MAX) 2583 #endif 2584 { 2585 png_warning(png_ptr, "Image height exceeds user limit in IHDR"); 2586 error = 1; 2587 } 2588 2589 /* Check other values */ 2590 if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && 2591 bit_depth != 8 && bit_depth != 16) 2592 { 2593 png_warning(png_ptr, "Invalid bit depth in IHDR"); 2594 error = 1; 2595 } 2596 2597 if (color_type < 0 || color_type == 1 || 2598 color_type == 5 || color_type > 6) 2599 { 2600 png_warning(png_ptr, "Invalid color type in IHDR"); 2601 error = 1; 2602 } 2603 2604 if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || 2605 ((color_type == PNG_COLOR_TYPE_RGB || 2606 color_type == PNG_COLOR_TYPE_GRAY_ALPHA || 2607 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) 2608 { 2609 png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR"); 2610 error = 1; 2611 } 2612 2613 if (interlace_type >= PNG_INTERLACE_LAST) 2614 { 2615 png_warning(png_ptr, "Unknown interlace method in IHDR"); 2616 error = 1; 2617 } 2618 2619 if (compression_type != PNG_COMPRESSION_TYPE_BASE) 2620 { 2621 png_warning(png_ptr, "Unknown compression method in IHDR"); 2622 error = 1; 2623 } 2624 2625 #ifdef PNG_MNG_FEATURES_SUPPORTED 2626 /* Accept filter_method 64 (intrapixel differencing) only if 2627 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and 2628 * 2. Libpng did not read a PNG signature (this filter_method is only 2629 * used in PNG datastreams that are embedded in MNG datastreams) and 2630 * 3. The application called png_permit_mng_features with a mask that 2631 * included PNG_FLAG_MNG_FILTER_64 and 2632 * 4. The filter_method is 64 and 2633 * 5. The color_type is RGB or RGBA 2634 */ 2635 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && 2636 png_ptr->mng_features_permitted != 0) 2637 png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); 2638 2639 if (filter_type != PNG_FILTER_TYPE_BASE) 2640 { 2641 if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 && 2642 (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && 2643 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) && 2644 (color_type == PNG_COLOR_TYPE_RGB || 2645 color_type == PNG_COLOR_TYPE_RGB_ALPHA))) 2646 { 2647 png_warning(png_ptr, "Unknown filter method in IHDR"); 2648 error = 1; 2649 } 2650 2651 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0) 2652 { 2653 png_warning(png_ptr, "Invalid filter method in IHDR"); 2654 error = 1; 2655 } 2656 } 2657 2658 #else 2659 if (filter_type != PNG_FILTER_TYPE_BASE) 2660 { 2661 png_warning(png_ptr, "Unknown filter method in IHDR"); 2662 error = 1; 2663 } 2664 #endif 2665 2666 if (error == 1) 2667 png_error(png_ptr, "Invalid IHDR data"); 2668 } 2669 2670 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) 2671 /* ASCII to fp functions */ 2672 /* Check an ASCII formated floating point value, see the more detailed 2673 * comments in pngpriv.h 2674 */ 2675 /* The following is used internally to preserve the sticky flags */ 2676 #define png_fp_add(state, flags) ((state) |= (flags)) 2677 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY)) 2678 2679 int /* PRIVATE */ 2680 png_check_fp_number(png_const_charp string, png_size_t size, int *statep, 2681 png_size_tp whereami) 2682 { 2683 int state = *statep; 2684 png_size_t i = *whereami; 2685 2686 while (i < size) 2687 { 2688 int type; 2689 /* First find the type of the next character */ 2690 switch (string[i]) 2691 { 2692 case 43: type = PNG_FP_SAW_SIGN; break; 2693 case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break; 2694 case 46: type = PNG_FP_SAW_DOT; break; 2695 case 48: type = PNG_FP_SAW_DIGIT; break; 2696 case 49: case 50: case 51: case 52: 2697 case 53: case 54: case 55: case 56: 2698 case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break; 2699 case 69: 2700 case 101: type = PNG_FP_SAW_E; break; 2701 default: goto PNG_FP_End; 2702 } 2703 2704 /* Now deal with this type according to the current 2705 * state, the type is arranged to not overlap the 2706 * bits of the PNG_FP_STATE. 2707 */ 2708 switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY)) 2709 { 2710 case PNG_FP_INTEGER + PNG_FP_SAW_SIGN: 2711 if ((state & PNG_FP_SAW_ANY) != 0) 2712 goto PNG_FP_End; /* not a part of the number */ 2713 2714 png_fp_add(state, type); 2715 break; 2716 2717 case PNG_FP_INTEGER + PNG_FP_SAW_DOT: 2718 /* Ok as trailer, ok as lead of fraction. */ 2719 if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */ 2720 goto PNG_FP_End; 2721 2722 else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */ 2723 png_fp_add(state, type); 2724 2725 else 2726 png_fp_set(state, PNG_FP_FRACTION | type); 2727 2728 break; 2729 2730 case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT: 2731 if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */ 2732 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); 2733 2734 png_fp_add(state, type | PNG_FP_WAS_VALID); 2735 2736 break; 2737 2738 case PNG_FP_INTEGER + PNG_FP_SAW_E: 2739 if ((state & PNG_FP_SAW_DIGIT) == 0) 2740 goto PNG_FP_End; 2741 2742 png_fp_set(state, PNG_FP_EXPONENT); 2743 2744 break; 2745 2746 /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN: 2747 goto PNG_FP_End; ** no sign in fraction */ 2748 2749 /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT: 2750 goto PNG_FP_End; ** Because SAW_DOT is always set */ 2751 2752 case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT: 2753 png_fp_add(state, type | PNG_FP_WAS_VALID); 2754 break; 2755 2756 case PNG_FP_FRACTION + PNG_FP_SAW_E: 2757 /* This is correct because the trailing '.' on an 2758 * integer is handled above - so we can only get here 2759 * with the sequence ".E" (with no preceding digits). 2760 */ 2761 if ((state & PNG_FP_SAW_DIGIT) == 0) 2762 goto PNG_FP_End; 2763 2764 png_fp_set(state, PNG_FP_EXPONENT); 2765 2766 break; 2767 2768 case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN: 2769 if ((state & PNG_FP_SAW_ANY) != 0) 2770 goto PNG_FP_End; /* not a part of the number */ 2771 2772 png_fp_add(state, PNG_FP_SAW_SIGN); 2773 2774 break; 2775 2776 /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT: 2777 goto PNG_FP_End; */ 2778 2779 case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT: 2780 png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID); 2781 2782 break; 2783 2784 /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E: 2785 goto PNG_FP_End; */ 2786 2787 default: goto PNG_FP_End; /* I.e. break 2 */ 2788 } 2789 2790 /* The character seems ok, continue. */ 2791 ++i; 2792 } 2793 2794 PNG_FP_End: 2795 /* Here at the end, update the state and return the correct 2796 * return code. 2797 */ 2798 *statep = state; 2799 *whereami = i; 2800 2801 return (state & PNG_FP_SAW_DIGIT) != 0; 2802 } 2803 2804 2805 /* The same but for a complete string. */ 2806 int 2807 png_check_fp_string(png_const_charp string, png_size_t size) 2808 { 2809 int state=0; 2810 png_size_t char_index=0; 2811 2812 if (png_check_fp_number(string, size, &state, &char_index) != 0 && 2813 (char_index == size || string[char_index] == 0)) 2814 return state /* must be non-zero - see above */; 2815 2816 return 0; /* i.e. fail */ 2817 } 2818 #endif /* pCAL || sCAL */ 2819 2820 #ifdef PNG_sCAL_SUPPORTED 2821 # ifdef PNG_FLOATING_POINT_SUPPORTED 2822 /* Utility used below - a simple accurate power of ten from an integral 2823 * exponent. 2824 */ 2825 static double 2826 png_pow10(int power) 2827 { 2828 int recip = 0; 2829 double d = 1; 2830 2831 /* Handle negative exponent with a reciprocal at the end because 2832 * 10 is exact whereas .1 is inexact in base 2 2833 */ 2834 if (power < 0) 2835 { 2836 if (power < DBL_MIN_10_EXP) return 0; 2837 recip = 1, power = -power; 2838 } 2839 2840 if (power > 0) 2841 { 2842 /* Decompose power bitwise. */ 2843 double mult = 10; 2844 do 2845 { 2846 if (power & 1) d *= mult; 2847 mult *= mult; 2848 power >>= 1; 2849 } 2850 while (power > 0); 2851 2852 if (recip != 0) d = 1/d; 2853 } 2854 /* else power is 0 and d is 1 */ 2855 2856 return d; 2857 } 2858 2859 /* Function to format a floating point value in ASCII with a given 2860 * precision. 2861 */ 2862 void /* PRIVATE */ 2863 png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size, 2864 double fp, unsigned int precision) 2865 { 2866 /* We use standard functions from math.h, but not printf because 2867 * that would require stdio. The caller must supply a buffer of 2868 * sufficient size or we will png_error. The tests on size and 2869 * the space in ascii[] consumed are indicated below. 2870 */ 2871 if (precision < 1) 2872 precision = DBL_DIG; 2873 2874 /* Enforce the limit of the implementation precision too. */ 2875 if (precision > DBL_DIG+1) 2876 precision = DBL_DIG+1; 2877 2878 /* Basic sanity checks */ 2879 if (size >= precision+5) /* See the requirements below. */ 2880 { 2881 if (fp < 0) 2882 { 2883 fp = -fp; 2884 *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */ 2885 --size; 2886 } 2887 2888 if (fp >= DBL_MIN && fp <= DBL_MAX) 2889 { 2890 int exp_b10; /* A base 10 exponent */ 2891 double base; /* 10^exp_b10 */ 2892 2893 /* First extract a base 10 exponent of the number, 2894 * the calculation below rounds down when converting 2895 * from base 2 to base 10 (multiply by log10(2) - 2896 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to 2897 * be increased. Note that the arithmetic shift 2898 * performs a floor() unlike C arithmetic - using a 2899 * C multiply would break the following for negative 2900 * exponents. 2901 */ 2902 (void)frexp(fp, &exp_b10); /* exponent to base 2 */ 2903 2904 exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */ 2905 2906 /* Avoid underflow here. */ 2907 base = png_pow10(exp_b10); /* May underflow */ 2908 2909 while (base < DBL_MIN || base < fp) 2910 { 2911 /* And this may overflow. */ 2912 double test = png_pow10(exp_b10+1); 2913 2914 if (test <= DBL_MAX) 2915 ++exp_b10, base = test; 2916 2917 else 2918 break; 2919 } 2920 2921 /* Normalize fp and correct exp_b10, after this fp is in the 2922 * range [.1,1) and exp_b10 is both the exponent and the digit 2923 * *before* which the decimal point should be inserted 2924 * (starting with 0 for the first digit). Note that this 2925 * works even if 10^exp_b10 is out of range because of the 2926 * test on DBL_MAX above. 2927 */ 2928 fp /= base; 2929 while (fp >= 1) fp /= 10, ++exp_b10; 2930 2931 /* Because of the code above fp may, at this point, be 2932 * less than .1, this is ok because the code below can 2933 * handle the leading zeros this generates, so no attempt 2934 * is made to correct that here. 2935 */ 2936 2937 { 2938 unsigned int czero, clead, cdigits; 2939 char exponent[10]; 2940 2941 /* Allow up to two leading zeros - this will not lengthen 2942 * the number compared to using E-n. 2943 */ 2944 if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */ 2945 { 2946 czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */ 2947 exp_b10 = 0; /* Dot added below before first output. */ 2948 } 2949 else 2950 czero = 0; /* No zeros to add */ 2951 2952 /* Generate the digit list, stripping trailing zeros and 2953 * inserting a '.' before a digit if the exponent is 0. 2954 */ 2955 clead = czero; /* Count of leading zeros */ 2956 cdigits = 0; /* Count of digits in list. */ 2957 2958 do 2959 { 2960 double d; 2961 2962 fp *= 10; 2963 /* Use modf here, not floor and subtract, so that 2964 * the separation is done in one step. At the end 2965 * of the loop don't break the number into parts so 2966 * that the final digit is rounded. 2967 */ 2968 if (cdigits+czero+1 < precision+clead) 2969 fp = modf(fp, &d); 2970 2971 else 2972 { 2973 d = floor(fp + .5); 2974 2975 if (d > 9) 2976 { 2977 /* Rounding up to 10, handle that here. */ 2978 if (czero > 0) 2979 { 2980 --czero, d = 1; 2981 if (cdigits == 0) --clead; 2982 } 2983 else 2984 { 2985 while (cdigits > 0 && d > 9) 2986 { 2987 int ch = *--ascii; 2988 2989 if (exp_b10 != (-1)) 2990 ++exp_b10; 2991 2992 else if (ch == 46) 2993 { 2994 ch = *--ascii, ++size; 2995 /* Advance exp_b10 to '1', so that the 2996 * decimal point happens after the 2997 * previous digit. 2998 */ 2999 exp_b10 = 1; 3000 } 3001 3002 --cdigits; 3003 d = ch - 47; /* I.e. 1+(ch-48) */ 3004 } 3005 3006 /* Did we reach the beginning? If so adjust the 3007 * exponent but take into account the leading 3008 * decimal point. 3009 */ 3010 if (d > 9) /* cdigits == 0 */ 3011 { 3012 if (exp_b10 == (-1)) 3013 { 3014 /* Leading decimal point (plus zeros?), if 3015 * we lose the decimal point here it must 3016 * be reentered below. 3017 */ 3018 int ch = *--ascii; 3019 3020 if (ch == 46) 3021 ++size, exp_b10 = 1; 3022 3023 /* Else lost a leading zero, so 'exp_b10' is 3024 * still ok at (-1) 3025 */ 3026 } 3027 else 3028 ++exp_b10; 3029 3030 /* In all cases we output a '1' */ 3031 d = 1; 3032 } 3033 } 3034 } 3035 fp = 0; /* Guarantees termination below. */ 3036 } 3037 3038 if (d == 0) 3039 { 3040 ++czero; 3041 if (cdigits == 0) ++clead; 3042 } 3043 else 3044 { 3045 /* Included embedded zeros in the digit count. */ 3046 cdigits += czero - clead; 3047 clead = 0; 3048 3049 while (czero > 0) 3050 { 3051 /* exp_b10 == (-1) means we just output the decimal 3052 * place - after the DP don't adjust 'exp_b10' any 3053 * more! 3054 */ 3055 if (exp_b10 != (-1)) 3056 { 3057 if (exp_b10 == 0) *ascii++ = 46, --size; 3058 /* PLUS 1: TOTAL 4 */ 3059 --exp_b10; 3060 } 3061 *ascii++ = 48, --czero; 3062 } 3063 3064 if (exp_b10 != (-1)) 3065 { 3066 if (exp_b10 == 0) 3067 *ascii++ = 46, --size; /* counted above */ 3068 3069 --exp_b10; 3070 } 3071 *ascii++ = (char)(48 + (int)d), ++cdigits; 3072 } 3073 } 3074 while (cdigits+czero < precision+clead && fp > DBL_MIN); 3075 3076 /* The total output count (max) is now 4+precision */ 3077 3078 /* Check for an exponent, if we don't need one we are 3079 * done and just need to terminate the string. At 3080 * this point exp_b10==(-1) is effectively if flag - it got 3081 * to '-1' because of the decrement after outputting 3082 * the decimal point above (the exponent required is 3083 * *not* -1!) 3084 */ 3085 if (exp_b10 >= (-1) && exp_b10 <= 2) 3086 { 3087 /* The following only happens if we didn't output the 3088 * leading zeros above for negative exponent, so this 3089 * doesn't add to the digit requirement. Note that the 3090 * two zeros here can only be output if the two leading 3091 * zeros were *not* output, so this doesn't increase 3092 * the output count. 3093 */ 3094 while (--exp_b10 >= 0) *ascii++ = 48; 3095 3096 *ascii = 0; 3097 3098 /* Total buffer requirement (including the '\0') is 3099 * 5+precision - see check at the start. 3100 */ 3101 return; 3102 } 3103 3104 /* Here if an exponent is required, adjust size for 3105 * the digits we output but did not count. The total 3106 * digit output here so far is at most 1+precision - no 3107 * decimal point and no leading or trailing zeros have 3108 * been output. 3109 */ 3110 size -= cdigits; 3111 3112 *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */ 3113 3114 /* The following use of an unsigned temporary avoids ambiguities in 3115 * the signed arithmetic on exp_b10 and permits GCC at least to do 3116 * better optimization. 3117 */ 3118 { 3119 unsigned int uexp_b10; 3120 3121 if (exp_b10 < 0) 3122 { 3123 *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */ 3124 uexp_b10 = -exp_b10; 3125 } 3126 3127 else 3128 uexp_b10 = exp_b10; 3129 3130 cdigits = 0; 3131 3132 while (uexp_b10 > 0) 3133 { 3134 exponent[cdigits++] = (char)(48 + uexp_b10 % 10); 3135 uexp_b10 /= 10; 3136 } 3137 } 3138 3139 /* Need another size check here for the exponent digits, so 3140 * this need not be considered above. 3141 */ 3142 if (size > cdigits) 3143 { 3144 while (cdigits > 0) *ascii++ = exponent[--cdigits]; 3145 3146 *ascii = 0; 3147 3148 return; 3149 } 3150 } 3151 } 3152 else if (!(fp >= DBL_MIN)) 3153 { 3154 *ascii++ = 48; /* '0' */ 3155 *ascii = 0; 3156 return; 3157 } 3158 else 3159 { 3160 *ascii++ = 105; /* 'i' */ 3161 *ascii++ = 110; /* 'n' */ 3162 *ascii++ = 102; /* 'f' */ 3163 *ascii = 0; 3164 return; 3165 } 3166 } 3167 3168 /* Here on buffer too small. */ 3169 png_error(png_ptr, "ASCII conversion buffer too small"); 3170 } 3171 3172 # endif /* FLOATING_POINT */ 3173 3174 # ifdef PNG_FIXED_POINT_SUPPORTED 3175 /* Function to format a fixed point value in ASCII. 3176 */ 3177 void /* PRIVATE */ 3178 png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii, 3179 png_size_t size, png_fixed_point fp) 3180 { 3181 /* Require space for 10 decimal digits, a decimal point, a minus sign and a 3182 * trailing \0, 13 characters: 3183 */ 3184 if (size > 12) 3185 { 3186 png_uint_32 num; 3187 3188 /* Avoid overflow here on the minimum integer. */ 3189 if (fp < 0) 3190 *ascii++ = 45, num = -fp; 3191 else 3192 num = fp; 3193 3194 if (num <= 0x80000000) /* else overflowed */ 3195 { 3196 unsigned int ndigits = 0, first = 16 /* flag value */; 3197 char digits[10]; 3198 3199 while (num) 3200 { 3201 /* Split the low digit off num: */ 3202 unsigned int tmp = num/10; 3203 num -= tmp*10; 3204 digits[ndigits++] = (char)(48 + num); 3205 /* Record the first non-zero digit, note that this is a number 3206 * starting at 1, it's not actually the array index. 3207 */ 3208 if (first == 16 && num > 0) 3209 first = ndigits; 3210 num = tmp; 3211 } 3212 3213 if (ndigits > 0) 3214 { 3215 while (ndigits > 5) *ascii++ = digits[--ndigits]; 3216 /* The remaining digits are fractional digits, ndigits is '5' or 3217 * smaller at this point. It is certainly not zero. Check for a 3218 * non-zero fractional digit: 3219 */ 3220 if (first <= 5) 3221 { 3222 unsigned int i; 3223 *ascii++ = 46; /* decimal point */ 3224 /* ndigits may be <5 for small numbers, output leading zeros 3225 * then ndigits digits to first: 3226 */ 3227 i = 5; 3228 while (ndigits < i) *ascii++ = 48, --i; 3229 while (ndigits >= first) *ascii++ = digits[--ndigits]; 3230 /* Don't output the trailing zeros! */ 3231 } 3232 } 3233 else 3234 *ascii++ = 48; 3235 3236 /* And null terminate the string: */ 3237 *ascii = 0; 3238 return; 3239 } 3240 } 3241 3242 /* Here on buffer too small. */ 3243 png_error(png_ptr, "ASCII conversion buffer too small"); 3244 } 3245 # endif /* FIXED_POINT */ 3246 #endif /* SCAL */ 3247 3248 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \ 3249 !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \ 3250 (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \ 3251 defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \ 3252 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \ 3253 (defined(PNG_sCAL_SUPPORTED) && \ 3254 defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)) 3255 png_fixed_point 3256 png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text) 3257 { 3258 double r = floor(100000 * fp + .5); 3259 3260 if (r > 2147483647. || r < -2147483648.) 3261 png_fixed_error(png_ptr, text); 3262 3263 # ifndef PNG_ERROR_TEXT_SUPPORTED 3264 PNG_UNUSED(text) 3265 # endif 3266 3267 return (png_fixed_point)r; 3268 } 3269 #endif 3270 3271 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\ 3272 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) 3273 /* muldiv functions */ 3274 /* This API takes signed arguments and rounds the result to the nearest 3275 * integer (or, for a fixed point number - the standard argument - to 3276 * the nearest .00001). Overflow and divide by zero are signalled in 3277 * the result, a boolean - true on success, false on overflow. 3278 */ 3279 int 3280 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, 3281 png_int_32 divisor) 3282 { 3283 /* Return a * times / divisor, rounded. */ 3284 if (divisor != 0) 3285 { 3286 if (a == 0 || times == 0) 3287 { 3288 *res = 0; 3289 return 1; 3290 } 3291 else 3292 { 3293 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3294 double r = a; 3295 r *= times; 3296 r /= divisor; 3297 r = floor(r+.5); 3298 3299 /* A png_fixed_point is a 32-bit integer. */ 3300 if (r <= 2147483647. && r >= -2147483648.) 3301 { 3302 *res = (png_fixed_point)r; 3303 return 1; 3304 } 3305 #else 3306 int negative = 0; 3307 png_uint_32 A, T, D; 3308 png_uint_32 s16, s32, s00; 3309 3310 if (a < 0) 3311 negative = 1, A = -a; 3312 else 3313 A = a; 3314 3315 if (times < 0) 3316 negative = !negative, T = -times; 3317 else 3318 T = times; 3319 3320 if (divisor < 0) 3321 negative = !negative, D = -divisor; 3322 else 3323 D = divisor; 3324 3325 /* Following can't overflow because the arguments only 3326 * have 31 bits each, however the result may be 32 bits. 3327 */ 3328 s16 = (A >> 16) * (T & 0xffff) + 3329 (A & 0xffff) * (T >> 16); 3330 /* Can't overflow because the a*times bit is only 30 3331 * bits at most. 3332 */ 3333 s32 = (A >> 16) * (T >> 16) + (s16 >> 16); 3334 s00 = (A & 0xffff) * (T & 0xffff); 3335 3336 s16 = (s16 & 0xffff) << 16; 3337 s00 += s16; 3338 3339 if (s00 < s16) 3340 ++s32; /* carry */ 3341 3342 if (s32 < D) /* else overflow */ 3343 { 3344 /* s32.s00 is now the 64-bit product, do a standard 3345 * division, we know that s32 < D, so the maximum 3346 * required shift is 31. 3347 */ 3348 int bitshift = 32; 3349 png_fixed_point result = 0; /* NOTE: signed */ 3350 3351 while (--bitshift >= 0) 3352 { 3353 png_uint_32 d32, d00; 3354 3355 if (bitshift > 0) 3356 d32 = D >> (32-bitshift), d00 = D << bitshift; 3357 3358 else 3359 d32 = 0, d00 = D; 3360 3361 if (s32 > d32) 3362 { 3363 if (s00 < d00) --s32; /* carry */ 3364 s32 -= d32, s00 -= d00, result += 1<<bitshift; 3365 } 3366 3367 else 3368 if (s32 == d32 && s00 >= d00) 3369 s32 = 0, s00 -= d00, result += 1<<bitshift; 3370 } 3371 3372 /* Handle the rounding. */ 3373 if (s00 >= (D >> 1)) 3374 ++result; 3375 3376 if (negative != 0) 3377 result = -result; 3378 3379 /* Check for overflow. */ 3380 if ((negative != 0 && result <= 0) || 3381 (negative == 0 && result >= 0)) 3382 { 3383 *res = result; 3384 return 1; 3385 } 3386 } 3387 #endif 3388 } 3389 } 3390 3391 return 0; 3392 } 3393 #endif /* READ_GAMMA || INCH_CONVERSIONS */ 3394 3395 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) 3396 /* The following is for when the caller doesn't much care about the 3397 * result. 3398 */ 3399 png_fixed_point 3400 png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times, 3401 png_int_32 divisor) 3402 { 3403 png_fixed_point result; 3404 3405 if (png_muldiv(&result, a, times, divisor) != 0) 3406 return result; 3407 3408 png_warning(png_ptr, "fixed point overflow ignored"); 3409 return 0; 3410 } 3411 #endif 3412 3413 #ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */ 3414 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */ 3415 png_fixed_point 3416 png_reciprocal(png_fixed_point a) 3417 { 3418 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3419 double r = floor(1E10/a+.5); 3420 3421 if (r <= 2147483647. && r >= -2147483648.) 3422 return (png_fixed_point)r; 3423 #else 3424 png_fixed_point res; 3425 3426 if (png_muldiv(&res, 100000, 100000, a) != 0) 3427 return res; 3428 #endif 3429 3430 return 0; /* error/overflow */ 3431 } 3432 3433 /* This is the shared test on whether a gamma value is 'significant' - whether 3434 * it is worth doing gamma correction. 3435 */ 3436 int /* PRIVATE */ 3437 png_gamma_significant(png_fixed_point gamma_val) 3438 { 3439 return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED || 3440 gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED; 3441 } 3442 #endif 3443 3444 #ifdef PNG_READ_GAMMA_SUPPORTED 3445 #ifdef PNG_16BIT_SUPPORTED 3446 /* A local convenience routine. */ 3447 static png_fixed_point 3448 png_product2(png_fixed_point a, png_fixed_point b) 3449 { 3450 /* The required result is 1/a * 1/b; the following preserves accuracy. */ 3451 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3452 double r = a * 1E-5; 3453 r *= b; 3454 r = floor(r+.5); 3455 3456 if (r <= 2147483647. && r >= -2147483648.) 3457 return (png_fixed_point)r; 3458 #else 3459 png_fixed_point res; 3460 3461 if (png_muldiv(&res, a, b, 100000) != 0) 3462 return res; 3463 #endif 3464 3465 return 0; /* overflow */ 3466 } 3467 #endif /* 16BIT */ 3468 3469 /* The inverse of the above. */ 3470 png_fixed_point 3471 png_reciprocal2(png_fixed_point a, png_fixed_point b) 3472 { 3473 /* The required result is 1/a * 1/b; the following preserves accuracy. */ 3474 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3475 if (a != 0 && b != 0) 3476 { 3477 double r = 1E15/a; 3478 r /= b; 3479 r = floor(r+.5); 3480 3481 if (r <= 2147483647. && r >= -2147483648.) 3482 return (png_fixed_point)r; 3483 } 3484 #else 3485 /* This may overflow because the range of png_fixed_point isn't symmetric, 3486 * but this API is only used for the product of file and screen gamma so it 3487 * doesn't matter that the smallest number it can produce is 1/21474, not 3488 * 1/100000 3489 */ 3490 png_fixed_point res = png_product2(a, b); 3491 3492 if (res != 0) 3493 return png_reciprocal(res); 3494 #endif 3495 3496 return 0; /* overflow */ 3497 } 3498 #endif /* READ_GAMMA */ 3499 3500 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */ 3501 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED 3502 /* Fixed point gamma. 3503 * 3504 * The code to calculate the tables used below can be found in the shell script 3505 * contrib/tools/intgamma.sh 3506 * 3507 * To calculate gamma this code implements fast log() and exp() calls using only 3508 * fixed point arithmetic. This code has sufficient precision for either 8-bit 3509 * or 16-bit sample values. 3510 * 3511 * The tables used here were calculated using simple 'bc' programs, but C double 3512 * precision floating point arithmetic would work fine. 3513 * 3514 * 8-bit log table 3515 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to 3516 * 255, so it's the base 2 logarithm of a normalized 8-bit floating point 3517 * mantissa. The numbers are 32-bit fractions. 3518 */ 3519 static const png_uint_32 3520 png_8bit_l2[128] = 3521 { 3522 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U, 3523 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U, 3524 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U, 3525 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U, 3526 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U, 3527 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U, 3528 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U, 3529 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U, 3530 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U, 3531 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U, 3532 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U, 3533 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U, 3534 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U, 3535 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U, 3536 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U, 3537 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U, 3538 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U, 3539 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U, 3540 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U, 3541 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U, 3542 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U, 3543 24347096U, 0U 3544 3545 #if 0 3546 /* The following are the values for 16-bit tables - these work fine for the 3547 * 8-bit conversions but produce very slightly larger errors in the 16-bit 3548 * log (about 1.2 as opposed to 0.7 absolute error in the final value). To 3549 * use these all the shifts below must be adjusted appropriately. 3550 */ 3551 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054, 3552 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803, 3553 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068, 3554 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782, 3555 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887, 3556 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339, 3557 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098, 3558 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132, 3559 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415, 3560 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523, 3561 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495, 3562 1119, 744, 372 3563 #endif 3564 }; 3565 3566 static png_int_32 3567 png_log8bit(unsigned int x) 3568 { 3569 unsigned int lg2 = 0; 3570 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log, 3571 * because the log is actually negate that means adding 1. The final 3572 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1 3573 * input), return -1 for the overflow (log 0) case, - so the result is 3574 * always at most 19 bits. 3575 */ 3576 if ((x &= 0xff) == 0) 3577 return -1; 3578 3579 if ((x & 0xf0) == 0) 3580 lg2 = 4, x <<= 4; 3581 3582 if ((x & 0xc0) == 0) 3583 lg2 += 2, x <<= 2; 3584 3585 if ((x & 0x80) == 0) 3586 lg2 += 1, x <<= 1; 3587 3588 /* result is at most 19 bits, so this cast is safe: */ 3589 return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16)); 3590 } 3591 3592 /* The above gives exact (to 16 binary places) log2 values for 8-bit images, 3593 * for 16-bit images we use the most significant 8 bits of the 16-bit value to 3594 * get an approximation then multiply the approximation by a correction factor 3595 * determined by the remaining up to 8 bits. This requires an additional step 3596 * in the 16-bit case. 3597 * 3598 * We want log2(value/65535), we have log2(v'/255), where: 3599 * 3600 * value = v' * 256 + v'' 3601 * = v' * f 3602 * 3603 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128 3604 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less 3605 * than 258. The final factor also needs to correct for the fact that our 8-bit 3606 * value is scaled by 255, whereas the 16-bit values must be scaled by 65535. 3607 * 3608 * This gives a final formula using a calculated value 'x' which is value/v' and 3609 * scaling by 65536 to match the above table: 3610 * 3611 * log2(x/257) * 65536 3612 * 3613 * Since these numbers are so close to '1' we can use simple linear 3614 * interpolation between the two end values 256/257 (result -368.61) and 258/257 3615 * (result 367.179). The values used below are scaled by a further 64 to give 3616 * 16-bit precision in the interpolation: 3617 * 3618 * Start (256): -23591 3619 * Zero (257): 0 3620 * End (258): 23499 3621 */ 3622 #ifdef PNG_16BIT_SUPPORTED 3623 static png_int_32 3624 png_log16bit(png_uint_32 x) 3625 { 3626 unsigned int lg2 = 0; 3627 3628 /* As above, but now the input has 16 bits. */ 3629 if ((x &= 0xffff) == 0) 3630 return -1; 3631 3632 if ((x & 0xff00) == 0) 3633 lg2 = 8, x <<= 8; 3634 3635 if ((x & 0xf000) == 0) 3636 lg2 += 4, x <<= 4; 3637 3638 if ((x & 0xc000) == 0) 3639 lg2 += 2, x <<= 2; 3640 3641 if ((x & 0x8000) == 0) 3642 lg2 += 1, x <<= 1; 3643 3644 /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional 3645 * value. 3646 */ 3647 lg2 <<= 28; 3648 lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4; 3649 3650 /* Now we need to interpolate the factor, this requires a division by the top 3651 * 8 bits. Do this with maximum precision. 3652 */ 3653 x = ((x << 16) + (x >> 9)) / (x >> 8); 3654 3655 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24, 3656 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly 3657 * 16 bits to interpolate to get the low bits of the result. Round the 3658 * answer. Note that the end point values are scaled by 64 to retain overall 3659 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust 3660 * the overall scaling by 6-12. Round at every step. 3661 */ 3662 x -= 1U << 24; 3663 3664 if (x <= 65536U) /* <= '257' */ 3665 lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12); 3666 3667 else 3668 lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12); 3669 3670 /* Safe, because the result can't have more than 20 bits: */ 3671 return (png_int_32)((lg2 + 2048) >> 12); 3672 } 3673 #endif /* 16BIT */ 3674 3675 /* The 'exp()' case must invert the above, taking a 20-bit fixed point 3676 * logarithmic value and returning a 16 or 8-bit number as appropriate. In 3677 * each case only the low 16 bits are relevant - the fraction - since the 3678 * integer bits (the top 4) simply determine a shift. 3679 * 3680 * The worst case is the 16-bit distinction between 65535 and 65534. This 3681 * requires perhaps spurious accuracy in the decoding of the logarithm to 3682 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance 3683 * of getting this accuracy in practice. 3684 * 3685 * To deal with this the following exp() function works out the exponent of the 3686 * frational part of the logarithm by using an accurate 32-bit value from the 3687 * top four fractional bits then multiplying in the remaining bits. 3688 */ 3689 static const png_uint_32 3690 png_32bit_exp[16] = 3691 { 3692 /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */ 3693 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U, 3694 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U, 3695 2553802834U, 2445529972U, 2341847524U, 2242560872U 3696 }; 3697 3698 /* Adjustment table; provided to explain the numbers in the code below. */ 3699 #if 0 3700 for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"} 3701 11 44937.64284865548751208448 3702 10 45180.98734845585101160448 3703 9 45303.31936980687359311872 3704 8 45364.65110595323018870784 3705 7 45395.35850361789624614912 3706 6 45410.72259715102037508096 3707 5 45418.40724413220722311168 3708 4 45422.25021786898173001728 3709 3 45424.17186732298419044352 3710 2 45425.13273269940811464704 3711 1 45425.61317555035558641664 3712 0 45425.85339951654943850496 3713 #endif 3714 3715 static png_uint_32 3716 png_exp(png_fixed_point x) 3717 { 3718 if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */ 3719 { 3720 /* Obtain a 4-bit approximation */ 3721 png_uint_32 e = png_32bit_exp[(x >> 12) & 0x0f]; 3722 3723 /* Incorporate the low 12 bits - these decrease the returned value by 3724 * multiplying by a number less than 1 if the bit is set. The multiplier 3725 * is determined by the above table and the shift. Notice that the values 3726 * converge on 45426 and this is used to allow linear interpolation of the 3727 * low bits. 3728 */ 3729 if (x & 0x800) 3730 e -= (((e >> 16) * 44938U) + 16U) >> 5; 3731 3732 if (x & 0x400) 3733 e -= (((e >> 16) * 45181U) + 32U) >> 6; 3734 3735 if (x & 0x200) 3736 e -= (((e >> 16) * 45303U) + 64U) >> 7; 3737 3738 if (x & 0x100) 3739 e -= (((e >> 16) * 45365U) + 128U) >> 8; 3740 3741 if (x & 0x080) 3742 e -= (((e >> 16) * 45395U) + 256U) >> 9; 3743 3744 if (x & 0x040) 3745 e -= (((e >> 16) * 45410U) + 512U) >> 10; 3746 3747 /* And handle the low 6 bits in a single block. */ 3748 e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9; 3749 3750 /* Handle the upper bits of x. */ 3751 e >>= x >> 16; 3752 return e; 3753 } 3754 3755 /* Check for overflow */ 3756 if (x <= 0) 3757 return png_32bit_exp[0]; 3758 3759 /* Else underflow */ 3760 return 0; 3761 } 3762 3763 static png_byte 3764 png_exp8bit(png_fixed_point lg2) 3765 { 3766 /* Get a 32-bit value: */ 3767 png_uint_32 x = png_exp(lg2); 3768 3769 /* Convert the 32-bit value to 0..255 by multiplying by 256-1. Note that the 3770 * second, rounding, step can't overflow because of the first, subtraction, 3771 * step. 3772 */ 3773 x -= x >> 8; 3774 return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff); 3775 } 3776 3777 #ifdef PNG_16BIT_SUPPORTED 3778 static png_uint_16 3779 png_exp16bit(png_fixed_point lg2) 3780 { 3781 /* Get a 32-bit value: */ 3782 png_uint_32 x = png_exp(lg2); 3783 3784 /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */ 3785 x -= x >> 16; 3786 return (png_uint_16)((x + 32767U) >> 16); 3787 } 3788 #endif /* 16BIT */ 3789 #endif /* FLOATING_ARITHMETIC */ 3790 3791 png_byte 3792 png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val) 3793 { 3794 if (value > 0 && value < 255) 3795 { 3796 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3797 /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly 3798 * convert this to a floating point value. This includes values that 3799 * would overflow if 'value' were to be converted to 'int'. 3800 * 3801 * Apparently GCC, however, does an intermediate conversion to (int) 3802 * on some (ARM) but not all (x86) platforms, possibly because of 3803 * hardware FP limitations. (E.g. if the hardware conversion always 3804 * assumes the integer register contains a signed value.) This results 3805 * in ANSI-C undefined behavior for large values. 3806 * 3807 * Other implementations on the same machine might actually be ANSI-C90 3808 * conformant and therefore compile spurious extra code for the large 3809 * values. 3810 * 3811 * We can be reasonably sure that an unsigned to float conversion 3812 * won't be faster than an int to float one. Therefore this code 3813 * assumes responsibility for the undefined behavior, which it knows 3814 * can't happen because of the check above. 3815 * 3816 * Note the argument to this routine is an (unsigned int) because, on 3817 * 16-bit platforms, it is assigned a value which might be out of 3818 * range for an (int); that would result in undefined behavior in the 3819 * caller if the *argument* ('value') were to be declared (int). 3820 */ 3821 double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5); 3822 return (png_byte)r; 3823 # else 3824 png_int_32 lg2 = png_log8bit(value); 3825 png_fixed_point res; 3826 3827 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0) 3828 return png_exp8bit(res); 3829 3830 /* Overflow. */ 3831 value = 0; 3832 # endif 3833 } 3834 3835 return (png_byte)(value & 0xff); 3836 } 3837 3838 #ifdef PNG_16BIT_SUPPORTED 3839 png_uint_16 3840 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val) 3841 { 3842 if (value > 0 && value < 65535) 3843 { 3844 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3845 /* The same (unsigned int)->(double) constraints apply here as above, 3846 * however in this case the (unsigned int) to (int) conversion can 3847 * overflow on an ANSI-C90 compliant system so the cast needs to ensure 3848 * that this is not possible. 3849 */ 3850 double r = floor(65535*pow((png_int_32)value/65535., 3851 gamma_val*.00001)+.5); 3852 return (png_uint_16)r; 3853 # else 3854 png_int_32 lg2 = png_log16bit(value); 3855 png_fixed_point res; 3856 3857 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0) 3858 return png_exp16bit(res); 3859 3860 /* Overflow. */ 3861 value = 0; 3862 # endif 3863 } 3864 3865 return (png_uint_16)value; 3866 } 3867 #endif /* 16BIT */ 3868 3869 /* This does the right thing based on the bit_depth field of the 3870 * png_struct, interpreting values as 8-bit or 16-bit. While the result 3871 * is nominally a 16-bit value if bit depth is 8 then the result is 3872 * 8-bit (as are the arguments.) 3873 */ 3874 png_uint_16 /* PRIVATE */ 3875 png_gamma_correct(png_structrp png_ptr, unsigned int value, 3876 png_fixed_point gamma_val) 3877 { 3878 if (png_ptr->bit_depth == 8) 3879 return png_gamma_8bit_correct(value, gamma_val); 3880 3881 #ifdef PNG_16BIT_SUPPORTED 3882 else 3883 return png_gamma_16bit_correct(value, gamma_val); 3884 #else 3885 /* should not reach this */ 3886 return 0; 3887 #endif /* 16BIT */ 3888 } 3889 3890 #ifdef PNG_16BIT_SUPPORTED 3891 /* Internal function to build a single 16-bit table - the table consists of 3892 * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount 3893 * to shift the input values right (or 16-number_of_signifiant_bits). 3894 * 3895 * The caller is responsible for ensuring that the table gets cleaned up on 3896 * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument 3897 * should be somewhere that will be cleaned. 3898 */ 3899 static void 3900 png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable, 3901 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) 3902 { 3903 /* Various values derived from 'shift': */ 3904 PNG_CONST unsigned int num = 1U << (8U - shift); 3905 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3906 /* CSE the division and work round wacky GCC warnings (see the comments 3907 * in png_gamma_8bit_correct for where these come from.) 3908 */ 3909 PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1); 3910 #endif 3911 PNG_CONST unsigned int max = (1U << (16U - shift))-1U; 3912 PNG_CONST unsigned int max_by_2 = 1U << (15U-shift); 3913 unsigned int i; 3914 3915 png_uint_16pp table = *ptable = 3916 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p))); 3917 3918 for (i = 0; i < num; i++) 3919 { 3920 png_uint_16p sub_table = table[i] = 3921 (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16))); 3922 3923 /* The 'threshold' test is repeated here because it can arise for one of 3924 * the 16-bit tables even if the others don't hit it. 3925 */ 3926 if (png_gamma_significant(gamma_val) != 0) 3927 { 3928 /* The old code would overflow at the end and this would cause the 3929 * 'pow' function to return a result >1, resulting in an 3930 * arithmetic error. This code follows the spec exactly; ig is 3931 * the recovered input sample, it always has 8-16 bits. 3932 * 3933 * We want input * 65535/max, rounded, the arithmetic fits in 32 3934 * bits (unsigned) so long as max <= 32767. 3935 */ 3936 unsigned int j; 3937 for (j = 0; j < 256; j++) 3938 { 3939 png_uint_32 ig = (j << (8-shift)) + i; 3940 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED 3941 /* Inline the 'max' scaling operation: */ 3942 /* See png_gamma_8bit_correct for why the cast to (int) is 3943 * required here. 3944 */ 3945 double d = floor(65535.*pow(ig*fmax, gamma_val*.00001)+.5); 3946 sub_table[j] = (png_uint_16)d; 3947 # else 3948 if (shift != 0) 3949 ig = (ig * 65535U + max_by_2)/max; 3950 3951 sub_table[j] = png_gamma_16bit_correct(ig, gamma_val); 3952 # endif 3953 } 3954 } 3955 else 3956 { 3957 /* We must still build a table, but do it the fast way. */ 3958 unsigned int j; 3959 3960 for (j = 0; j < 256; j++) 3961 { 3962 png_uint_32 ig = (j << (8-shift)) + i; 3963 3964 if (shift != 0) 3965 ig = (ig * 65535U + max_by_2)/max; 3966 3967 sub_table[j] = (png_uint_16)ig; 3968 } 3969 } 3970 } 3971 } 3972 3973 /* NOTE: this function expects the *inverse* of the overall gamma transformation 3974 * required. 3975 */ 3976 static void 3977 png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable, 3978 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) 3979 { 3980 PNG_CONST unsigned int num = 1U << (8U - shift); 3981 PNG_CONST unsigned int max = (1U << (16U - shift))-1U; 3982 unsigned int i; 3983 png_uint_32 last; 3984 3985 png_uint_16pp table = *ptable = 3986 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p))); 3987 3988 /* 'num' is the number of tables and also the number of low bits of low 3989 * bits of the input 16-bit value used to select a table. Each table is 3990 * itself indexed by the high 8 bits of the value. 3991 */ 3992 for (i = 0; i < num; i++) 3993 table[i] = (png_uint_16p)png_malloc(png_ptr, 3994 256 * (sizeof (png_uint_16))); 3995 3996 /* 'gamma_val' is set to the reciprocal of the value calculated above, so 3997 * pow(out,g) is an *input* value. 'last' is the last input value set. 3998 * 3999 * In the loop 'i' is used to find output values. Since the output is 4000 * 8-bit there are only 256 possible values. The tables are set up to 4001 * select the closest possible output value for each input by finding 4002 * the input value at the boundary between each pair of output values 4003 * and filling the table up to that boundary with the lower output 4004 * value. 4005 * 4006 * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit 4007 * values the code below uses a 16-bit value in i; the values start at 4008 * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last 4009 * entries are filled with 255). Start i at 128 and fill all 'last' 4010 * table entries <= 'max' 4011 */ 4012 last = 0; 4013 for (i = 0; i < 255; ++i) /* 8-bit output value */ 4014 { 4015 /* Find the corresponding maximum input value */ 4016 png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */ 4017 4018 /* Find the boundary value in 16 bits: */ 4019 png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val); 4020 4021 /* Adjust (round) to (16-shift) bits: */ 4022 bound = (bound * max + 32768U)/65535U + 1U; 4023 4024 while (last < bound) 4025 { 4026 table[last & (0xffU >> shift)][last >> (8U - shift)] = out; 4027 last++; 4028 } 4029 } 4030 4031 /* And fill in the final entries. */ 4032 while (last < (num << 8)) 4033 { 4034 table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U; 4035 last++; 4036 } 4037 } 4038 #endif /* 16BIT */ 4039 4040 /* Build a single 8-bit table: same as the 16-bit case but much simpler (and 4041 * typically much faster). Note that libpng currently does no sBIT processing 4042 * (apparently contrary to the spec) so a 256-entry table is always generated. 4043 */ 4044 static void 4045 png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable, 4046 PNG_CONST png_fixed_point gamma_val) 4047 { 4048 unsigned int i; 4049 png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256); 4050 4051 if (png_gamma_significant(gamma_val) != 0) 4052 for (i=0; i<256; i++) 4053 table[i] = png_gamma_8bit_correct(i, gamma_val); 4054 4055 else 4056 for (i=0; i<256; ++i) 4057 table[i] = (png_byte)(i & 0xff); 4058 } 4059 4060 /* Used from png_read_destroy and below to release the memory used by the gamma 4061 * tables. 4062 */ 4063 void /* PRIVATE */ 4064 png_destroy_gamma_table(png_structrp png_ptr) 4065 { 4066 png_free(png_ptr, png_ptr->gamma_table); 4067 png_ptr->gamma_table = NULL; 4068 4069 #ifdef PNG_16BIT_SUPPORTED 4070 if (png_ptr->gamma_16_table != NULL) 4071 { 4072 int i; 4073 int istop = (1 << (8 - png_ptr->gamma_shift)); 4074 for (i = 0; i < istop; i++) 4075 { 4076 png_free(png_ptr, png_ptr->gamma_16_table[i]); 4077 } 4078 png_free(png_ptr, png_ptr->gamma_16_table); 4079 png_ptr->gamma_16_table = NULL; 4080 } 4081 #endif /* 16BIT */ 4082 4083 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ 4084 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ 4085 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) 4086 png_free(png_ptr, png_ptr->gamma_from_1); 4087 png_ptr->gamma_from_1 = NULL; 4088 png_free(png_ptr, png_ptr->gamma_to_1); 4089 png_ptr->gamma_to_1 = NULL; 4090 4091 #ifdef PNG_16BIT_SUPPORTED 4092 if (png_ptr->gamma_16_from_1 != NULL) 4093 { 4094 int i; 4095 int istop = (1 << (8 - png_ptr->gamma_shift)); 4096 for (i = 0; i < istop; i++) 4097 { 4098 png_free(png_ptr, png_ptr->gamma_16_from_1[i]); 4099 } 4100 png_free(png_ptr, png_ptr->gamma_16_from_1); 4101 png_ptr->gamma_16_from_1 = NULL; 4102 } 4103 if (png_ptr->gamma_16_to_1 != NULL) 4104 { 4105 int i; 4106 int istop = (1 << (8 - png_ptr->gamma_shift)); 4107 for (i = 0; i < istop; i++) 4108 { 4109 png_free(png_ptr, png_ptr->gamma_16_to_1[i]); 4110 } 4111 png_free(png_ptr, png_ptr->gamma_16_to_1); 4112 png_ptr->gamma_16_to_1 = NULL; 4113 } 4114 #endif /* 16BIT */ 4115 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ 4116 } 4117 4118 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit 4119 * tables, we don't make a full table if we are reducing to 8-bit in 4120 * the future. Note also how the gamma_16 tables are segmented so that 4121 * we don't need to allocate > 64K chunks for a full 16-bit table. 4122 */ 4123 void /* PRIVATE */ 4124 png_build_gamma_table(png_structrp png_ptr, int bit_depth) 4125 { 4126 png_debug(1, "in png_build_gamma_table"); 4127 4128 /* Remove any existing table; this copes with multiple calls to 4129 * png_read_update_info. The warning is because building the gamma tables 4130 * multiple times is a performance hit - it's harmless but the ability to call 4131 * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible 4132 * to warn if the app introduces such a hit. 4133 */ 4134 if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL) 4135 { 4136 png_warning(png_ptr, "gamma table being rebuilt"); 4137 png_destroy_gamma_table(png_ptr); 4138 } 4139 4140 if (bit_depth <= 8) 4141 { 4142 png_build_8bit_table(png_ptr, &png_ptr->gamma_table, 4143 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, 4144 png_ptr->screen_gamma) : PNG_FP_1); 4145 4146 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ 4147 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ 4148 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) 4149 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0) 4150 { 4151 png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, 4152 png_reciprocal(png_ptr->colorspace.gamma)); 4153 4154 png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1, 4155 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : 4156 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); 4157 } 4158 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ 4159 } 4160 #ifdef PNG_16BIT_SUPPORTED 4161 else 4162 { 4163 png_byte shift, sig_bit; 4164 4165 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) 4166 { 4167 sig_bit = png_ptr->sig_bit.red; 4168 4169 if (png_ptr->sig_bit.green > sig_bit) 4170 sig_bit = png_ptr->sig_bit.green; 4171 4172 if (png_ptr->sig_bit.blue > sig_bit) 4173 sig_bit = png_ptr->sig_bit.blue; 4174 } 4175 else 4176 sig_bit = png_ptr->sig_bit.gray; 4177 4178 /* 16-bit gamma code uses this equation: 4179 * 4180 * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] 4181 * 4182 * Where 'iv' is the input color value and 'ov' is the output value - 4183 * pow(iv, gamma). 4184 * 4185 * Thus the gamma table consists of up to 256 256-entry tables. The table 4186 * is selected by the (8-gamma_shift) most significant of the low 8 bits of 4187 * the color value then indexed by the upper 8 bits: 4188 * 4189 * table[low bits][high 8 bits] 4190 * 4191 * So the table 'n' corresponds to all those 'iv' of: 4192 * 4193 * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1> 4194 * 4195 */ 4196 if (sig_bit > 0 && sig_bit < 16U) 4197 /* shift == insignificant bits */ 4198 shift = (png_byte)((16U - sig_bit) & 0xff); 4199 4200 else 4201 shift = 0; /* keep all 16 bits */ 4202 4203 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0) 4204 { 4205 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively 4206 * the significant bits in the *input* when the output will 4207 * eventually be 8 bits. By default it is 11. 4208 */ 4209 if (shift < (16U - PNG_MAX_GAMMA_8)) 4210 shift = (16U - PNG_MAX_GAMMA_8); 4211 } 4212 4213 if (shift > 8U) 4214 shift = 8U; /* Guarantees at least one table! */ 4215 4216 png_ptr->gamma_shift = shift; 4217 4218 /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now 4219 * PNG_COMPOSE). This effectively smashed the background calculation for 4220 * 16-bit output because the 8-bit table assumes the result will be reduced 4221 * to 8 bits. 4222 */ 4223 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0) 4224 png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, 4225 png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma, 4226 png_ptr->screen_gamma) : PNG_FP_1); 4227 4228 else 4229 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, 4230 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, 4231 png_ptr->screen_gamma) : PNG_FP_1); 4232 4233 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ 4234 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ 4235 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) 4236 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0) 4237 { 4238 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, 4239 png_reciprocal(png_ptr->colorspace.gamma)); 4240 4241 /* Notice that the '16 from 1' table should be full precision, however 4242 * the lookup on this table still uses gamma_shift, so it can't be. 4243 * TODO: fix this. 4244 */ 4245 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift, 4246 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : 4247 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); 4248 } 4249 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ 4250 } 4251 #endif /* 16BIT */ 4252 } 4253 #endif /* READ_GAMMA */ 4254 4255 /* HARDWARE OR SOFTWARE OPTION SUPPORT */ 4256 #ifdef PNG_SET_OPTION_SUPPORTED 4257 int PNGAPI 4258 png_set_option(png_structrp png_ptr, int option, int onoff) 4259 { 4260 if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT && 4261 (option & 1) == 0) 4262 { 4263 int mask = 3 << option; 4264 int setting = (2 + (onoff != 0)) << option; 4265 int current = png_ptr->options; 4266 4267 png_ptr->options = (png_byte)(((current & ~mask) | setting) & 0xff); 4268 4269 return (current & mask) >> option; 4270 } 4271 4272 return PNG_OPTION_INVALID; 4273 } 4274 #endif 4275 4276 /* sRGB support */ 4277 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ 4278 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) 4279 /* sRGB conversion tables; these are machine generated with the code in 4280 * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the 4281 * specification (see the article at http://en.wikipedia.org/wiki/SRGB) 4282 * is used, not the gamma=1/2.2 approximation use elsewhere in libpng. 4283 * The sRGB to linear table is exact (to the nearest 16-bit linear fraction). 4284 * The inverse (linear to sRGB) table has accuracies as follows: 4285 * 4286 * For all possible (255*65535+1) input values: 4287 * 4288 * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact 4289 * 4290 * For the input values corresponding to the 65536 16-bit values: 4291 * 4292 * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact 4293 * 4294 * In all cases the inexact readings are only off by one. 4295 */ 4296 4297 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED 4298 /* The convert-to-sRGB table is only currently required for read. */ 4299 const png_uint_16 png_sRGB_table[256] = 4300 { 4301 0,20,40,60,80,99,119,139, 4302 159,179,199,219,241,264,288,313, 4303 340,367,396,427,458,491,526,562, 4304 599,637,677,718,761,805,851,898, 4305 947,997,1048,1101,1156,1212,1270,1330, 4306 1391,1453,1517,1583,1651,1720,1790,1863, 4307 1937,2013,2090,2170,2250,2333,2418,2504, 4308 2592,2681,2773,2866,2961,3058,3157,3258, 4309 3360,3464,3570,3678,3788,3900,4014,4129, 4310 4247,4366,4488,4611,4736,4864,4993,5124, 4311 5257,5392,5530,5669,5810,5953,6099,6246, 4312 6395,6547,6700,6856,7014,7174,7335,7500, 4313 7666,7834,8004,8177,8352,8528,8708,8889, 4314 9072,9258,9445,9635,9828,10022,10219,10417, 4315 10619,10822,11028,11235,11446,11658,11873,12090, 4316 12309,12530,12754,12980,13209,13440,13673,13909, 4317 14146,14387,14629,14874,15122,15371,15623,15878, 4318 16135,16394,16656,16920,17187,17456,17727,18001, 4319 18277,18556,18837,19121,19407,19696,19987,20281, 4320 20577,20876,21177,21481,21787,22096,22407,22721, 4321 23038,23357,23678,24002,24329,24658,24990,25325, 4322 25662,26001,26344,26688,27036,27386,27739,28094, 4323 28452,28813,29176,29542,29911,30282,30656,31033, 4324 31412,31794,32179,32567,32957,33350,33745,34143, 4325 34544,34948,35355,35764,36176,36591,37008,37429, 4326 37852,38278,38706,39138,39572,40009,40449,40891, 4327 41337,41785,42236,42690,43147,43606,44069,44534, 4328 45002,45473,45947,46423,46903,47385,47871,48359, 4329 48850,49344,49841,50341,50844,51349,51858,52369, 4330 52884,53401,53921,54445,54971,55500,56032,56567, 4331 57105,57646,58190,58737,59287,59840,60396,60955, 4332 61517,62082,62650,63221,63795,64372,64952,65535 4333 }; 4334 #endif /* SIMPLIFIED_READ */ 4335 4336 /* The base/delta tables are required for both read and write (but currently 4337 * only the simplified versions.) 4338 */ 4339 const png_uint_16 png_sRGB_base[512] = 4340 { 4341 128,1782,3383,4644,5675,6564,7357,8074, 4342 8732,9346,9921,10463,10977,11466,11935,12384, 4343 12816,13233,13634,14024,14402,14769,15125,15473, 4344 15812,16142,16466,16781,17090,17393,17690,17981, 4345 18266,18546,18822,19093,19359,19621,19879,20133, 4346 20383,20630,20873,21113,21349,21583,21813,22041, 4347 22265,22487,22707,22923,23138,23350,23559,23767, 4348 23972,24175,24376,24575,24772,24967,25160,25352, 4349 25542,25730,25916,26101,26284,26465,26645,26823, 4350 27000,27176,27350,27523,27695,27865,28034,28201, 4351 28368,28533,28697,28860,29021,29182,29341,29500, 4352 29657,29813,29969,30123,30276,30429,30580,30730, 4353 30880,31028,31176,31323,31469,31614,31758,31902, 4354 32045,32186,32327,32468,32607,32746,32884,33021, 4355 33158,33294,33429,33564,33697,33831,33963,34095, 4356 34226,34357,34486,34616,34744,34873,35000,35127, 4357 35253,35379,35504,35629,35753,35876,35999,36122, 4358 36244,36365,36486,36606,36726,36845,36964,37083, 4359 37201,37318,37435,37551,37668,37783,37898,38013, 4360 38127,38241,38354,38467,38580,38692,38803,38915, 4361 39026,39136,39246,39356,39465,39574,39682,39790, 4362 39898,40005,40112,40219,40325,40431,40537,40642, 4363 40747,40851,40955,41059,41163,41266,41369,41471, 4364 41573,41675,41777,41878,41979,42079,42179,42279, 4365 42379,42478,42577,42676,42775,42873,42971,43068, 4366 43165,43262,43359,43456,43552,43648,43743,43839, 4367 43934,44028,44123,44217,44311,44405,44499,44592, 4368 44685,44778,44870,44962,45054,45146,45238,45329, 4369 45420,45511,45601,45692,45782,45872,45961,46051, 4370 46140,46229,46318,46406,46494,46583,46670,46758, 4371 46846,46933,47020,47107,47193,47280,47366,47452, 4372 47538,47623,47709,47794,47879,47964,48048,48133, 4373 48217,48301,48385,48468,48552,48635,48718,48801, 4374 48884,48966,49048,49131,49213,49294,49376,49458, 4375 49539,49620,49701,49782,49862,49943,50023,50103, 4376 50183,50263,50342,50422,50501,50580,50659,50738, 4377 50816,50895,50973,51051,51129,51207,51285,51362, 4378 51439,51517,51594,51671,51747,51824,51900,51977, 4379 52053,52129,52205,52280,52356,52432,52507,52582, 4380 52657,52732,52807,52881,52956,53030,53104,53178, 4381 53252,53326,53400,53473,53546,53620,53693,53766, 4382 53839,53911,53984,54056,54129,54201,54273,54345, 4383 54417,54489,54560,54632,54703,54774,54845,54916, 4384 54987,55058,55129,55199,55269,55340,55410,55480, 4385 55550,55620,55689,55759,55828,55898,55967,56036, 4386 56105,56174,56243,56311,56380,56448,56517,56585, 4387 56653,56721,56789,56857,56924,56992,57059,57127, 4388 57194,57261,57328,57395,57462,57529,57595,57662, 4389 57728,57795,57861,57927,57993,58059,58125,58191, 4390 58256,58322,58387,58453,58518,58583,58648,58713, 4391 58778,58843,58908,58972,59037,59101,59165,59230, 4392 59294,59358,59422,59486,59549,59613,59677,59740, 4393 59804,59867,59930,59993,60056,60119,60182,60245, 4394 60308,60370,60433,60495,60558,60620,60682,60744, 4395 60806,60868,60930,60992,61054,61115,61177,61238, 4396 61300,61361,61422,61483,61544,61605,61666,61727, 4397 61788,61848,61909,61969,62030,62090,62150,62211, 4398 62271,62331,62391,62450,62510,62570,62630,62689, 4399 62749,62808,62867,62927,62986,63045,63104,63163, 4400 63222,63281,63340,63398,63457,63515,63574,63632, 4401 63691,63749,63807,63865,63923,63981,64039,64097, 4402 64155,64212,64270,64328,64385,64443,64500,64557, 4403 64614,64672,64729,64786,64843,64900,64956,65013, 4404 65070,65126,65183,65239,65296,65352,65409,65465 4405 }; 4406 4407 const png_byte png_sRGB_delta[512] = 4408 { 4409 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54, 4410 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36, 4411 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28, 4412 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24, 4413 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21, 4414 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19, 4415 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17, 4416 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16, 4417 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15, 4418 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14, 4419 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13, 4420 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12, 4421 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12, 4422 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11, 4423 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, 4424 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, 4425 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 4426 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 4427 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, 4428 10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 4429 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 4430 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 4431 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 4432 9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 4433 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 4434 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 4435 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 4436 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 4437 8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7, 4438 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 4439 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 4440 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 4441 }; 4442 #endif /* SIMPLIFIED READ/WRITE sRGB support */ 4443 4444 /* SIMPLIFIED READ/WRITE SUPPORT */ 4445 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ 4446 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) 4447 static int 4448 png_image_free_function(png_voidp argument) 4449 { 4450 png_imagep image = png_voidcast(png_imagep, argument); 4451 png_controlp cp = image->opaque; 4452 png_control c; 4453 4454 /* Double check that we have a png_ptr - it should be impossible to get here 4455 * without one. 4456 */ 4457 if (cp->png_ptr == NULL) 4458 return 0; 4459 4460 /* First free any data held in the control structure. */ 4461 # ifdef PNG_STDIO_SUPPORTED 4462 if (cp->owned_file != 0) 4463 { 4464 FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr); 4465 cp->owned_file = 0; 4466 4467 /* Ignore errors here. */ 4468 if (fp != NULL) 4469 { 4470 cp->png_ptr->io_ptr = NULL; 4471 (void)fclose(fp); 4472 } 4473 } 4474 # endif 4475 4476 /* Copy the control structure so that the original, allocated, version can be 4477 * safely freed. Notice that a png_error here stops the remainder of the 4478 * cleanup, but this is probably fine because that would indicate bad memory 4479 * problems anyway. 4480 */ 4481 c = *cp; 4482 image->opaque = &c; 4483 png_free(c.png_ptr, cp); 4484 4485 /* Then the structures, calling the correct API. */ 4486 if (c.for_write != 0) 4487 { 4488 # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED 4489 png_destroy_write_struct(&c.png_ptr, &c.info_ptr); 4490 # else 4491 png_error(c.png_ptr, "simplified write not supported"); 4492 # endif 4493 } 4494 else 4495 { 4496 # ifdef PNG_SIMPLIFIED_READ_SUPPORTED 4497 png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL); 4498 # else 4499 png_error(c.png_ptr, "simplified read not supported"); 4500 # endif 4501 } 4502 4503 /* Success. */ 4504 return 1; 4505 } 4506 4507 void PNGAPI 4508 png_image_free(png_imagep image) 4509 { 4510 /* Safely call the real function, but only if doing so is safe at this point 4511 * (if not inside an error handling context). Otherwise assume 4512 * png_safe_execute will call this API after the return. 4513 */ 4514 if (image != NULL && image->opaque != NULL && 4515 image->opaque->error_buf == NULL) 4516 { 4517 /* Ignore errors here: */ 4518 (void)png_safe_execute(image, png_image_free_function, image); 4519 image->opaque = NULL; 4520 } 4521 } 4522 4523 int /* PRIVATE */ 4524 png_image_error(png_imagep image, png_const_charp error_message) 4525 { 4526 /* Utility to log an error. */ 4527 png_safecat(image->message, (sizeof image->message), 0, error_message); 4528 image->warning_or_error |= PNG_IMAGE_ERROR; 4529 png_image_free(image); 4530 return 0; 4531 } 4532 4533 #endif /* SIMPLIFIED READ/WRITE */ 4534 #endif /* READ || WRITE */ 4535