2 /* png.c - location for general purpose libpng functions
4 * Last changed in libpng 1.6.25 [September 1, 2016]
5 * Copyright (c) 1998-2002,2004,2006-2016 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.)
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
16 /* Generate a compiler error if there is an old png.h in the search path. */
17 typedef png_libpng_version_1_6_25 Your_png_h_is_not_version_1_6_25;
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.
25 #ifdef PNG_READ_SUPPORTED
27 png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
29 unsigned int nb = (unsigned int)num_bytes;
31 png_debug(1, "in png_set_sig_bytes");
40 png_error(png_ptr, "Too many bytes for PNG signature");
42 png_ptr->sig_bytes = (png_byte)nb;
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).
54 png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
56 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
61 else if (num_to_check < 1)
67 if (start + num_to_check > 8)
68 num_to_check = 8 - start;
70 return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
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)
80 png_alloc_size_t num_bytes = size;
85 if (items >= (~(png_alloc_size_t)0)/size)
87 png_warning (png_voidcast(png_structrp, png_ptr),
88 "Potential overflow in png_zalloc()");
93 return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
96 /* Function to free memory for zlib */
98 png_zfree(voidpf png_ptr, voidpf ptr)
100 png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
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.
107 png_reset_crc(png_structrp png_ptr)
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);
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.
119 png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
123 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
125 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
126 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
132 if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
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.
141 if (need_crc != 0 && length > 0)
143 uLong crc = png_ptr->crc; /* Should never issue a warning */
147 uInt safe_length = (uInt)length;
149 if (safe_length == 0)
150 safe_length = (uInt)-1; /* evil, but safe */
153 crc = crc32(crc, ptr, safe_length);
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.
160 length -= safe_length;
164 /* And the following is always safe because the crc is only 32 bits. */
165 png_ptr->crc = (png_uint_32)crc;
169 /* Check a user supplied version number, called from both read and write
170 * functions that create a png_struct.
173 png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
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.
180 if (user_png_ver != NULL)
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] == '.')
192 } while (found_dots < 2 && user_png_ver[i] != 0 &&
193 PNG_LIBPNG_VER_STRING[i] != 0);
197 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
199 if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
201 #ifdef PNG_WARNINGS_SUPPORTED
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);
212 png_warning(png_ptr, m);
215 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
222 /* Success return. */
226 /* Generic function to create a png_struct for either read or write - this
227 * contains the common initialization.
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)
234 png_struct create_struct;
235 # ifdef PNG_SETJMP_SUPPORTED
236 jmp_buf create_jmp_buf;
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)
243 memset(&create_struct, 0, (sizeof create_struct));
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;
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;
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.
259 create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
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.
266 # ifdef PNG_USER_MEM_SUPPORTED
267 png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
270 PNG_UNUSED(malloc_fn)
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
279 png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
281 # ifdef PNG_SETJMP_SUPPORTED
282 if (!setjmp(create_jmp_buf))
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
291 create_struct.jmp_buf_ptr = &create_jmp_buf;
292 create_struct.jmp_buf_size = 0; /*stack allocation*/
293 create_struct.longjmp_fn = longjmp;
295 /* Call the general version checker (shared with read and write code):
297 if (png_user_version_check(&create_struct, user_png_ver) != 0)
299 png_structrp png_ptr = png_voidcast(png_structrp,
300 png_malloc_warn(&create_struct, (sizeof *png_ptr)));
304 /* png_ptr->zstream holds a back-pointer to the png_struct, so
305 * this can only be done now:
307 create_struct.zstream.zalloc = png_zalloc;
308 create_struct.zstream.zfree = png_zfree;
309 create_struct.zstream.opaque = png_ptr;
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;
318 *png_ptr = create_struct;
320 /* This is the successful return point */
326 /* A longjmp because of a bug in the application storage allocator or a
327 * simple failure to allocate the png_struct.
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)
338 png_debug(1, "in png_create_info_struct");
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'.
348 info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
349 (sizeof *info_ptr)));
351 if (info_ptr != NULL)
352 memset(info_ptr, 0, (sizeof *info_ptr));
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
366 png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
368 png_inforp info_ptr = NULL;
370 png_debug(1, "in png_destroy_info_struct");
375 if (info_ptr_ptr != NULL)
376 info_ptr = *info_ptr_ptr;
378 if (info_ptr != NULL)
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
386 *info_ptr_ptr = NULL;
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);
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
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.
403 PNG_FUNCTION(void,PNGAPI
404 png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
407 png_inforp info_ptr = *ptr_ptr;
409 png_debug(1, "in png_info_init_3");
411 if (info_ptr == NULL)
414 if ((sizeof (png_info)) > png_info_struct_size)
417 /* The following line is why this API should not be used: */
419 info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
420 (sizeof *info_ptr)));
421 if (info_ptr == NULL)
426 /* Set everything to 0 */
427 memset(info_ptr, 0, (sizeof *info_ptr));
430 /* The following API is not called internally */
432 png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
433 int freer, png_uint_32 mask)
435 png_debug(1, "in png_data_freer");
437 if (png_ptr == NULL || info_ptr == NULL)
440 if (freer == PNG_DESTROY_WILL_FREE_DATA)
441 info_ptr->free_me |= mask;
443 else if (freer == PNG_USER_WILL_FREE_DATA)
444 info_ptr->free_me &= ~mask;
447 png_error(png_ptr, "Unknown freer parameter in png_data_freer");
451 png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
454 png_debug(1, "in png_free_data");
456 if (png_ptr == NULL || info_ptr == NULL)
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)
466 png_free(png_ptr, info_ptr->text[num].key);
467 info_ptr->text[num].key = NULL;
474 for (i = 0; i < info_ptr->num_text; i++)
475 png_free(png_ptr, info_ptr->text[i].key);
477 png_free(png_ptr, info_ptr->text);
478 info_ptr->text = NULL;
479 info_ptr->num_text = 0;
484 #ifdef PNG_tRNS_SUPPORTED
485 /* Free any tRNS entry */
486 if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
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;
495 #ifdef PNG_sCAL_SUPPORTED
496 /* Free any sCAL entry */
497 if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
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;
507 #ifdef PNG_pCAL_SUPPORTED
508 /* Free any pCAL entry */
509 if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
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;
516 if (info_ptr->pcal_params != NULL)
520 for (i = 0; i < info_ptr->pcal_nparams; i++)
521 png_free(png_ptr, info_ptr->pcal_params[i]);
523 png_free(png_ptr, info_ptr->pcal_params);
524 info_ptr->pcal_params = NULL;
526 info_ptr->valid &= ~PNG_INFO_pCAL;
530 #ifdef PNG_iCCP_SUPPORTED
531 /* Free any profile entry */
532 if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
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;
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)
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;
559 for (i = 0; i < info_ptr->splt_palettes_num; i++)
561 png_free(png_ptr, info_ptr->splt_palettes[i].name);
562 png_free(png_ptr, info_ptr->splt_palettes[i].entries);
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;
573 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
574 if (info_ptr->unknown_chunks != 0 &&
575 ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
579 png_free(png_ptr, info_ptr->unknown_chunks[num].data);
580 info_ptr->unknown_chunks[num].data = NULL;
587 for (i = 0; i < info_ptr->unknown_chunks_num; i++)
588 png_free(png_ptr, info_ptr->unknown_chunks[i].data);
590 png_free(png_ptr, info_ptr->unknown_chunks);
591 info_ptr->unknown_chunks = NULL;
592 info_ptr->unknown_chunks_num = 0;
597 #ifdef PNG_hIST_SUPPORTED
598 /* Free any hIST entry */
599 if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
601 png_free(png_ptr, info_ptr->hist);
602 info_ptr->hist = NULL;
603 info_ptr->valid &= ~PNG_INFO_hIST;
607 /* Free any PLTE entry that was internally allocated */
608 if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
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;
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)
620 if (info_ptr->row_pointers != 0)
623 for (row = 0; row < info_ptr->height; row++)
624 png_free(png_ptr, info_ptr->row_pointers[row]);
626 png_free(png_ptr, info_ptr->row_pointers);
627 info_ptr->row_pointers = NULL;
629 info_ptr->valid &= ~PNG_INFO_IDAT;
634 mask &= ~PNG_FREE_MUL;
636 info_ptr->free_me &= ~mask;
638 #endif /* READ || WRITE */
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.
645 png_get_io_ptr(png_const_structrp png_ptr)
650 return (png_ptr->io_ptr);
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.
662 png_init_io(png_structrp png_ptr, png_FILE_p fp)
664 png_debug(1, "in png_init_io");
669 png_ptr->io_ptr = (png_voidp)fp;
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:
678 * (UNSIGNED_MAX+1) + integer
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.
685 png_save_int_32(png_bytep buf, png_int_32 i)
687 png_save_uint_32(buf, i);
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.
696 png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
698 static PNG_CONST char short_months[12][4] =
699 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
700 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
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 ||
714 char number_buf[5]; /* enough for a four-digit year */
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)
721 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
723 APPEND_STRING(short_months[(ptime->month - 1)]);
725 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
727 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
729 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
731 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
732 APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
736 # undef APPEND_NUMBER
737 # undef APPEND_STRING
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.
749 png_const_charp PNGAPI
750 png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)
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");
759 return png_ptr->time_buffer;
764 # endif /* LIBPNG_VER < 10700 */
765 # endif /* TIME_RFC1123 */
767 #endif /* READ || WRITE */
769 png_const_charp PNGAPI
770 png_get_copyright(png_const_structrp png_ptr)
772 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
773 #ifdef PNG_STRING_COPYRIGHT
774 return PNG_STRING_COPYRIGHT
777 return PNG_STRING_NEWLINE \
778 "libpng version 1.6.25 - September 1, 2016" PNG_STRING_NEWLINE \
779 "Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson" \
781 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
782 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
785 return "libpng version 1.6.25 - September 1, 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.";
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.
801 png_const_charp PNGAPI
802 png_get_libpng_ver(png_const_structrp png_ptr)
804 /* Version of *.c files used when building libpng */
805 return png_get_header_ver(png_ptr);
808 png_const_charp PNGAPI
809 png_get_header_ver(png_const_structrp png_ptr)
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;
816 png_const_charp PNGAPI
817 png_get_header_version(png_const_structrp png_ptr)
819 /* Returns longer string containing both version and date */
820 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
822 return PNG_HEADER_VERSION_STRING
823 # ifndef PNG_READ_SUPPORTED
828 return PNG_HEADER_VERSION_STRING;
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.
840 png_build_grayscale_palette(int bit_depth, png_colorp palette)
847 png_debug(1, "in png_do_build_grayscale_palette");
880 for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
882 palette[i].red = (png_byte)(v & 0xff);
883 palette[i].green = (png_byte)(v & 0xff);
884 palette[i].blue = (png_byte)(v & 0xff);
889 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
891 png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
893 /* Check chunk_name and return "keep" value if it's on the list, else 0 */
894 png_const_bytep p, p_end;
896 if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
897 return PNG_HANDLE_CHUNK_AS_DEFAULT;
899 p_end = png_ptr->chunk_list;
900 p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
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.
906 do /* num_chunk_list > 0, so at least one */
910 if (memcmp(chunk_name, p, 4) == 0)
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
920 return PNG_HANDLE_CHUNK_AS_DEFAULT;
923 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
924 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
926 png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
928 png_byte chunk_string[5];
930 PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
931 return png_handle_as_unknown(png_ptr, chunk_string);
933 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
934 #endif /* SET_UNKNOWN_CHUNKS */
936 #ifdef PNG_READ_SUPPORTED
937 /* This function, added to libpng-1.0.6g, is untested. */
939 png_reset_zstream(png_structrp png_ptr)
942 return Z_STREAM_ERROR;
944 /* WARNING: this resets the window bits to the maximum! */
945 return (inflateReset(&png_ptr->zstream));
949 /* This function was added to libpng-1.0.7 */
951 png_access_version_number(void)
953 /* Version of *.c files used when building libpng */
954 return((png_uint_32)PNG_LIBPNG_VER);
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.
963 png_zstream_error(png_structrp png_ptr, int ret)
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.
969 if (png_ptr->zstream.msg == NULL) switch (ret)
973 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
978 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
982 /* This means the deflate stream did not have a dictionary; this
983 * indicates a bogus PNG.
985 png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
989 /* gz APIs only: should not happen */
990 png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
994 /* internal libpng error */
995 png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
999 png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
1003 png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
1007 /* End of input or output; not a problem if the caller is doing
1008 * incremental read or write.
1010 png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
1013 case Z_VERSION_ERROR:
1014 png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
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".
1023 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
1028 /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
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 */
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.
1040 * 'from' says where the new gamma value comes from:
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
1047 png_fixed_point gtest;
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))
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.
1059 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
1061 png_chunk_report(png_ptr, "gamma value does not match sRGB",
1063 /* Do not overwrite an sRGB value */
1067 else /* sRGB tag not involved */
1069 png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
1079 png_colorspace_set_gamma(png_const_structrp png_ptr,
1080 png_colorspacerp colorspace, png_fixed_point gAMA)
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.)
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.
1093 png_const_charp errmsg;
1095 if (gAMA < 16 || gAMA > 625000000)
1096 errmsg = "gamma value out of range";
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";
1105 /* Do nothing if the colorspace is already invalid */
1106 else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
1111 if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
1112 1/*from gAMA*/) != 0)
1114 /* Store this gamma value. */
1115 colorspace->gamma = gAMA;
1116 colorspace->flags |=
1117 (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
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.
1128 /* Error exit - errmsg has been set. */
1129 colorspace->flags |= PNG_COLORSPACE_INVALID;
1130 png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
1134 png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
1136 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
1138 /* Everything is invalid */
1139 info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
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*/);
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.
1157 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
1158 info_ptr->valid |= PNG_INFO_sRGB;
1161 info_ptr->valid &= ~PNG_INFO_sRGB;
1163 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
1164 info_ptr->valid |= PNG_INFO_cHRM;
1167 info_ptr->valid &= ~PNG_INFO_cHRM;
1170 if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
1171 info_ptr->valid |= PNG_INFO_gAMA;
1174 info_ptr->valid &= ~PNG_INFO_gAMA;
1178 #ifdef PNG_READ_SUPPORTED
1180 png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
1182 if (info_ptr == NULL) /* reduce code size; check here not in the caller */
1185 info_ptr->colorspace = png_ptr->colorspace;
1186 png_colorspace_sync_info(png_ptr, info_ptr);
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.
1198 png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
1200 png_int_32 d, dwhite, whiteX, whiteY;
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)
1205 if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0)
1208 whiteX = XYZ->red_X;
1209 whiteY = XYZ->red_Y;
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)
1214 if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0)
1217 whiteX += XYZ->green_X;
1218 whiteY += XYZ->green_Y;
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)
1223 if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0)
1226 whiteX += XYZ->blue_X;
1227 whiteY += XYZ->blue_Y;
1229 /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
1232 if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0)
1234 if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0)
1241 png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
1243 png_fixed_point red_inverse, green_inverse, blue_scale;
1244 png_fixed_point left, right, denominator;
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.
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;
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.
1267 * Think of the original end-points as points in (X,Y,Z) space. The
1268 * chromaticity values (c) have the property:
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
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.
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:
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
1296 * But cHRM records only white-x and white-y, so we have lost the white scale
1299 * white-C = white-c*white-scale
1301 * To handle this the inverse transformation makes an arbitrary assumption
1302 * about white-scale:
1304 * Assume: white-Y = 1.0
1305 * Hence: white-scale = 1/white-y
1306 * Or: red-Y + green-Y + blue-Y = 1.0
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
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
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
1326 * So this code uses the perhaps slightly less optimal but more
1327 * understandable and totally obvious approach of calculating color-scale.
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.
1333 * libpng arithmetic: a simple inversion of the above equations
1334 * ------------------------------------------------------------
1336 * white_scale = 1/white-y
1337 * white-X = white-x * white-scale
1339 * white-Z = (1 - white-x - white-y) * white_scale
1341 * white-C = red-C + green-C + blue-C
1342 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
1344 * This gives us three equations in (red-scale,green-scale,blue-scale) where
1345 * all the coefficients are now known:
1347 * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
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
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:
1356 * red-scale + green-scale + blue-scale = 1/white-y = white-scale
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:
1366 * blue-scale = white-scale - red-scale - green-scale
1370 * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
1371 * (white-x - blue-x)*white-scale
1373 * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
1374 * 1 - blue-y*white-scale
1376 * And now we can trivially solve for (red-scale,green-scale):
1379 * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
1380 * -----------------------------------------------------------
1384 * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
1385 * ---------------------------------------------------------
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)
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)
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.
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.
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:
1420 * red numerator: -0.04751
1421 * green numerator: -0.08788
1422 * denominator: -0.2241 (without white-y multiplication)
1424 * The resultant Y coefficients from the chromaticities of some widely used
1425 * color space definitions are (to 15 decimal places):
1428 * 0.212639005871510 0.715168678767756 0.072192315360734
1430 * 0.288071128229293 0.711843217810102 0.000085653960605
1432 * 0.297344975250536 0.627363566255466 0.075291458493998
1433 * Adobe Wide Gamut RGB
1434 * 0.258728243040113 0.724682314948566 0.016589442011321
1436 /* By the argument, above overflow should be impossible here. The return
1437 * value of 2 indicates an internal error to the caller.
1439 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0)
1441 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0)
1443 denominator = left - right;
1445 /* Now find the red numerator. */
1446 if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
1448 if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
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.
1456 if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 ||
1457 red_inverse <= xy->whitey /* r+g+b scales = white scale */)
1460 /* Similarly for green_inverse: */
1461 if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
1463 if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
1465 if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 ||
1466 green_inverse <= xy->whitey)
1469 /* And the blue scale, the checks above guarantee this can't overflow but it
1470 * can still produce 0 for extreme cHRM values.
1472 blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
1473 png_reciprocal(green_inverse);
1474 if (blue_scale <= 0)
1478 /* And fill in the png_XYZ: */
1479 if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0)
1481 if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0)
1483 if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
1487 if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0)
1489 if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0)
1491 if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
1492 green_inverse) == 0)
1495 if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0)
1497 if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0)
1499 if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
1503 return 0; /*success*/
1507 png_XYZ_normalize(png_XYZ *XYZ)
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)
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
1522 if (0x7fffffff - Y < XYZ->green_X)
1525 if (0x7fffffff - Y < XYZ->blue_X)
1531 if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0)
1533 if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0)
1535 if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0)
1538 if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0)
1540 if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0)
1542 if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0)
1545 if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0)
1547 if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0)
1549 if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0)
1557 png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
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))
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.
1583 png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
1588 /* As a side-effect this routine also returns the XYZ endpoints. */
1589 result = png_XYZ_from_xy(XYZ, xy);
1593 result = png_xy_from_XYZ(&xy_test, XYZ);
1597 if (png_colorspace_endpoints_match(xy, &xy_test,
1598 5/*actually, the math is pretty accurate*/) != 0)
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.
1609 png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
1614 result = png_XYZ_normalize(XYZ);
1618 result = png_xy_from_XYZ(xy, XYZ);
1623 return png_colorspace_check_xy(&XYZtemp, xy);
1626 /* Used to check for an endpoint match against sRGB */
1627 static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
1630 /* red */ 64000, 33000,
1631 /* green */ 30000, 60000,
1632 /* blue */ 15000, 6000,
1633 /* white */ 31270, 32900
1637 png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
1638 png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
1641 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
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
1648 if (preferred < 2 &&
1649 (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
1651 /* The end points must be reasonably close to any we already have. The
1652 * following allows an error of up to +/-.001
1654 if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
1657 colorspace->flags |= PNG_COLORSPACE_INVALID;
1658 png_benign_error(png_ptr, "inconsistent chromaticities");
1659 return 0; /* failed */
1662 /* Only overwrite with preferred values */
1664 return 1; /* ok, but no change */
1667 colorspace->end_points_xy = *xy;
1668 colorspace->end_points_XYZ = *XYZ;
1669 colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;
1671 /* The end points are normally quoted to two decimal digits, so allow +/-0.01
1674 if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
1675 colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
1678 colorspace->flags &= PNG_COLORSPACE_CANCEL(
1679 PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
1681 return 2; /* ok and changed */
1685 png_colorspace_set_chromaticities(png_const_structrp png_ptr,
1686 png_colorspacerp colorspace, const png_xy *xy, int preferred)
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.
1696 switch (png_colorspace_check_xy(&XYZ, xy))
1698 case 0: /* success */
1699 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
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.
1706 colorspace->flags |= PNG_COLORSPACE_INVALID;
1707 png_benign_error(png_ptr, "invalid chromaticities");
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.
1714 colorspace->flags |= PNG_COLORSPACE_INVALID;
1715 png_error(png_ptr, "internal error checking chromaticities");
1718 return 0; /* failed */
1722 png_colorspace_set_endpoints(png_const_structrp png_ptr,
1723 png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
1725 png_XYZ XYZ = *XYZ_in;
1728 switch (png_colorspace_check_XYZ(&xy, &XYZ))
1731 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
1735 /* End points are invalid. */
1736 colorspace->flags |= PNG_COLORSPACE_INVALID;
1737 png_benign_error(png_ptr, "invalid end points");
1741 colorspace->flags |= PNG_COLORSPACE_INVALID;
1742 png_error(png_ptr, "internal error checking chromaticities");
1745 return 0; /* failed */
1748 #if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)
1749 /* Error message generation */
1751 png_icc_tag_char(png_uint_32 byte)
1754 if (byte >= 32 && byte <= 126)
1761 png_icc_tag_name(char *name, png_uint_32 tag)
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 );
1772 is_ICC_signature_char(png_alloc_size_t it)
1774 return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||
1775 (it >= 97 && it <= 122);
1779 is_ICC_signature(png_alloc_size_t it)
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);
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)
1792 char message[196]; /* see below for calculation */
1794 if (colorspace != NULL)
1795 colorspace->flags |= PNG_COLORSPACE_INVALID;
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)
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++] = ' ';
1808 # ifdef PNG_WARNINGS_SUPPORTED
1811 char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
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*/
1819 /* The 'reason' is an arbitrary message, allow +79 maximum 195 */
1820 pos = png_safecat(message, (sizeof message), pos, reason);
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.)
1828 png_chunk_report(png_ptr, message,
1829 (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
1833 #endif /* sRGB || iCCP */
1835 #ifdef PNG_sRGB_SUPPORTED
1837 png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
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.
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.)
1852 static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
1855 /* red */ 41239, 21264, 1933,
1856 /* green */ 35758, 71517, 11919,
1857 /* blue */ 18048, 7219, 95053
1860 /* Do nothing if the colorspace is already invalidated. */
1861 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
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
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");
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");
1882 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
1884 png_benign_error(png_ptr, "duplicate sRGB information ignored");
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.
1891 if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
1892 !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
1894 png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
1897 /* This check is just done for the error reporting - the routine always
1898 * returns true when the 'from' argument corresponds to sRGB (2).
1900 (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
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;
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);
1914 colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
1915 colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
1917 /* Finally record that we have an sRGB profile */
1918 colorspace->flags |=
1919 (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
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:
1929 * (63189.8112, 65536, 54060.6464)
1931 static const png_byte D50_nCIEXYZ[12] =
1932 { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };
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)
1938 if (profile_length < 132)
1939 return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
1945 #ifdef PNG_READ_iCCP_SUPPORTED
1947 png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
1948 png_const_charp name, png_uint_32 profile_length)
1950 if (!icc_check_length(png_ptr, colorspace, name, profile_length))
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).
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 */
1977 #endif /* READ_iCCP */
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)
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.
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");
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,
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");
2007 /* The 'intent' must be valid or we can't store it, ICC limits the intent to
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");
2015 /* This is just a warning because the profile may be valid in future
2018 if (temp >= PNG_sRGB_INTENT_LAST)
2019 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2020 "intent outside defined range");
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!)
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
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");
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.
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");
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
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.
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.
2070 temp = png_get_uint_32(profile+16); /* data colour space field */
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");
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");
2086 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2087 "invalid ICC profile color space");
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.
2099 temp = png_get_uint_32(profile+12); /* profile/device class */
2102 case 0x73636e72: /* 'scnr' */
2103 case 0x6d6e7472: /* 'mntr' */
2104 case 0x70727472: /* 'prtr' */
2105 case 0x73706163: /* 'spac' */
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");
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
2121 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2122 "unexpected DeviceLink ICC profile class");
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.
2129 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2130 "unexpected NamedColor ICC profile class");
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.
2139 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
2140 "unrecognized ICC profile class");
2144 /* For any profile other than a device link one the PCS must be encoded
2145 * either in XYZ or Lab.
2147 temp = png_get_uint_32(profile+20);
2150 case 0x58595a20: /* 'XYZ ' */
2151 case 0x4c616220: /* 'Lab ' */
2155 return png_icc_profile_error(png_ptr, colorspace, name, temp,
2156 "unexpected ICC PCS encoding");
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 */)
2167 png_uint_32 tag_count = png_get_uint_32(profile+128);
2169 png_const_bytep tag = profile+132; /* The first tag */
2171 /* First scan all the tags in the table and add bits to the icc_info value
2172 * (temporarily in 'tags').
2174 for (itag=0; itag < tag_count; ++itag, tag += 12)
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 */
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.
2186 if ((tag_start & 3) != 0)
2188 /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is
2189 * only a warning here because libpng does not care about the
2192 (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
2193 "ICC profile tag start not a multiple of 4");
2196 /* This is a hard error; potentially it can cause read outside the
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");
2204 return 1; /* success, maybe with warnings */
2207 #ifdef PNG_sRGB_SUPPORTED
2208 #if PNG_sRGB_PROFILE_CHECKS >= 0
2209 /* Information about the known ICC sRGB profiles */
2212 png_uint_32 adler, crc, length;
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 },
2222 } png_sRGB_checks[] =
2224 /* This data comes from contrib/tools/checksum-icc run on downloads of
2225 * all four ICC sRGB profiles from www.color.org.
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")
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")
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")
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")
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.
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")
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.
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")
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")
2272 png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
2273 png_const_bytep profile, uLong adler)
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.
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 */
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) ==
2297 for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)
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])
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!)
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;
2313 /* Profile is unsigned or more checks have been configured in. */
2316 length = png_get_uint_32(profile);
2317 intent = png_get_uint_32(profile+64);
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)
2324 /* Now calculate the adler32 if not done already. */
2327 adler = adler32(0, NULL, 0);
2328 adler = adler32(adler, profile, length);
2331 if (adler == png_sRGB_checks[i].adler)
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.
2337 # if PNG_sRGB_PROFILE_CHECKS > 1
2340 crc = crc32(0, NULL, 0);
2341 crc = crc32(crc, profile, length);
2344 /* So this check must pass for the 'return' below to happen.
2346 if (crc == png_sRGB_checks[i].crc)
2349 if (png_sRGB_checks[i].is_broken != 0)
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.
2356 png_chunk_report(png_ptr, "known incorrect sRGB profile",
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.
2364 else if (png_sRGB_checks[i].have_md5 == 0)
2366 png_chunk_report(png_ptr,
2367 "out-of-date sRGB profile with no signature",
2371 return 1+png_sRGB_checks[i].is_broken;
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".
2380 png_chunk_report(png_ptr,
2381 "Not recognizing known sRGB profile that has been edited",
2389 return 0; /* no match */
2393 png_icc_set_sRGB(png_const_structrp png_ptr,
2394 png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
2396 /* Is this profile one of the known ICC sRGB profiles? If it is, just set
2397 * the sRGB information.
2399 if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
2400 (void)png_colorspace_set_sRGB(png_ptr, colorspace,
2401 (int)/*already checked*/png_get_uint_32(profile+64));
2403 #endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
2407 png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
2408 png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
2411 if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
2414 if (icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
2415 png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
2417 png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
2420 # if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
2421 /* If no sRGB support, don't try storing sRGB information */
2422 png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
2432 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2434 png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
2436 /* Set the rgb_to_gray coefficients from the colorspace. */
2437 if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
2438 (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
2440 /* png_set_background has not been called, get the coefficients from the Y
2441 * values of the colorspace colorants.
2443 png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
2444 png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
2445 png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
2446 png_fixed_point total = r+g+b;
2449 r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
2450 g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
2451 b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
2454 /* We allow 0 coefficients here. r+g+b may be 32769 if two or
2455 * all of the coefficients were rounded up. Handle this by
2456 * reducing the *largest* coefficient by 1; this matches the
2457 * approach used for the default coefficients in pngrtran.c
2463 else if (r+g+b < 32768)
2468 if (g >= r && g >= b)
2470 else if (r >= g && r >= b)
2476 /* Check for an internal error. */
2479 "internal error handling cHRM coefficients");
2483 png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
2484 png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
2488 /* This is a png_error at present even though it could be ignored -
2489 * it should never happen, but it is important that if it does, the
2493 png_error(png_ptr, "internal error handling cHRM->XYZ");
2496 #endif /* READ_RGB_TO_GRAY */
2498 #endif /* COLORSPACE */
2501 /* This exists solely to work round a warning from GNU C. */
2502 static int /* PRIVATE */
2503 png_gt(size_t a, size_t b)
2508 # define png_gt(a,b) ((a) > (b))
2512 png_check_IHDR(png_const_structrp png_ptr,
2513 png_uint_32 width, png_uint_32 height, int bit_depth,
2514 int color_type, int interlace_type, int compression_type,
2519 /* Check for width and height valid values */
2522 png_warning(png_ptr, "Image width is zero in IHDR");
2526 if (width > PNG_UINT_31_MAX)
2528 png_warning(png_ptr, "Invalid image width in IHDR");
2532 if (png_gt(((width + 7) & (~7)),
2534 - 48 /* big_row_buf hack */
2535 - 1) /* filter byte */
2536 / 8) /* 8-byte RGBA pixels */
2537 - 1)) /* extra max_pixel_depth pad */
2539 /* The size of the row must be within the limits of this architecture.
2540 * Because the read code can perform arbitrary transformations the
2541 * maximum size is checked here. Because the code in png_read_start_row
2542 * adds extra space "for safety's sake" in several places a conservative
2543 * limit is used here.
2545 * NOTE: it would be far better to check the size that is actually used,
2546 * but the effect in the real world is minor and the changes are more
2547 * extensive, therefore much more dangerous and much more difficult to
2548 * write in a way that avoids compiler warnings.
2550 png_warning(png_ptr, "Image width is too large for this architecture");
2554 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2555 if (width > png_ptr->user_width_max)
2557 if (width > PNG_USER_WIDTH_MAX)
2560 png_warning(png_ptr, "Image width exceeds user limit in IHDR");
2566 png_warning(png_ptr, "Image height is zero in IHDR");
2570 if (height > PNG_UINT_31_MAX)
2572 png_warning(png_ptr, "Invalid image height in IHDR");
2576 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
2577 if (height > png_ptr->user_height_max)
2579 if (height > PNG_USER_HEIGHT_MAX)
2582 png_warning(png_ptr, "Image height exceeds user limit in IHDR");
2586 /* Check other values */
2587 if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
2588 bit_depth != 8 && bit_depth != 16)
2590 png_warning(png_ptr, "Invalid bit depth in IHDR");
2594 if (color_type < 0 || color_type == 1 ||
2595 color_type == 5 || color_type > 6)
2597 png_warning(png_ptr, "Invalid color type in IHDR");
2601 if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
2602 ((color_type == PNG_COLOR_TYPE_RGB ||
2603 color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
2604 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
2606 png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
2610 if (interlace_type >= PNG_INTERLACE_LAST)
2612 png_warning(png_ptr, "Unknown interlace method in IHDR");
2616 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
2618 png_warning(png_ptr, "Unknown compression method in IHDR");
2622 #ifdef PNG_MNG_FEATURES_SUPPORTED
2623 /* Accept filter_method 64 (intrapixel differencing) only if
2624 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
2625 * 2. Libpng did not read a PNG signature (this filter_method is only
2626 * used in PNG datastreams that are embedded in MNG datastreams) and
2627 * 3. The application called png_permit_mng_features with a mask that
2628 * included PNG_FLAG_MNG_FILTER_64 and
2629 * 4. The filter_method is 64 and
2630 * 5. The color_type is RGB or RGBA
2632 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 &&
2633 png_ptr->mng_features_permitted != 0)
2634 png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
2636 if (filter_type != PNG_FILTER_TYPE_BASE)
2638 if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
2639 (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
2640 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
2641 (color_type == PNG_COLOR_TYPE_RGB ||
2642 color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
2644 png_warning(png_ptr, "Unknown filter method in IHDR");
2648 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
2650 png_warning(png_ptr, "Invalid filter method in IHDR");
2656 if (filter_type != PNG_FILTER_TYPE_BASE)
2658 png_warning(png_ptr, "Unknown filter method in IHDR");
2664 png_error(png_ptr, "Invalid IHDR data");
2667 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
2668 /* ASCII to fp functions */
2669 /* Check an ASCII formated floating point value, see the more detailed
2670 * comments in pngpriv.h
2672 /* The following is used internally to preserve the sticky flags */
2673 #define png_fp_add(state, flags) ((state) |= (flags))
2674 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
2677 png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
2678 png_size_tp whereami)
2680 int state = *statep;
2681 png_size_t i = *whereami;
2686 /* First find the type of the next character */
2689 case 43: type = PNG_FP_SAW_SIGN; break;
2690 case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
2691 case 46: type = PNG_FP_SAW_DOT; break;
2692 case 48: type = PNG_FP_SAW_DIGIT; break;
2693 case 49: case 50: case 51: case 52:
2694 case 53: case 54: case 55: case 56:
2695 case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
2697 case 101: type = PNG_FP_SAW_E; break;
2698 default: goto PNG_FP_End;
2701 /* Now deal with this type according to the current
2702 * state, the type is arranged to not overlap the
2703 * bits of the PNG_FP_STATE.
2705 switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
2707 case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
2708 if ((state & PNG_FP_SAW_ANY) != 0)
2709 goto PNG_FP_End; /* not a part of the number */
2711 png_fp_add(state, type);
2714 case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
2715 /* Ok as trailer, ok as lead of fraction. */
2716 if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
2719 else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
2720 png_fp_add(state, type);
2723 png_fp_set(state, PNG_FP_FRACTION | type);
2727 case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
2728 if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
2729 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
2731 png_fp_add(state, type | PNG_FP_WAS_VALID);
2735 case PNG_FP_INTEGER + PNG_FP_SAW_E:
2736 if ((state & PNG_FP_SAW_DIGIT) == 0)
2739 png_fp_set(state, PNG_FP_EXPONENT);
2743 /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
2744 goto PNG_FP_End; ** no sign in fraction */
2746 /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
2747 goto PNG_FP_End; ** Because SAW_DOT is always set */
2749 case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
2750 png_fp_add(state, type | PNG_FP_WAS_VALID);
2753 case PNG_FP_FRACTION + PNG_FP_SAW_E:
2754 /* This is correct because the trailing '.' on an
2755 * integer is handled above - so we can only get here
2756 * with the sequence ".E" (with no preceding digits).
2758 if ((state & PNG_FP_SAW_DIGIT) == 0)
2761 png_fp_set(state, PNG_FP_EXPONENT);
2765 case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
2766 if ((state & PNG_FP_SAW_ANY) != 0)
2767 goto PNG_FP_End; /* not a part of the number */
2769 png_fp_add(state, PNG_FP_SAW_SIGN);
2773 /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
2776 case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
2777 png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
2781 /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
2784 default: goto PNG_FP_End; /* I.e. break 2 */
2787 /* The character seems ok, continue. */
2792 /* Here at the end, update the state and return the correct
2798 return (state & PNG_FP_SAW_DIGIT) != 0;
2802 /* The same but for a complete string. */
2804 png_check_fp_string(png_const_charp string, png_size_t size)
2807 png_size_t char_index=0;
2809 if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
2810 (char_index == size || string[char_index] == 0))
2811 return state /* must be non-zero - see above */;
2813 return 0; /* i.e. fail */
2815 #endif /* pCAL || sCAL */
2817 #ifdef PNG_sCAL_SUPPORTED
2818 # ifdef PNG_FLOATING_POINT_SUPPORTED
2819 /* Utility used below - a simple accurate power of ten from an integral
2823 png_pow10(int power)
2828 /* Handle negative exponent with a reciprocal at the end because
2829 * 10 is exact whereas .1 is inexact in base 2
2833 if (power < DBL_MIN_10_EXP) return 0;
2834 recip = 1, power = -power;
2839 /* Decompose power bitwise. */
2843 if (power & 1) d *= mult;
2849 if (recip != 0) d = 1/d;
2851 /* else power is 0 and d is 1 */
2856 /* Function to format a floating point value in ASCII with a given
2860 png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
2861 double fp, unsigned int precision)
2863 /* We use standard functions from math.h, but not printf because
2864 * that would require stdio. The caller must supply a buffer of
2865 * sufficient size or we will png_error. The tests on size and
2866 * the space in ascii[] consumed are indicated below.
2869 precision = DBL_DIG;
2871 /* Enforce the limit of the implementation precision too. */
2872 if (precision > DBL_DIG+1)
2873 precision = DBL_DIG+1;
2875 /* Basic sanity checks */
2876 if (size >= precision+5) /* See the requirements below. */
2881 *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */
2885 if (fp >= DBL_MIN && fp <= DBL_MAX)
2887 int exp_b10; /* A base 10 exponent */
2888 double base; /* 10^exp_b10 */
2890 /* First extract a base 10 exponent of the number,
2891 * the calculation below rounds down when converting
2892 * from base 2 to base 10 (multiply by log10(2) -
2893 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
2894 * be increased. Note that the arithmetic shift
2895 * performs a floor() unlike C arithmetic - using a
2896 * C multiply would break the following for negative
2899 (void)frexp(fp, &exp_b10); /* exponent to base 2 */
2901 exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
2903 /* Avoid underflow here. */
2904 base = png_pow10(exp_b10); /* May underflow */
2906 while (base < DBL_MIN || base < fp)
2908 /* And this may overflow. */
2909 double test = png_pow10(exp_b10+1);
2911 if (test <= DBL_MAX)
2912 ++exp_b10, base = test;
2918 /* Normalize fp and correct exp_b10, after this fp is in the
2919 * range [.1,1) and exp_b10 is both the exponent and the digit
2920 * *before* which the decimal point should be inserted
2921 * (starting with 0 for the first digit). Note that this
2922 * works even if 10^exp_b10 is out of range because of the
2923 * test on DBL_MAX above.
2926 while (fp >= 1) fp /= 10, ++exp_b10;
2928 /* Because of the code above fp may, at this point, be
2929 * less than .1, this is ok because the code below can
2930 * handle the leading zeros this generates, so no attempt
2931 * is made to correct that here.
2935 unsigned int czero, clead, cdigits;
2938 /* Allow up to two leading zeros - this will not lengthen
2939 * the number compared to using E-n.
2941 if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
2943 czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
2944 exp_b10 = 0; /* Dot added below before first output. */
2947 czero = 0; /* No zeros to add */
2949 /* Generate the digit list, stripping trailing zeros and
2950 * inserting a '.' before a digit if the exponent is 0.
2952 clead = czero; /* Count of leading zeros */
2953 cdigits = 0; /* Count of digits in list. */
2960 /* Use modf here, not floor and subtract, so that
2961 * the separation is done in one step. At the end
2962 * of the loop don't break the number into parts so
2963 * that the final digit is rounded.
2965 if (cdigits+czero+1 < precision+clead)
2974 /* Rounding up to 10, handle that here. */
2978 if (cdigits == 0) --clead;
2982 while (cdigits > 0 && d > 9)
2986 if (exp_b10 != (-1))
2991 ch = *--ascii, ++size;
2992 /* Advance exp_b10 to '1', so that the
2993 * decimal point happens after the
3000 d = ch - 47; /* I.e. 1+(ch-48) */
3003 /* Did we reach the beginning? If so adjust the
3004 * exponent but take into account the leading
3007 if (d > 9) /* cdigits == 0 */
3009 if (exp_b10 == (-1))
3011 /* Leading decimal point (plus zeros?), if
3012 * we lose the decimal point here it must
3013 * be reentered below.
3018 ++size, exp_b10 = 1;
3020 /* Else lost a leading zero, so 'exp_b10' is
3027 /* In all cases we output a '1' */
3032 fp = 0; /* Guarantees termination below. */
3038 if (cdigits == 0) ++clead;
3042 /* Included embedded zeros in the digit count. */
3043 cdigits += czero - clead;
3048 /* exp_b10 == (-1) means we just output the decimal
3049 * place - after the DP don't adjust 'exp_b10' any
3052 if (exp_b10 != (-1))
3054 if (exp_b10 == 0) *ascii++ = 46, --size;
3055 /* PLUS 1: TOTAL 4 */
3058 *ascii++ = 48, --czero;
3061 if (exp_b10 != (-1))
3064 *ascii++ = 46, --size; /* counted above */
3068 *ascii++ = (char)(48 + (int)d), ++cdigits;
3071 while (cdigits+czero < precision+clead && fp > DBL_MIN);
3073 /* The total output count (max) is now 4+precision */
3075 /* Check for an exponent, if we don't need one we are
3076 * done and just need to terminate the string. At
3077 * this point exp_b10==(-1) is effectively if flag - it got
3078 * to '-1' because of the decrement after outputting
3079 * the decimal point above (the exponent required is
3082 if (exp_b10 >= (-1) && exp_b10 <= 2)
3084 /* The following only happens if we didn't output the
3085 * leading zeros above for negative exponent, so this
3086 * doesn't add to the digit requirement. Note that the
3087 * two zeros here can only be output if the two leading
3088 * zeros were *not* output, so this doesn't increase
3091 while (--exp_b10 >= 0) *ascii++ = 48;
3095 /* Total buffer requirement (including the '\0') is
3096 * 5+precision - see check at the start.
3101 /* Here if an exponent is required, adjust size for
3102 * the digits we output but did not count. The total
3103 * digit output here so far is at most 1+precision - no
3104 * decimal point and no leading or trailing zeros have
3109 *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */
3111 /* The following use of an unsigned temporary avoids ambiguities in
3112 * the signed arithmetic on exp_b10 and permits GCC at least to do
3113 * better optimization.
3116 unsigned int uexp_b10;
3120 *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
3121 uexp_b10 = -exp_b10;
3129 while (uexp_b10 > 0)
3131 exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
3136 /* Need another size check here for the exponent digits, so
3137 * this need not be considered above.
3141 while (cdigits > 0) *ascii++ = exponent[--cdigits];
3149 else if (!(fp >= DBL_MIN))
3151 *ascii++ = 48; /* '0' */
3157 *ascii++ = 105; /* 'i' */
3158 *ascii++ = 110; /* 'n' */
3159 *ascii++ = 102; /* 'f' */
3165 /* Here on buffer too small. */
3166 png_error(png_ptr, "ASCII conversion buffer too small");
3169 # endif /* FLOATING_POINT */
3171 # ifdef PNG_FIXED_POINT_SUPPORTED
3172 /* Function to format a fixed point value in ASCII.
3175 png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
3176 png_size_t size, png_fixed_point fp)
3178 /* Require space for 10 decimal digits, a decimal point, a minus sign and a
3179 * trailing \0, 13 characters:
3185 /* Avoid overflow here on the minimum integer. */
3187 *ascii++ = 45, num = -fp;
3191 if (num <= 0x80000000) /* else overflowed */
3193 unsigned int ndigits = 0, first = 16 /* flag value */;
3198 /* Split the low digit off num: */
3199 unsigned int tmp = num/10;
3201 digits[ndigits++] = (char)(48 + num);
3202 /* Record the first non-zero digit, note that this is a number
3203 * starting at 1, it's not actually the array index.
3205 if (first == 16 && num > 0)
3212 while (ndigits > 5) *ascii++ = digits[--ndigits];
3213 /* The remaining digits are fractional digits, ndigits is '5' or
3214 * smaller at this point. It is certainly not zero. Check for a
3215 * non-zero fractional digit:
3220 *ascii++ = 46; /* decimal point */
3221 /* ndigits may be <5 for small numbers, output leading zeros
3222 * then ndigits digits to first:
3225 while (ndigits < i) *ascii++ = 48, --i;
3226 while (ndigits >= first) *ascii++ = digits[--ndigits];
3227 /* Don't output the trailing zeros! */
3233 /* And null terminate the string: */
3239 /* Here on buffer too small. */
3240 png_error(png_ptr, "ASCII conversion buffer too small");
3242 # endif /* FIXED_POINT */
3245 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
3246 !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
3247 (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
3248 defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
3249 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
3250 (defined(PNG_sCAL_SUPPORTED) && \
3251 defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
3253 png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
3255 double r = floor(100000 * fp + .5);
3257 if (r > 2147483647. || r < -2147483648.)
3258 png_fixed_error(png_ptr, text);
3260 # ifndef PNG_ERROR_TEXT_SUPPORTED
3264 return (png_fixed_point)r;
3268 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\
3269 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
3270 /* muldiv functions */
3271 /* This API takes signed arguments and rounds the result to the nearest
3272 * integer (or, for a fixed point number - the standard argument - to
3273 * the nearest .00001). Overflow and divide by zero are signalled in
3274 * the result, a boolean - true on success, false on overflow.
3277 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
3280 /* Return a * times / divisor, rounded. */
3283 if (a == 0 || times == 0)
3290 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3296 /* A png_fixed_point is a 32-bit integer. */
3297 if (r <= 2147483647. && r >= -2147483648.)
3299 *res = (png_fixed_point)r;
3304 png_uint_32 A, T, D;
3305 png_uint_32 s16, s32, s00;
3308 negative = 1, A = -a;
3313 negative = !negative, T = -times;
3318 negative = !negative, D = -divisor;
3322 /* Following can't overflow because the arguments only
3323 * have 31 bits each, however the result may be 32 bits.
3325 s16 = (A >> 16) * (T & 0xffff) +
3326 (A & 0xffff) * (T >> 16);
3327 /* Can't overflow because the a*times bit is only 30
3330 s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
3331 s00 = (A & 0xffff) * (T & 0xffff);
3333 s16 = (s16 & 0xffff) << 16;
3339 if (s32 < D) /* else overflow */
3341 /* s32.s00 is now the 64-bit product, do a standard
3342 * division, we know that s32 < D, so the maximum
3343 * required shift is 31.
3346 png_fixed_point result = 0; /* NOTE: signed */
3348 while (--bitshift >= 0)
3350 png_uint_32 d32, d00;
3353 d32 = D >> (32-bitshift), d00 = D << bitshift;
3360 if (s00 < d00) --s32; /* carry */
3361 s32 -= d32, s00 -= d00, result += 1<<bitshift;
3365 if (s32 == d32 && s00 >= d00)
3366 s32 = 0, s00 -= d00, result += 1<<bitshift;
3369 /* Handle the rounding. */
3370 if (s00 >= (D >> 1))
3376 /* Check for overflow. */
3377 if ((negative != 0 && result <= 0) ||
3378 (negative == 0 && result >= 0))
3390 #endif /* READ_GAMMA || INCH_CONVERSIONS */
3392 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
3393 /* The following is for when the caller doesn't much care about the
3397 png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
3400 png_fixed_point result;
3402 if (png_muldiv(&result, a, times, divisor) != 0)
3405 png_warning(png_ptr, "fixed point overflow ignored");
3410 #ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */
3411 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
3413 png_reciprocal(png_fixed_point a)
3415 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3416 double r = floor(1E10/a+.5);
3418 if (r <= 2147483647. && r >= -2147483648.)
3419 return (png_fixed_point)r;
3421 png_fixed_point res;
3423 if (png_muldiv(&res, 100000, 100000, a) != 0)
3427 return 0; /* error/overflow */
3430 /* This is the shared test on whether a gamma value is 'significant' - whether
3431 * it is worth doing gamma correction.
3434 png_gamma_significant(png_fixed_point gamma_val)
3436 return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
3437 gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
3441 #ifdef PNG_READ_GAMMA_SUPPORTED
3442 #ifdef PNG_16BIT_SUPPORTED
3443 /* A local convenience routine. */
3444 static png_fixed_point
3445 png_product2(png_fixed_point a, png_fixed_point b)
3447 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3448 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3449 double r = a * 1E-5;
3453 if (r <= 2147483647. && r >= -2147483648.)
3454 return (png_fixed_point)r;
3456 png_fixed_point res;
3458 if (png_muldiv(&res, a, b, 100000) != 0)
3462 return 0; /* overflow */
3466 /* The inverse of the above. */
3468 png_reciprocal2(png_fixed_point a, png_fixed_point b)
3470 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3471 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3472 if (a != 0 && b != 0)
3478 if (r <= 2147483647. && r >= -2147483648.)
3479 return (png_fixed_point)r;
3482 /* This may overflow because the range of png_fixed_point isn't symmetric,
3483 * but this API is only used for the product of file and screen gamma so it
3484 * doesn't matter that the smallest number it can produce is 1/21474, not
3487 png_fixed_point res = png_product2(a, b);
3490 return png_reciprocal(res);
3493 return 0; /* overflow */
3495 #endif /* READ_GAMMA */
3497 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
3498 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
3499 /* Fixed point gamma.
3501 * The code to calculate the tables used below can be found in the shell script
3502 * contrib/tools/intgamma.sh
3504 * To calculate gamma this code implements fast log() and exp() calls using only
3505 * fixed point arithmetic. This code has sufficient precision for either 8-bit
3506 * or 16-bit sample values.
3508 * The tables used here were calculated using simple 'bc' programs, but C double
3509 * precision floating point arithmetic would work fine.
3512 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
3513 * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
3514 * mantissa. The numbers are 32-bit fractions.
3516 static const png_uint_32
3519 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
3520 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
3521 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
3522 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
3523 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
3524 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
3525 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
3526 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
3527 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
3528 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
3529 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
3530 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
3531 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
3532 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
3533 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
3534 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
3535 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
3536 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
3537 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
3538 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
3539 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
3543 /* The following are the values for 16-bit tables - these work fine for the
3544 * 8-bit conversions but produce very slightly larger errors in the 16-bit
3545 * log (about 1.2 as opposed to 0.7 absolute error in the final value). To
3546 * use these all the shifts below must be adjusted appropriately.
3548 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
3549 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
3550 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
3551 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
3552 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
3553 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
3554 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
3555 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
3556 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
3557 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
3558 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
3564 png_log8bit(unsigned int x)
3566 unsigned int lg2 = 0;
3567 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
3568 * because the log is actually negate that means adding 1. The final
3569 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
3570 * input), return -1 for the overflow (log 0) case, - so the result is
3571 * always at most 19 bits.
3573 if ((x &= 0xff) == 0)
3576 if ((x & 0xf0) == 0)
3579 if ((x & 0xc0) == 0)
3582 if ((x & 0x80) == 0)
3585 /* result is at most 19 bits, so this cast is safe: */
3586 return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
3589 /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
3590 * for 16-bit images we use the most significant 8 bits of the 16-bit value to
3591 * get an approximation then multiply the approximation by a correction factor
3592 * determined by the remaining up to 8 bits. This requires an additional step
3593 * in the 16-bit case.
3595 * We want log2(value/65535), we have log2(v'/255), where:
3597 * value = v' * 256 + v''
3600 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
3601 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
3602 * than 258. The final factor also needs to correct for the fact that our 8-bit
3603 * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
3605 * This gives a final formula using a calculated value 'x' which is value/v' and
3606 * scaling by 65536 to match the above table:
3608 * log2(x/257) * 65536
3610 * Since these numbers are so close to '1' we can use simple linear
3611 * interpolation between the two end values 256/257 (result -368.61) and 258/257
3612 * (result 367.179). The values used below are scaled by a further 64 to give
3613 * 16-bit precision in the interpolation:
3615 * Start (256): -23591
3619 #ifdef PNG_16BIT_SUPPORTED
3621 png_log16bit(png_uint_32 x)
3623 unsigned int lg2 = 0;
3625 /* As above, but now the input has 16 bits. */
3626 if ((x &= 0xffff) == 0)
3629 if ((x & 0xff00) == 0)
3632 if ((x & 0xf000) == 0)
3635 if ((x & 0xc000) == 0)
3638 if ((x & 0x8000) == 0)
3641 /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
3645 lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
3647 /* Now we need to interpolate the factor, this requires a division by the top
3648 * 8 bits. Do this with maximum precision.
3650 x = ((x << 16) + (x >> 9)) / (x >> 8);
3652 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
3653 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
3654 * 16 bits to interpolate to get the low bits of the result. Round the
3655 * answer. Note that the end point values are scaled by 64 to retain overall
3656 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
3657 * the overall scaling by 6-12. Round at every step.
3661 if (x <= 65536U) /* <= '257' */
3662 lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
3665 lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
3667 /* Safe, because the result can't have more than 20 bits: */
3668 return (png_int_32)((lg2 + 2048) >> 12);
3672 /* The 'exp()' case must invert the above, taking a 20-bit fixed point
3673 * logarithmic value and returning a 16 or 8-bit number as appropriate. In
3674 * each case only the low 16 bits are relevant - the fraction - since the
3675 * integer bits (the top 4) simply determine a shift.
3677 * The worst case is the 16-bit distinction between 65535 and 65534. This
3678 * requires perhaps spurious accuracy in the decoding of the logarithm to
3679 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
3680 * of getting this accuracy in practice.
3682 * To deal with this the following exp() function works out the exponent of the
3683 * frational part of the logarithm by using an accurate 32-bit value from the
3684 * top four fractional bits then multiplying in the remaining bits.
3686 static const png_uint_32
3689 /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
3690 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
3691 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
3692 2553802834U, 2445529972U, 2341847524U, 2242560872U
3695 /* Adjustment table; provided to explain the numbers in the code below. */
3697 for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
3698 11 44937.64284865548751208448
3699 10 45180.98734845585101160448
3700 9 45303.31936980687359311872
3701 8 45364.65110595323018870784
3702 7 45395.35850361789624614912
3703 6 45410.72259715102037508096
3704 5 45418.40724413220722311168
3705 4 45422.25021786898173001728
3706 3 45424.17186732298419044352
3707 2 45425.13273269940811464704
3708 1 45425.61317555035558641664
3709 0 45425.85339951654943850496
3713 png_exp(png_fixed_point x)
3715 if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
3717 /* Obtain a 4-bit approximation */
3718 png_uint_32 e = png_32bit_exp[(x >> 12) & 0x0f];
3720 /* Incorporate the low 12 bits - these decrease the returned value by
3721 * multiplying by a number less than 1 if the bit is set. The multiplier
3722 * is determined by the above table and the shift. Notice that the values
3723 * converge on 45426 and this is used to allow linear interpolation of the
3727 e -= (((e >> 16) * 44938U) + 16U) >> 5;
3730 e -= (((e >> 16) * 45181U) + 32U) >> 6;
3733 e -= (((e >> 16) * 45303U) + 64U) >> 7;
3736 e -= (((e >> 16) * 45365U) + 128U) >> 8;
3739 e -= (((e >> 16) * 45395U) + 256U) >> 9;
3742 e -= (((e >> 16) * 45410U) + 512U) >> 10;
3744 /* And handle the low 6 bits in a single block. */
3745 e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
3747 /* Handle the upper bits of x. */
3752 /* Check for overflow */
3754 return png_32bit_exp[0];
3756 /* Else underflow */
3761 png_exp8bit(png_fixed_point lg2)
3763 /* Get a 32-bit value: */
3764 png_uint_32 x = png_exp(lg2);
3766 /* Convert the 32-bit value to 0..255 by multiplying by 256-1. Note that the
3767 * second, rounding, step can't overflow because of the first, subtraction,
3771 return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff);
3774 #ifdef PNG_16BIT_SUPPORTED
3776 png_exp16bit(png_fixed_point lg2)
3778 /* Get a 32-bit value: */
3779 png_uint_32 x = png_exp(lg2);
3781 /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
3783 return (png_uint_16)((x + 32767U) >> 16);
3786 #endif /* FLOATING_ARITHMETIC */
3789 png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
3791 if (value > 0 && value < 255)
3793 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3794 /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly
3795 * convert this to a floating point value. This includes values that
3796 * would overflow if 'value' were to be converted to 'int'.
3798 * Apparently GCC, however, does an intermediate conversion to (int)
3799 * on some (ARM) but not all (x86) platforms, possibly because of
3800 * hardware FP limitations. (E.g. if the hardware conversion always
3801 * assumes the integer register contains a signed value.) This results
3802 * in ANSI-C undefined behavior for large values.
3804 * Other implementations on the same machine might actually be ANSI-C90
3805 * conformant and therefore compile spurious extra code for the large
3808 * We can be reasonably sure that an unsigned to float conversion
3809 * won't be faster than an int to float one. Therefore this code
3810 * assumes responsibility for the undefined behavior, which it knows
3811 * can't happen because of the check above.
3813 * Note the argument to this routine is an (unsigned int) because, on
3814 * 16-bit platforms, it is assigned a value which might be out of
3815 * range for an (int); that would result in undefined behavior in the
3816 * caller if the *argument* ('value') were to be declared (int).
3818 double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5);
3821 png_int_32 lg2 = png_log8bit(value);
3822 png_fixed_point res;
3824 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
3825 return png_exp8bit(res);
3832 return (png_byte)(value & 0xff);
3835 #ifdef PNG_16BIT_SUPPORTED
3837 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
3839 if (value > 0 && value < 65535)
3841 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3842 /* The same (unsigned int)->(double) constraints apply here as above,
3843 * however in this case the (unsigned int) to (int) conversion can
3844 * overflow on an ANSI-C90 compliant system so the cast needs to ensure
3845 * that this is not possible.
3847 double r = floor(65535*pow((png_int_32)value/65535.,
3848 gamma_val*.00001)+.5);
3849 return (png_uint_16)r;
3851 png_int_32 lg2 = png_log16bit(value);
3852 png_fixed_point res;
3854 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
3855 return png_exp16bit(res);
3862 return (png_uint_16)value;
3866 /* This does the right thing based on the bit_depth field of the
3867 * png_struct, interpreting values as 8-bit or 16-bit. While the result
3868 * is nominally a 16-bit value if bit depth is 8 then the result is
3869 * 8-bit (as are the arguments.)
3871 png_uint_16 /* PRIVATE */
3872 png_gamma_correct(png_structrp png_ptr, unsigned int value,
3873 png_fixed_point gamma_val)
3875 if (png_ptr->bit_depth == 8)
3876 return png_gamma_8bit_correct(value, gamma_val);
3878 #ifdef PNG_16BIT_SUPPORTED
3880 return png_gamma_16bit_correct(value, gamma_val);
3882 /* should not reach this */
3887 #ifdef PNG_16BIT_SUPPORTED
3888 /* Internal function to build a single 16-bit table - the table consists of
3889 * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
3890 * to shift the input values right (or 16-number_of_signifiant_bits).
3892 * The caller is responsible for ensuring that the table gets cleaned up on
3893 * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
3894 * should be somewhere that will be cleaned.
3897 png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
3898 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
3900 /* Various values derived from 'shift': */
3901 PNG_CONST unsigned int num = 1U << (8U - shift);
3902 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3903 /* CSE the division and work round wacky GCC warnings (see the comments
3904 * in png_gamma_8bit_correct for where these come from.)
3906 PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1);
3908 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
3909 PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
3912 png_uint_16pp table = *ptable =
3913 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
3915 for (i = 0; i < num; i++)
3917 png_uint_16p sub_table = table[i] =
3918 (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));
3920 /* The 'threshold' test is repeated here because it can arise for one of
3921 * the 16-bit tables even if the others don't hit it.
3923 if (png_gamma_significant(gamma_val) != 0)
3925 /* The old code would overflow at the end and this would cause the
3926 * 'pow' function to return a result >1, resulting in an
3927 * arithmetic error. This code follows the spec exactly; ig is
3928 * the recovered input sample, it always has 8-16 bits.
3930 * We want input * 65535/max, rounded, the arithmetic fits in 32
3931 * bits (unsigned) so long as max <= 32767.
3934 for (j = 0; j < 256; j++)
3936 png_uint_32 ig = (j << (8-shift)) + i;
3937 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3938 /* Inline the 'max' scaling operation: */
3939 /* See png_gamma_8bit_correct for why the cast to (int) is
3942 double d = floor(65535.*pow(ig*fmax, gamma_val*.00001)+.5);
3943 sub_table[j] = (png_uint_16)d;
3946 ig = (ig * 65535U + max_by_2)/max;
3948 sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
3954 /* We must still build a table, but do it the fast way. */
3957 for (j = 0; j < 256; j++)
3959 png_uint_32 ig = (j << (8-shift)) + i;
3962 ig = (ig * 65535U + max_by_2)/max;
3964 sub_table[j] = (png_uint_16)ig;
3970 /* NOTE: this function expects the *inverse* of the overall gamma transformation
3974 png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
3975 PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
3977 PNG_CONST unsigned int num = 1U << (8U - shift);
3978 PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
3982 png_uint_16pp table = *ptable =
3983 (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
3985 /* 'num' is the number of tables and also the number of low bits of low
3986 * bits of the input 16-bit value used to select a table. Each table is
3987 * itself indexed by the high 8 bits of the value.
3989 for (i = 0; i < num; i++)
3990 table[i] = (png_uint_16p)png_malloc(png_ptr,
3991 256 * (sizeof (png_uint_16)));
3993 /* 'gamma_val' is set to the reciprocal of the value calculated above, so
3994 * pow(out,g) is an *input* value. 'last' is the last input value set.
3996 * In the loop 'i' is used to find output values. Since the output is
3997 * 8-bit there are only 256 possible values. The tables are set up to
3998 * select the closest possible output value for each input by finding
3999 * the input value at the boundary between each pair of output values
4000 * and filling the table up to that boundary with the lower output
4003 * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit
4004 * values the code below uses a 16-bit value in i; the values start at
4005 * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
4006 * entries are filled with 255). Start i at 128 and fill all 'last'
4007 * table entries <= 'max'
4010 for (i = 0; i < 255; ++i) /* 8-bit output value */
4012 /* Find the corresponding maximum input value */
4013 png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */
4015 /* Find the boundary value in 16 bits: */
4016 png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
4018 /* Adjust (round) to (16-shift) bits: */
4019 bound = (bound * max + 32768U)/65535U + 1U;
4021 while (last < bound)
4023 table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
4028 /* And fill in the final entries. */
4029 while (last < (num << 8))
4031 table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
4037 /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
4038 * typically much faster). Note that libpng currently does no sBIT processing
4039 * (apparently contrary to the spec) so a 256-entry table is always generated.
4042 png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
4043 PNG_CONST png_fixed_point gamma_val)
4046 png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
4048 if (png_gamma_significant(gamma_val) != 0)
4049 for (i=0; i<256; i++)
4050 table[i] = png_gamma_8bit_correct(i, gamma_val);
4053 for (i=0; i<256; ++i)
4054 table[i] = (png_byte)(i & 0xff);
4057 /* Used from png_read_destroy and below to release the memory used by the gamma
4061 png_destroy_gamma_table(png_structrp png_ptr)
4063 png_free(png_ptr, png_ptr->gamma_table);
4064 png_ptr->gamma_table = NULL;
4066 #ifdef PNG_16BIT_SUPPORTED
4067 if (png_ptr->gamma_16_table != NULL)
4070 int istop = (1 << (8 - png_ptr->gamma_shift));
4071 for (i = 0; i < istop; i++)
4073 png_free(png_ptr, png_ptr->gamma_16_table[i]);
4075 png_free(png_ptr, png_ptr->gamma_16_table);
4076 png_ptr->gamma_16_table = NULL;
4080 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4081 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4082 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4083 png_free(png_ptr, png_ptr->gamma_from_1);
4084 png_ptr->gamma_from_1 = NULL;
4085 png_free(png_ptr, png_ptr->gamma_to_1);
4086 png_ptr->gamma_to_1 = NULL;
4088 #ifdef PNG_16BIT_SUPPORTED
4089 if (png_ptr->gamma_16_from_1 != NULL)
4092 int istop = (1 << (8 - png_ptr->gamma_shift));
4093 for (i = 0; i < istop; i++)
4095 png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
4097 png_free(png_ptr, png_ptr->gamma_16_from_1);
4098 png_ptr->gamma_16_from_1 = NULL;
4100 if (png_ptr->gamma_16_to_1 != NULL)
4103 int istop = (1 << (8 - png_ptr->gamma_shift));
4104 for (i = 0; i < istop; i++)
4106 png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
4108 png_free(png_ptr, png_ptr->gamma_16_to_1);
4109 png_ptr->gamma_16_to_1 = NULL;
4112 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4115 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
4116 * tables, we don't make a full table if we are reducing to 8-bit in
4117 * the future. Note also how the gamma_16 tables are segmented so that
4118 * we don't need to allocate > 64K chunks for a full 16-bit table.
4121 png_build_gamma_table(png_structrp png_ptr, int bit_depth)
4123 png_debug(1, "in png_build_gamma_table");
4125 /* Remove any existing table; this copes with multiple calls to
4126 * png_read_update_info. The warning is because building the gamma tables
4127 * multiple times is a performance hit - it's harmless but the ability to
4128 * call png_read_update_info() multiple times is new in 1.5.6 so it seems
4129 * sensible to warn if the app introduces such a hit.
4131 if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
4133 png_warning(png_ptr, "gamma table being rebuilt");
4134 png_destroy_gamma_table(png_ptr);
4139 png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
4140 png_ptr->screen_gamma > 0 ?
4141 png_reciprocal2(png_ptr->colorspace.gamma,
4142 png_ptr->screen_gamma) : PNG_FP_1);
4144 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4145 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4146 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4147 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
4149 png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
4150 png_reciprocal(png_ptr->colorspace.gamma));
4152 png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
4153 png_ptr->screen_gamma > 0 ?
4154 png_reciprocal(png_ptr->screen_gamma) :
4155 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
4157 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4159 #ifdef PNG_16BIT_SUPPORTED
4162 png_byte shift, sig_bit;
4164 if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
4166 sig_bit = png_ptr->sig_bit.red;
4168 if (png_ptr->sig_bit.green > sig_bit)
4169 sig_bit = png_ptr->sig_bit.green;
4171 if (png_ptr->sig_bit.blue > sig_bit)
4172 sig_bit = png_ptr->sig_bit.blue;
4175 sig_bit = png_ptr->sig_bit.gray;
4177 /* 16-bit gamma code uses this equation:
4179 * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
4181 * Where 'iv' is the input color value and 'ov' is the output value -
4184 * Thus the gamma table consists of up to 256 256-entry tables. The table
4185 * is selected by the (8-gamma_shift) most significant of the low 8 bits
4186 * of the color value then indexed by the upper 8 bits:
4188 * table[low bits][high 8 bits]
4190 * So the table 'n' corresponds to all those 'iv' of:
4192 * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
4195 if (sig_bit > 0 && sig_bit < 16U)
4196 /* shift == insignificant bits */
4197 shift = (png_byte)((16U - sig_bit) & 0xff);
4200 shift = 0; /* keep all 16 bits */
4202 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
4204 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
4205 * the significant bits in the *input* when the output will
4206 * eventually be 8 bits. By default it is 11.
4208 if (shift < (16U - PNG_MAX_GAMMA_8))
4209 shift = (16U - PNG_MAX_GAMMA_8);
4213 shift = 8U; /* Guarantees at least one table! */
4215 png_ptr->gamma_shift = shift;
4217 /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
4218 * PNG_COMPOSE). This effectively smashed the background calculation for
4219 * 16-bit output because the 8-bit table assumes the result will be
4220 * reduced to 8 bits.
4222 if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
4223 png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
4224 png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
4225 png_ptr->screen_gamma) : PNG_FP_1);
4228 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
4229 png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
4230 png_ptr->screen_gamma) : PNG_FP_1);
4232 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4233 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4234 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4235 if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
4237 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
4238 png_reciprocal(png_ptr->colorspace.gamma));
4240 /* Notice that the '16 from 1' table should be full precision, however
4241 * the lookup on this table still uses gamma_shift, so it can't be.
4244 png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
4245 png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
4246 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
4248 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4252 #endif /* READ_GAMMA */
4254 /* HARDWARE OR SOFTWARE OPTION SUPPORT */
4255 #ifdef PNG_SET_OPTION_SUPPORTED
4257 png_set_option(png_structrp png_ptr, int option, int onoff)
4259 if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
4262 int mask = 3 << option;
4263 int setting = (2 + (onoff != 0)) << option;
4264 int current = png_ptr->options;
4266 png_ptr->options = (png_byte)(((current & ~mask) | setting) & 0xff);
4268 return (current & mask) >> option;
4271 return PNG_OPTION_INVALID;
4276 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4277 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4278 /* sRGB conversion tables; these are machine generated with the code in
4279 * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the
4280 * specification (see the article at http://en.wikipedia.org/wiki/SRGB)
4281 * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.
4282 * The sRGB to linear table is exact (to the nearest 16-bit linear fraction).
4283 * The inverse (linear to sRGB) table has accuracies as follows:
4285 * For all possible (255*65535+1) input values:
4287 * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact
4289 * For the input values corresponding to the 65536 16-bit values:
4291 * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact
4293 * In all cases the inexact readings are only off by one.
4296 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4297 /* The convert-to-sRGB table is only currently required for read. */
4298 const png_uint_16 png_sRGB_table[256] =
4300 0,20,40,60,80,99,119,139,
4301 159,179,199,219,241,264,288,313,
4302 340,367,396,427,458,491,526,562,
4303 599,637,677,718,761,805,851,898,
4304 947,997,1048,1101,1156,1212,1270,1330,
4305 1391,1453,1517,1583,1651,1720,1790,1863,
4306 1937,2013,2090,2170,2250,2333,2418,2504,
4307 2592,2681,2773,2866,2961,3058,3157,3258,
4308 3360,3464,3570,3678,3788,3900,4014,4129,
4309 4247,4366,4488,4611,4736,4864,4993,5124,
4310 5257,5392,5530,5669,5810,5953,6099,6246,
4311 6395,6547,6700,6856,7014,7174,7335,7500,
4312 7666,7834,8004,8177,8352,8528,8708,8889,
4313 9072,9258,9445,9635,9828,10022,10219,10417,
4314 10619,10822,11028,11235,11446,11658,11873,12090,
4315 12309,12530,12754,12980,13209,13440,13673,13909,
4316 14146,14387,14629,14874,15122,15371,15623,15878,
4317 16135,16394,16656,16920,17187,17456,17727,18001,
4318 18277,18556,18837,19121,19407,19696,19987,20281,
4319 20577,20876,21177,21481,21787,22096,22407,22721,
4320 23038,23357,23678,24002,24329,24658,24990,25325,
4321 25662,26001,26344,26688,27036,27386,27739,28094,
4322 28452,28813,29176,29542,29911,30282,30656,31033,
4323 31412,31794,32179,32567,32957,33350,33745,34143,
4324 34544,34948,35355,35764,36176,36591,37008,37429,
4325 37852,38278,38706,39138,39572,40009,40449,40891,
4326 41337,41785,42236,42690,43147,43606,44069,44534,
4327 45002,45473,45947,46423,46903,47385,47871,48359,
4328 48850,49344,49841,50341,50844,51349,51858,52369,
4329 52884,53401,53921,54445,54971,55500,56032,56567,
4330 57105,57646,58190,58737,59287,59840,60396,60955,
4331 61517,62082,62650,63221,63795,64372,64952,65535
4333 #endif /* SIMPLIFIED_READ */
4335 /* The base/delta tables are required for both read and write (but currently
4336 * only the simplified versions.)
4338 const png_uint_16 png_sRGB_base[512] =
4340 128,1782,3383,4644,5675,6564,7357,8074,
4341 8732,9346,9921,10463,10977,11466,11935,12384,
4342 12816,13233,13634,14024,14402,14769,15125,15473,
4343 15812,16142,16466,16781,17090,17393,17690,17981,
4344 18266,18546,18822,19093,19359,19621,19879,20133,
4345 20383,20630,20873,21113,21349,21583,21813,22041,
4346 22265,22487,22707,22923,23138,23350,23559,23767,
4347 23972,24175,24376,24575,24772,24967,25160,25352,
4348 25542,25730,25916,26101,26284,26465,26645,26823,
4349 27000,27176,27350,27523,27695,27865,28034,28201,
4350 28368,28533,28697,28860,29021,29182,29341,29500,
4351 29657,29813,29969,30123,30276,30429,30580,30730,
4352 30880,31028,31176,31323,31469,31614,31758,31902,
4353 32045,32186,32327,32468,32607,32746,32884,33021,
4354 33158,33294,33429,33564,33697,33831,33963,34095,
4355 34226,34357,34486,34616,34744,34873,35000,35127,
4356 35253,35379,35504,35629,35753,35876,35999,36122,
4357 36244,36365,36486,36606,36726,36845,36964,37083,
4358 37201,37318,37435,37551,37668,37783,37898,38013,
4359 38127,38241,38354,38467,38580,38692,38803,38915,
4360 39026,39136,39246,39356,39465,39574,39682,39790,
4361 39898,40005,40112,40219,40325,40431,40537,40642,
4362 40747,40851,40955,41059,41163,41266,41369,41471,
4363 41573,41675,41777,41878,41979,42079,42179,42279,
4364 42379,42478,42577,42676,42775,42873,42971,43068,
4365 43165,43262,43359,43456,43552,43648,43743,43839,
4366 43934,44028,44123,44217,44311,44405,44499,44592,
4367 44685,44778,44870,44962,45054,45146,45238,45329,
4368 45420,45511,45601,45692,45782,45872,45961,46051,
4369 46140,46229,46318,46406,46494,46583,46670,46758,
4370 46846,46933,47020,47107,47193,47280,47366,47452,
4371 47538,47623,47709,47794,47879,47964,48048,48133,
4372 48217,48301,48385,48468,48552,48635,48718,48801,
4373 48884,48966,49048,49131,49213,49294,49376,49458,
4374 49539,49620,49701,49782,49862,49943,50023,50103,
4375 50183,50263,50342,50422,50501,50580,50659,50738,
4376 50816,50895,50973,51051,51129,51207,51285,51362,
4377 51439,51517,51594,51671,51747,51824,51900,51977,
4378 52053,52129,52205,52280,52356,52432,52507,52582,
4379 52657,52732,52807,52881,52956,53030,53104,53178,
4380 53252,53326,53400,53473,53546,53620,53693,53766,
4381 53839,53911,53984,54056,54129,54201,54273,54345,
4382 54417,54489,54560,54632,54703,54774,54845,54916,
4383 54987,55058,55129,55199,55269,55340,55410,55480,
4384 55550,55620,55689,55759,55828,55898,55967,56036,
4385 56105,56174,56243,56311,56380,56448,56517,56585,
4386 56653,56721,56789,56857,56924,56992,57059,57127,
4387 57194,57261,57328,57395,57462,57529,57595,57662,
4388 57728,57795,57861,57927,57993,58059,58125,58191,
4389 58256,58322,58387,58453,58518,58583,58648,58713,
4390 58778,58843,58908,58972,59037,59101,59165,59230,
4391 59294,59358,59422,59486,59549,59613,59677,59740,
4392 59804,59867,59930,59993,60056,60119,60182,60245,
4393 60308,60370,60433,60495,60558,60620,60682,60744,
4394 60806,60868,60930,60992,61054,61115,61177,61238,
4395 61300,61361,61422,61483,61544,61605,61666,61727,
4396 61788,61848,61909,61969,62030,62090,62150,62211,
4397 62271,62331,62391,62450,62510,62570,62630,62689,
4398 62749,62808,62867,62927,62986,63045,63104,63163,
4399 63222,63281,63340,63398,63457,63515,63574,63632,
4400 63691,63749,63807,63865,63923,63981,64039,64097,
4401 64155,64212,64270,64328,64385,64443,64500,64557,
4402 64614,64672,64729,64786,64843,64900,64956,65013,
4403 65070,65126,65183,65239,65296,65352,65409,65465
4406 const png_byte png_sRGB_delta[512] =
4408 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,
4409 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,
4410 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,
4411 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,
4412 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,
4413 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,
4414 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,
4415 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
4416 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,
4417 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,
4418 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,
4419 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,
4420 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
4421 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,
4422 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4423 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4424 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4425 10,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,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4428 9,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,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4432 8,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,7,7,7,7,7,7,7,
4437 7,7,7,7,7,7,7,7,7,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
4441 #endif /* SIMPLIFIED READ/WRITE sRGB support */
4443 /* SIMPLIFIED READ/WRITE SUPPORT */
4444 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4445 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4447 png_image_free_function(png_voidp argument)
4449 png_imagep image = png_voidcast(png_imagep, argument);
4450 png_controlp cp = image->opaque;
4453 /* Double check that we have a png_ptr - it should be impossible to get here
4456 if (cp->png_ptr == NULL)
4459 /* First free any data held in the control structure. */
4460 # ifdef PNG_STDIO_SUPPORTED
4461 if (cp->owned_file != 0)
4463 FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
4466 /* Ignore errors here. */
4469 cp->png_ptr->io_ptr = NULL;
4475 /* Copy the control structure so that the original, allocated, version can be
4476 * safely freed. Notice that a png_error here stops the remainder of the
4477 * cleanup, but this is probably fine because that would indicate bad memory
4482 png_free(c.png_ptr, cp);
4484 /* Then the structures, calling the correct API. */
4485 if (c.for_write != 0)
4487 # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
4488 png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
4490 png_error(c.png_ptr, "simplified write not supported");
4495 # ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4496 png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
4498 png_error(c.png_ptr, "simplified read not supported");
4507 png_image_free(png_imagep image)
4509 /* Safely call the real function, but only if doing so is safe at this point
4510 * (if not inside an error handling context). Otherwise assume
4511 * png_safe_execute will call this API after the return.
4513 if (image != NULL && image->opaque != NULL &&
4514 image->opaque->error_buf == NULL)
4516 /* Ignore errors here: */
4517 (void)png_safe_execute(image, png_image_free_function, image);
4518 image->opaque = NULL;
4523 png_image_error(png_imagep image, png_const_charp error_message)
4525 /* Utility to log an error. */
4526 png_safecat(image->message, (sizeof image->message), 0, error_message);
4527 image->warning_or_error |= PNG_IMAGE_ERROR;
4528 png_image_free(image);
4532 #endif /* SIMPLIFIED READ/WRITE */
4533 #endif /* READ || WRITE */