2 /* png.c - location for general purpose libpng functions
4 * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
5 * Copyright (c) 1998-2014 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_7_0beta31 Your_png_h_is_not_version_1_7_0beta31;
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 png_debug(1, "in png_set_sig_bytes");
35 png_error(png_ptr, "Too many bytes for PNG signature");
37 png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
40 /* Checks whether the supplied bytes match the PNG signature. We allow
41 * checking less than the full 8-byte signature so that those apps that
42 * already read the first few bytes of a file to determine the file type
43 * can simply check the remaining bytes for extra assurance. Returns
44 * an integer less than, equal to, or greater than zero if sig is found,
45 * respectively, to be less than, to match, or be greater than the correct
46 * PNG signature (this is the same behavior as strcmp, memcmp, etc).
49 png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
51 png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
56 else if (num_to_check < 1)
62 if (start + num_to_check > 8)
63 num_to_check = 8 - start;
65 return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
68 #endif /* PNG_READ_SUPPORTED */
70 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
71 /* Function to allocate memory for zlib */
72 PNG_FUNCTION(voidpf /* PRIVATE */,
73 png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
75 png_alloc_size_t num_bytes = size;
80 if (items >= (~(png_alloc_size_t)0)/size)
82 png_warning (png_voidcast(png_structrp, png_ptr),
83 "Potential overflow in png_zalloc()");
88 return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
91 /* Function to free memory for zlib */
93 png_zfree(voidpf png_ptr, voidpf ptr)
95 png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
98 /* Reset the CRC variable to 32 bits of 1's. Care must be taken
99 * in case CRC is > 32 bits to leave the top bits 0.
102 png_reset_crc(png_structrp png_ptr)
104 /* The cast is safe because the crc is a 32 bit value. */
105 png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
108 /* Calculate the CRC over a section of data. We can only pass as
109 * much data to this routine as the largest single buffer size. We
110 * also check that this data will actually be used before going to the
111 * trouble of calculating it.
114 png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
118 if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))
120 if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
121 (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
127 if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
131 /* 'uLong' is defined in zlib.h as unsigned long; this means that on some
132 * systems it is a 64 bit value. crc32, however, returns 32 bits so the
133 * following cast is safe. 'uInt' may be no more than 16 bits, so it is
134 * necessary to perform a loop here.
136 if (need_crc && length > 0)
138 uLong crc = png_ptr->crc; /* Should never issue a warning */
142 uInt safe_length = (uInt)length;
143 if (safe_length == 0)
144 safe_length = (uInt)-1; /* evil, but safe */
146 crc = crc32(crc, ptr, safe_length);
148 /* The following should never issue compiler warnings; if they do the
149 * target system has characteristics that will probably violate other
150 * assumptions within the libpng code.
153 length -= safe_length;
157 /* And the following is always safe because the crc is only 32 bits. */
158 png_ptr->crc = (png_uint_32)crc;
162 /* Check a user supplied version number, called from both read and write
163 * functions that create a png_struct.
166 png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
174 if (user_png_ver[i] != png_libpng_ver[i])
175 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
176 } while (png_libpng_ver[i++]);
180 png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
182 if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
184 /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
185 * we must recompile any applications that use any older library version.
186 * For versions after libpng 1.0, we will be compatible, so we need
187 * only check the first and third digits (note that when we reach version
188 * 1.10 we will need to check the fourth symbol, namely user_png_ver[3]).
190 if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
191 (user_png_ver[0] == '1' && (user_png_ver[2] != png_libpng_ver[2] ||
192 user_png_ver[3] != png_libpng_ver[3])) ||
193 (user_png_ver[0] == '0' && user_png_ver[2] < '9'))
195 #ifdef PNG_WARNINGS_SUPPORTED
199 pos = png_safecat(m, (sizeof m), pos,
200 "Application built with libpng-");
201 pos = png_safecat(m, (sizeof m), pos, user_png_ver);
202 pos = png_safecat(m, (sizeof m), pos, " but running with ");
203 pos = png_safecat(m, (sizeof m), pos, png_libpng_ver);
206 png_warning(png_ptr, m);
209 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
217 /* Success return. */
221 /* Generic function to create a png_struct for either read or write - this
222 * contains the common initialization.
224 PNG_FUNCTION(png_structp /* PRIVATE */,
225 png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
226 png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
227 png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
229 png_struct create_struct;
230 # ifdef PNG_SETJMP_SUPPORTED
231 jmp_buf create_jmp_buf;
234 /* This temporary stack-allocated structure is used to provide a place to
235 * build enough context to allow the user provided memory allocator (if any)
238 memset(&create_struct, 0, (sizeof create_struct));
240 /* These limits are only used on read at present, and if READ is not turned
241 * on neither will USER_LIMITS be. The width/height and chunk malloc limits
242 * are constants, so if they cannot be set they don't get defined in
243 * png_struct, the user_chunk_cache limits is a down-counter, when it reaches
244 * 1 no more chunks will be handled. 0 means unlimited, consequently the
245 * limit is 1 more than the number of chunks that will be handled.
247 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
248 create_struct.user_width_max = PNG_USER_WIDTH_MAX;
249 create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
250 create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
252 # ifdef PNG_USER_LIMITS_SUPPORTED
253 /* Must exist even if the initial value is constant */
254 create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
257 /* The following two API calls simply set fields in png_struct, so it is safe
258 * to do them now even though error handling is not yet set up.
260 # ifdef PNG_USER_MEM_SUPPORTED
261 png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
264 PNG_UNUSED(malloc_fn)
268 /* (*error_fn) can return control to the caller after the error_ptr is set,
269 * this will result in a memory leak unless the error_fn does something
270 * extremely sophisticated. The design lacks merit but is implicit in the
273 png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
275 # ifdef PNG_SETJMP_SUPPORTED
276 if (!setjmp(create_jmp_buf))
278 /* Temporarily fake out the longjmp information until we have
279 * successfully completed this function. This only works if we have
280 * setjmp() support compiled in, but it is safe - this stuff should
283 create_struct.jmp_buf_ptr = &create_jmp_buf;
284 create_struct.jmp_buf_size = 0; /*stack allocation*/
285 create_struct.longjmp_fn = longjmp;
289 /* Call the general version checker (shared with read and write code):
291 if (png_user_version_check(&create_struct, user_png_ver))
293 png_structrp png_ptr = png_voidcast(png_structrp,
294 png_malloc_warn(&create_struct, (sizeof *png_ptr)));
298 /* png_ptr->zstream holds a back-pointer to the png_struct, so
299 * this can only be done now:
301 create_struct.zstream.zalloc = png_zalloc;
302 create_struct.zstream.zfree = png_zfree;
303 create_struct.zstream.opaque = png_ptr;
305 # ifdef PNG_SETJMP_SUPPORTED
306 /* Eliminate the local error handling: */
307 create_struct.jmp_buf_ptr = NULL;
308 create_struct.jmp_buf_size = 0;
309 create_struct.longjmp_fn = 0;
312 *png_ptr = create_struct;
314 /* This is the successful return point */
320 /* A longjmp because of a bug in the application storage allocator or a
321 * simple failure to allocate the png_struct.
326 /* Allocate the memory for an info_struct for the application. */
327 PNG_FUNCTION(png_infop,PNGAPI
328 png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
332 png_debug(1, "in png_create_info_struct");
337 /* Use the internal API that does not (or at least should not) error out, so
338 * that this call always returns ok. The application typically sets up the
339 * error handling *after* creating the info_struct because this is the way it
340 * has always been done in 'example.c'.
342 info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
343 (sizeof *info_ptr)));
345 if (info_ptr != NULL)
346 memset(info_ptr, 0, (sizeof *info_ptr));
351 /* This function frees the memory associated with a single info struct.
352 * Normally, one would use either png_destroy_read_struct() or
353 * png_destroy_write_struct() to free an info struct, but this may be
354 * useful for some applications. From libpng 1.6.0 this function is also used
355 * internally to implement the png_info release part of the 'struct' destroy
356 * APIs. This ensures that all possible approaches free the same data (all of
360 png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
362 png_inforp info_ptr = NULL;
364 png_debug(1, "in png_destroy_info_struct");
369 if (info_ptr_ptr != NULL)
370 info_ptr = *info_ptr_ptr;
372 if (info_ptr != NULL)
374 /* Do this first in case of an error below; if the app implements its own
375 * memory management this can lead to png_free calling png_error, which
376 * will abort this routine and return control to the app error handler.
377 * An infinite loop may result if it then tries to free the same info
380 *info_ptr_ptr = NULL;
382 png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
383 memset(info_ptr, 0, (sizeof *info_ptr));
384 png_free(png_ptr, info_ptr);
389 png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
392 png_debug(1, "in png_free_data");
394 if (png_ptr == NULL || info_ptr == NULL)
397 #ifdef PNG_TEXT_SUPPORTED
398 /* Free text item num or (if num == -1) all text items */
399 if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
403 if (info_ptr->text && info_ptr->text[num].key)
405 png_free(png_ptr, info_ptr->text[num].key);
406 info_ptr->text[num].key = NULL;
413 for (i = 0; i < info_ptr->num_text; i++)
414 png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
415 png_free(png_ptr, info_ptr->text);
416 info_ptr->text = NULL;
417 info_ptr->num_text=0;
422 #ifdef PNG_tRNS_SUPPORTED
423 /* Free any tRNS entry */
424 if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
426 info_ptr->valid &= ~PNG_INFO_tRNS;
427 png_free(png_ptr, info_ptr->trans_alpha);
428 info_ptr->trans_alpha = NULL;
429 info_ptr->num_trans = 0;
433 #ifdef PNG_sCAL_SUPPORTED
434 /* Free any sCAL entry */
435 if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
437 png_free(png_ptr, info_ptr->scal_s_width);
438 png_free(png_ptr, info_ptr->scal_s_height);
439 info_ptr->scal_s_width = NULL;
440 info_ptr->scal_s_height = NULL;
441 info_ptr->valid &= ~PNG_INFO_sCAL;
445 #ifdef PNG_pCAL_SUPPORTED
446 /* Free any pCAL entry */
447 if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
449 png_free(png_ptr, info_ptr->pcal_purpose);
450 png_free(png_ptr, info_ptr->pcal_units);
451 info_ptr->pcal_purpose = NULL;
452 info_ptr->pcal_units = NULL;
453 if (info_ptr->pcal_params != NULL)
456 for (i = 0; i < info_ptr->pcal_nparams; i++)
458 png_free(png_ptr, info_ptr->pcal_params[i]);
459 info_ptr->pcal_params[i] = NULL;
461 png_free(png_ptr, info_ptr->pcal_params);
462 info_ptr->pcal_params = NULL;
464 info_ptr->valid &= ~PNG_INFO_pCAL;
468 #ifdef PNG_iCCP_SUPPORTED
469 /* Free any profile entry */
470 if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
472 png_free(png_ptr, info_ptr->iccp_name);
473 png_free(png_ptr, info_ptr->iccp_profile);
474 info_ptr->iccp_name = NULL;
475 info_ptr->iccp_profile = NULL;
476 info_ptr->valid &= ~PNG_INFO_iCCP;
480 #ifdef PNG_sPLT_SUPPORTED
481 /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
482 if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
486 if (info_ptr->splt_palettes)
488 png_free(png_ptr, info_ptr->splt_palettes[num].name);
489 png_free(png_ptr, info_ptr->splt_palettes[num].entries);
490 info_ptr->splt_palettes[num].name = NULL;
491 info_ptr->splt_palettes[num].entries = NULL;
497 if (info_ptr->splt_palettes_num)
500 for (i = 0; i < info_ptr->splt_palettes_num; i++)
501 png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i);
503 png_free(png_ptr, info_ptr->splt_palettes);
504 info_ptr->splt_palettes = NULL;
505 info_ptr->splt_palettes_num = 0;
507 info_ptr->valid &= ~PNG_INFO_sPLT;
512 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
513 if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
517 if (info_ptr->unknown_chunks)
519 png_free(png_ptr, info_ptr->unknown_chunks[num].data);
520 info_ptr->unknown_chunks[num].data = NULL;
528 if (info_ptr->unknown_chunks_num)
530 for (i = 0; i < info_ptr->unknown_chunks_num; i++)
531 png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i);
533 png_free(png_ptr, info_ptr->unknown_chunks);
534 info_ptr->unknown_chunks = NULL;
535 info_ptr->unknown_chunks_num = 0;
541 #ifdef PNG_hIST_SUPPORTED
542 /* Free any hIST entry */
543 if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
545 png_free(png_ptr, info_ptr->hist);
546 info_ptr->hist = NULL;
547 info_ptr->valid &= ~PNG_INFO_hIST;
551 /* Free any PLTE entry that was internally allocated */
552 if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
554 png_free(png_ptr, info_ptr->palette);
555 info_ptr->palette = NULL;
556 info_ptr->valid &= ~PNG_INFO_PLTE;
557 info_ptr->num_palette = 0;
560 #ifdef PNG_INFO_IMAGE_SUPPORTED
561 /* Free any image bits attached to the info structure */
562 if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
564 if (info_ptr->row_pointers)
567 for (row = 0; row < info_ptr->height; row++)
569 png_free(png_ptr, info_ptr->row_pointers[row]);
570 info_ptr->row_pointers[row] = NULL;
572 png_free(png_ptr, info_ptr->row_pointers);
573 info_ptr->row_pointers = NULL;
575 info_ptr->valid &= ~PNG_INFO_IDAT;
580 mask &= ~PNG_FREE_MUL;
582 info_ptr->free_me &= ~mask;
584 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
586 /* This function returns a pointer to the io_ptr associated with the user
587 * functions. The application should free any memory associated with this
588 * pointer before png_write_destroy() or png_read_destroy() are called.
591 png_get_io_ptr(png_const_structrp png_ptr)
596 return (png_ptr->io_ptr);
599 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
600 # ifdef PNG_STDIO_SUPPORTED
601 /* Initialize the default input/output functions for the PNG file. If you
602 * use your own read or write routines, you can call either png_set_read_fn()
603 * or png_set_write_fn() instead of png_init_io(). If you have defined
604 * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
605 * function of your own because "FILE *" isn't necessarily available.
608 png_init_io(png_structrp png_ptr, png_FILE_p fp)
610 png_debug(1, "in png_init_io");
615 png_ptr->io_ptr = (png_voidp)fp;
619 #ifdef PNG_SAVE_INT_32_SUPPORTED
620 /* The png_save_int_32 function assumes integers are stored in two's
621 * complement format. If this isn't the case, then this routine needs to
622 * be modified to write data in two's complement format. Note that,
623 * the following works correctly even if png_int_32 has more than 32 bits
624 * (compare the more complex code required on read for sign extension.)
627 png_save_int_32(png_bytep buf, png_int_32 i)
629 buf[0] = (png_byte)((i >> 24) & 0xff);
630 buf[1] = (png_byte)((i >> 16) & 0xff);
631 buf[2] = (png_byte)((i >> 8) & 0xff);
632 buf[3] = (png_byte)(i & 0xff);
636 # ifdef PNG_TIME_RFC1123_SUPPORTED
637 /* Convert the supplied time into an RFC 1123 string suitable for use in
638 * a "Creation Time" or other text-based time string.
641 png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
643 static PNG_CONST char short_months[12][4] =
644 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
645 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
650 if (ptime->year > 9999 /* RFC1123 limitation */ ||
651 ptime->month == 0 || ptime->month > 12 ||
652 ptime->day == 0 || ptime->day > 31 ||
653 ptime->hour > 23 || ptime->minute > 59 ||
659 char number_buf[5]; /* enough for a four-digit year */
661 # define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
662 # define APPEND_NUMBER(format, value)\
663 APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
664 # define APPEND(ch) if (pos < 28) out[pos++] = (ch)
666 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
668 APPEND_STRING(short_months[(ptime->month - 1)]);
670 APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
672 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
674 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
676 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
677 APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
680 # undef APPEND_NUMBER
681 # undef APPEND_STRING
686 # endif /* PNG_TIME_RFC1123_SUPPORTED */
688 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
690 png_const_charp PNGAPI
691 png_get_copyright(png_const_structrp png_ptr)
693 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
694 #ifdef PNG_STRING_COPYRIGHT
695 return PNG_STRING_COPYRIGHT
698 return PNG_STRING_NEWLINE \
699 "libpng version 1.7.0beta31 - February 6, 2014" PNG_STRING_NEWLINE \
700 "Copyright (c) 1998-2014 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
701 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
702 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
705 return "libpng version 1.7.0beta31 - February 6, 2014\
706 Copyright (c) 1998-2014 Glenn Randers-Pehrson\
707 Copyright (c) 1996-1997 Andreas Dilger\
708 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
713 /* The following return the library version as a short string in the
714 * format 1.0.0 through 99.99.99zz. To get the version of *.h files
715 * used with your application, print out PNG_LIBPNG_VER_STRING, which
716 * is defined in png.h.
717 * Note: now there is no difference between png_get_libpng_ver() and
718 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
719 * it is guaranteed that png.c uses the correct version of png.h.
721 png_const_charp PNGAPI
722 png_get_libpng_ver(png_const_structrp png_ptr)
724 /* Version of *.c files used when building libpng */
725 return png_get_header_ver(png_ptr);
728 png_const_charp PNGAPI
729 png_get_header_ver(png_const_structrp png_ptr)
731 /* Version of *.h files used when building libpng */
732 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
733 return PNG_LIBPNG_VER_STRING;
736 png_const_charp PNGAPI
737 png_get_header_version(png_const_structrp png_ptr)
739 /* Returns longer string containing both version and date */
740 PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
742 return PNG_HEADER_VERSION_STRING
743 # ifndef PNG_READ_SUPPORTED
748 return PNG_HEADER_VERSION_STRING;
752 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
753 /* NOTE: this routine is not used internally! */
754 /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
755 * large of png_color. This lets grayscale images be treated as
756 * paletted. Most useful for gamma correction and simplification
757 * of code. This API is not used internally.
760 png_build_grayscale_palette(int bit_depth, png_colorp palette)
767 png_debug(1, "in png_do_build_grayscale_palette");
800 for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
802 palette[i].red = (png_byte)v;
803 palette[i].green = (png_byte)v;
804 palette[i].blue = (png_byte)v;
809 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
811 png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
813 /* Check chunk_name and return "keep" value if it's on the list, else 0 */
814 png_const_bytep p, p_end;
816 if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
817 return PNG_HANDLE_CHUNK_AS_DEFAULT;
819 p_end = png_ptr->chunk_list;
820 p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
822 /* The code is the fifth byte after each four byte string. Historically this
823 * code was always searched from the end of the list, this is no longer
824 * necessary because the 'set' routine handles duplicate entries correcty.
826 do /* num_chunk_list > 0, so at least one */
830 if (!memcmp(chunk_name, p, 4))
835 /* This means that known chunks should be processed and unknown chunks should
836 * be handled according to the value of png_ptr->unknown_default; this can be
837 * confusing because, as a result, there are two levels of defaulting for
840 return PNG_HANDLE_CHUNK_AS_DEFAULT;
843 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
844 defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
846 png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
848 png_byte chunk_string[5];
850 PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
851 return png_handle_as_unknown(png_ptr, chunk_string);
853 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
854 #endif /* SET_UNKNOWN_CHUNKS */
856 /* This function was added to libpng-1.0.7 */
858 png_access_version_number(void)
860 /* Version of *.c files used when building libpng */
861 return((png_uint_32)PNG_LIBPNG_VER);
864 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
865 /* Ensure that png_ptr->zstream.msg holds some appropriate error message string.
866 * If it doesn't 'ret' is used to set it to something appropriate, even in cases
867 * like Z_OK or Z_STREAM_END where the error code is apparently a success code.
870 png_zstream_error(png_structrp png_ptr, int ret)
872 /* Translate 'ret' into an appropriate error string, priority is given to the
873 * one in zstream if set. This always returns a string, even in cases like
874 * Z_OK or Z_STREAM_END where the error code is a success code.
876 if (png_ptr->zstream.msg == NULL) switch (ret)
880 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
885 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
889 /* This means the deflate stream did not have a dictionary; this
890 * indicates a bogus PNG.
892 png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
896 /* gz APIs only: should not happen */
897 png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
901 /* internal libpng error */
902 png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
906 png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
910 png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
914 /* End of input or output; not a problem if the caller is doing
915 * incremental read or write.
917 png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
920 case Z_VERSION_ERROR:
921 png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
924 case PNG_UNEXPECTED_ZLIB_RETURN:
925 /* Compile errors here mean that zlib now uses the value co-opted in
926 * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above
927 * and change pngpriv.h. Note that this message is "... return",
928 * whereas the default/Z_OK one is "... return code".
930 png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
935 /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
939 /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
940 #ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */
942 png_colorspace_check_gamma(png_const_structrp png_ptr,
943 png_colorspacerp colorspace, png_fixed_point gAMA, int from)
944 /* This is called to check a new gamma value against an existing one. The
945 * routine returns false if the new gamma value should not be written.
947 * 'from' says where the new gamma value comes from:
949 * 0: the new gamma value is the libpng estimate for an ICC profile
950 * 1: the new gamma value comes from a gAMA chunk
951 * 2: the new gamma value comes from an sRGB chunk
954 png_fixed_point gtest;
956 if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
957 (!png_muldiv(>est, colorspace->gamma, PNG_FP_1, gAMA) ||
958 png_gamma_significant(gtest)))
960 /* Either this is an sRGB image, in which case the calculated gamma
961 * approximation should match, or this is an image with a profile and the
962 * value libpng calculates for the gamma of the profile does not match the
963 * value recorded in the file. The former, sRGB, case is an error, the
964 * latter is just a warning.
966 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
968 png_chunk_report(png_ptr, "gamma value does not match sRGB",
970 /* Do not overwrite an sRGB value */
974 else /* sRGB tag not involved */
976 png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
986 png_colorspace_set_gamma(png_const_structrp png_ptr,
987 png_colorspacerp colorspace, png_fixed_point gAMA)
989 /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
990 * occur. Since the fixed point representation is assymetrical it is
991 * possible for 1/gamma to overflow the limit of 21474 and this means the
992 * gamma value must be at least 5/100000 and hence at most 20000.0. For
993 * safety the limits here are a little narrower. The values are 0.00016 to
994 * 6250.0, which are truly ridiculous gamma values (and will produce
995 * displays that are all black or all white.)
997 * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
998 * handling code, which only required the value to be >0.
1000 png_const_charp errmsg;
1002 if (gAMA < 16 || gAMA > 625000000)
1003 errmsg = "gamma value out of range";
1005 # ifdef PNG_READ_gAMA_SUPPORTED
1006 /* Allow the application to set the gamma value more than once */
1007 else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
1008 (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
1009 errmsg = "duplicate";
1012 /* Do nothing if the colorspace is already invalid */
1013 else if (colorspace->flags & PNG_COLORSPACE_INVALID)
1018 if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/))
1020 /* Store this gamma value. */
1021 colorspace->gamma = gAMA;
1022 colorspace->flags |=
1023 (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
1026 /* At present if the check_gamma test fails the gamma of the colorspace is
1027 * not updated however the colorspace is not invalidated. This
1028 * corresponds to the case where the existing gamma comes from an sRGB
1029 * chunk or profile. An error message has already been output.
1034 /* Error exit - errmsg has been set. */
1035 colorspace->flags |= PNG_COLORSPACE_INVALID;
1036 png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
1040 png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
1042 if (info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)
1044 /* Everything is invalid */
1045 info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
1048 # ifdef PNG_COLORSPACE_SUPPORTED
1049 /* Clean up the iCCP profile now if it won't be used. */
1050 png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
1058 # ifdef PNG_COLORSPACE_SUPPORTED
1059 /* Leave the INFO_iCCP flag set if the pngset.c code has already set
1060 * it; this allows a PNG to contain a profile which matches sRGB and
1061 * yet still have that profile retrievable by the application.
1063 if (info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB)
1064 info_ptr->valid |= PNG_INFO_sRGB;
1067 info_ptr->valid &= ~PNG_INFO_sRGB;
1069 if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)
1070 info_ptr->valid |= PNG_INFO_cHRM;
1073 info_ptr->valid &= ~PNG_INFO_cHRM;
1076 if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA)
1077 info_ptr->valid |= PNG_INFO_gAMA;
1080 info_ptr->valid &= ~PNG_INFO_gAMA;
1084 #ifdef PNG_READ_SUPPORTED
1086 png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
1088 if (info_ptr == NULL) /* reduce code size; check here not in the caller */
1091 info_ptr->colorspace = png_ptr->colorspace;
1092 png_colorspace_sync_info(png_ptr, info_ptr);
1097 #ifdef PNG_COLORSPACE_SUPPORTED
1098 /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
1099 * cHRM, as opposed to using chromaticities. These internal APIs return
1100 * non-zero on a parameter error. The X, Y and Z values are required to be
1101 * positive and less than 1.0.
1104 png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
1106 png_int_32 d, dwhite, whiteX, whiteY;
1108 d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;
1109 if (!png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d)) return 1;
1110 if (!png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d)) return 1;
1112 whiteX = XYZ->red_X;
1113 whiteY = XYZ->red_Y;
1115 d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;
1116 if (!png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d)) return 1;
1117 if (!png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d)) return 1;
1119 whiteX += XYZ->green_X;
1120 whiteY += XYZ->green_Y;
1122 d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;
1123 if (!png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d)) return 1;
1124 if (!png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d)) return 1;
1126 whiteX += XYZ->blue_X;
1127 whiteY += XYZ->blue_Y;
1129 /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
1132 if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1;
1133 if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1;
1139 png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
1141 png_fixed_point red_inverse, green_inverse, blue_scale;
1142 png_fixed_point left, right, denominator;
1144 /* Check xy and, implicitly, z. Note that wide gamut color spaces typically
1145 * have end points with 0 tristimulus values (these are impossible end
1146 * points, but they are used to cover the possible colors.)
1148 if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1;
1149 if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1;
1150 if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1;
1151 if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1;
1152 if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1;
1153 if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1;
1154 if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1;
1155 if (xy->whitey < 0 || xy->whitey > PNG_FP_1-xy->whitex) return 1;
1157 /* The reverse calculation is more difficult because the original tristimulus
1158 * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
1159 * derived values were recorded in the cHRM chunk;
1160 * (red,green,blue,white)x(x,y). This loses one degree of freedom and
1161 * therefore an arbitrary ninth value has to be introduced to undo the
1162 * original transformations.
1164 * Think of the original end-points as points in (X,Y,Z) space. The
1165 * chromaticity values (c) have the property:
1171 * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the
1172 * three chromaticity values (x,y,z) for each end-point obey the
1177 * This describes the plane in (X,Y,Z) space that intersects each axis at the
1178 * value 1.0; call this the chromaticity plane. Thus the chromaticity
1179 * calculation has scaled each end-point so that it is on the x+y+z=1 plane
1180 * and chromaticity is the intersection of the vector from the origin to the
1181 * (X,Y,Z) value with the chromaticity plane.
1183 * To fully invert the chromaticity calculation we would need the three
1184 * end-point scale factors, (red-scale, green-scale, blue-scale), but these
1185 * were not recorded. Instead we calculated the reference white (X,Y,Z) and
1186 * recorded the chromaticity of this. The reference white (X,Y,Z) would have
1187 * given all three of the scale factors since:
1189 * color-C = color-c * color-scale
1190 * white-C = red-C + green-C + blue-C
1191 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
1193 * But cHRM records only white-x and white-y, so we have lost the white scale
1196 * white-C = white-c*white-scale
1198 * To handle this the inverse transformation makes an arbitrary assumption
1199 * about white-scale:
1201 * Assume: white-Y = 1.0
1202 * Hence: white-scale = 1/white-y
1203 * Or: red-Y + green-Y + blue-Y = 1.0
1205 * Notice the last statement of the assumption gives an equation in three of
1206 * the nine values we want to calculate. 8 more equations come from the
1207 * above routine as summarised at the top above (the chromaticity
1210 * Given: color-x = color-X / (color-X + color-Y + color-Z)
1211 * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
1213 * This is 9 simultaneous equations in the 9 variables "color-C" and can be
1214 * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix
1215 * determinants, however this is not as bad as it seems because only 28 of
1216 * the total of 90 terms in the various matrices are non-zero. Nevertheless
1217 * Cramer's rule is notoriously numerically unstable because the determinant
1218 * calculation involves the difference of large, but similar, numbers. It is
1219 * difficult to be sure that the calculation is stable for real world values
1220 * and it is certain that it becomes unstable where the end points are close
1223 * So this code uses the perhaps slightly less optimal but more
1224 * understandable and totally obvious approach of calculating color-scale.
1226 * This algorithm depends on the precision in white-scale and that is
1227 * (1/white-y), so we can immediately see that as white-y approaches 0 the
1228 * accuracy inherent in the cHRM chunk drops off substantially.
1230 * libpng arithmetic: a simple invertion of the above equations
1231 * ------------------------------------------------------------
1233 * white_scale = 1/white-y
1234 * white-X = white-x * white-scale
1236 * white-Z = (1 - white-x - white-y) * white_scale
1238 * white-C = red-C + green-C + blue-C
1239 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
1241 * This gives us three equations in (red-scale,green-scale,blue-scale) where
1242 * all the coefficients are now known:
1244 * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
1246 * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
1247 * red-z*red-scale + green-z*green-scale + blue-z*blue-scale
1248 * = (1 - white-x - white-y)/white-y
1250 * In the last equation color-z is (1 - color-x - color-y) so we can add all
1251 * three equations together to get an alternative third:
1253 * red-scale + green-scale + blue-scale = 1/white-y = white-scale
1255 * So now we have a Cramer's rule solution where the determinants are just
1256 * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve
1257 * multiplication of three coefficients so we can't guarantee to avoid
1258 * overflow in the libpng fixed point representation. Using Cramer's rule in
1259 * floating point is probably a good choice here, but it's not an option for
1260 * fixed point. Instead proceed to simplify the first two equations by
1261 * eliminating what is likely to be the largest value, blue-scale:
1263 * blue-scale = white-scale - red-scale - green-scale
1267 * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
1268 * (white-x - blue-x)*white-scale
1270 * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
1271 * 1 - blue-y*white-scale
1273 * And now we can trivially solve for (red-scale,green-scale):
1276 * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
1277 * -----------------------------------------------------------
1281 * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
1282 * ---------------------------------------------------------
1288 * ( (green-x - blue-x) * (white-y - blue-y) -
1289 * (green-y - blue-y) * (white-x - blue-x) ) / white-y
1290 * -------------------------------------------------------------------------
1291 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1294 * ( (red-y - blue-y) * (white-x - blue-x) -
1295 * (red-x - blue-x) * (white-y - blue-y) ) / white-y
1296 * -------------------------------------------------------------------------
1297 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1300 * The input values have 5 decimal digits of accuracy. The values are all in
1301 * the range 0 < value < 1, so simple products are in the same range but may
1302 * need up to 10 decimal digits to preserve the original precision and avoid
1303 * underflow. Because we are using a 32-bit signed representation we cannot
1304 * match this; the best is a little over 9 decimal digits, less than 10.
1306 * The approach used here is to preserve the maximum precision within the
1307 * signed representation. Because the red-scale calculation above uses the
1308 * difference between two products of values that must be in the range -1..+1
1309 * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The
1310 * factor is irrelevant in the calculation because it is applied to both
1311 * numerator and denominator.
1313 * Note that the values of the differences of the products of the
1314 * chromaticities in the above equations tend to be small, for example for
1315 * the sRGB chromaticities they are:
1317 * red numerator: -0.04751
1318 * green numerator: -0.08788
1319 * denominator: -0.2241 (without white-y multiplication)
1321 * The resultant Y coefficients from the chromaticities of some widely used
1322 * color space definitions are (to 15 decimal places):
1325 * 0.212639005871510 0.715168678767756 0.072192315360734
1327 * 0.288071128229293 0.711843217810102 0.000085653960605
1329 * 0.297344975250536 0.627363566255466 0.075291458493998
1330 * Adobe Wide Gamut RGB
1331 * 0.258728243040113 0.724682314948566 0.016589442011321
1333 /* By the argument, above overflow should be impossible here. The return
1334 * value of 2 indicates an internal error to the caller.
1336 if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7))
1338 if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7))
1340 denominator = left - right;
1342 /* Now find the red numerator. */
1343 if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7))
1345 if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7))
1348 /* Overflow is possible here and it indicates an extreme set of PNG cHRM
1349 * chunk values. This calculation actually returns the reciprocal of the
1350 * scale value because this allows us to delay the multiplication of white-y
1351 * into the denominator, which tends to produce a small number.
1353 if (!png_muldiv(&red_inverse, xy->whitey, denominator, left-right) ||
1354 red_inverse <= xy->whitey /* r+g+b scales = white scale */)
1357 /* Similarly for green_inverse: */
1358 if (!png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7))
1360 if (!png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7))
1362 if (!png_muldiv(&green_inverse, xy->whitey, denominator, left-right) ||
1363 green_inverse <= xy->whitey)
1366 /* And the blue scale, the checks above guarantee this can't overflow but it
1367 * can still produce 0 for extreme cHRM values.
1369 blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
1370 png_reciprocal(green_inverse);
1371 if (blue_scale <= 0) return 1;
1374 /* And fill in the png_XYZ: */
1375 if (!png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse)) return 1;
1376 if (!png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse)) return 1;
1377 if (!png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
1381 if (!png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse))
1383 if (!png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse))
1385 if (!png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
1389 if (!png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1)) return 1;
1390 if (!png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1)) return 1;
1391 if (!png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
1395 return 0; /*success*/
1399 png_XYZ_normalize(png_XYZ *XYZ)
1403 if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 ||
1404 XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 ||
1405 XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0)
1408 /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1.
1409 * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore
1410 * relying on addition of two positive values producing a negative one is not
1414 if (0x7fffffff - Y < XYZ->green_X) return 1;
1416 if (0x7fffffff - Y < XYZ->blue_X) return 1;
1421 if (!png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y)) return 1;
1422 if (!png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y)) return 1;
1423 if (!png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y)) return 1;
1425 if (!png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y)) return 1;
1426 if (!png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y)) return 1;
1427 if (!png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y)) return 1;
1429 if (!png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y)) return 1;
1430 if (!png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y)) return 1;
1431 if (!png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y)) return 1;
1438 png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
1440 /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
1441 return !(PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
1442 PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
1443 PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) ||
1444 PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) ||
1445 PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||
1446 PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||
1447 PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) ||
1448 PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta));
1451 /* Added in libpng-1.6.0, a different check for the validity of a set of cHRM
1452 * chunk chromaticities. Earlier checks used to simply look for the overflow
1453 * condition (where the determinant of the matrix to solve for XYZ ends up zero
1454 * because the chromaticity values are not all distinct.) Despite this it is
1455 * theoretically possible to produce chromaticities that are apparently valid
1456 * but that rapidly degrade to invalid, potentially crashing, sets because of
1457 * arithmetic inaccuracies when calculations are performed on them. The new
1458 * check is to round-trip xy -> XYZ -> xy and then check that the result is
1459 * within a small percentage of the original.
1462 png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
1467 /* As a side-effect this routine also returns the XYZ endpoints. */
1468 result = png_XYZ_from_xy(XYZ, xy);
1469 if (result) return result;
1471 result = png_xy_from_XYZ(&xy_test, XYZ);
1472 if (result) return result;
1474 if (png_colorspace_endpoints_match(xy, &xy_test,
1475 5/*actually, the math is pretty accurate*/))
1482 /* This is the check going the other way. The XYZ is modified to normalize it
1483 * (another side-effect) and the xy chromaticities are returned.
1486 png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
1491 result = png_XYZ_normalize(XYZ);
1492 if (result) return result;
1494 result = png_xy_from_XYZ(xy, XYZ);
1495 if (result) return result;
1498 return png_colorspace_check_xy(&XYZtemp, xy);
1501 /* Used to check for an endpoint match against sRGB */
1502 static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
1505 /* red */ 64000, 33000,
1506 /* green */ 30000, 60000,
1507 /* blue */ 15000, 6000,
1508 /* white */ 31270, 32900
1512 png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
1513 png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
1516 if (colorspace->flags & PNG_COLORSPACE_INVALID)
1519 /* The consistency check is performed on the chromaticities; this factors out
1520 * variations because of the normalization (or not) of the end point Y
1523 if (preferred < 2 && (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS))
1525 /* The end points must be reasonably close to any we already have. The
1526 * following allows an error of up to +/-.001
1528 if (!png_colorspace_endpoints_match(xy, &colorspace->end_points_xy, 100))
1530 colorspace->flags |= PNG_COLORSPACE_INVALID;
1531 png_benign_error(png_ptr, "inconsistent chromaticities");
1532 return 0; /* failed */
1535 /* Only overwrite with preferred values */
1537 return 1; /* ok, but no change */
1540 colorspace->end_points_xy = *xy;
1541 colorspace->end_points_XYZ = *XYZ;
1542 colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;
1544 /* The end points are normally quoted to two decimal digits, so allow +/-0.01
1547 if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000))
1548 colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
1551 colorspace->flags &= PNG_COLORSPACE_CANCEL(
1552 PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
1554 return 2; /* ok and changed */
1558 png_colorspace_set_chromaticities(png_const_structrp png_ptr,
1559 png_colorspacerp colorspace, const png_xy *xy, int preferred)
1561 /* We must check the end points to ensure they are reasonable - in the past
1562 * color management systems have crashed as a result of getting bogus
1563 * colorant values, while this isn't the fault of libpng it is the
1564 * responsibility of libpng because PNG carries the bomb and libpng is in a
1565 * position to protect against it.
1569 switch (png_colorspace_check_xy(&XYZ, xy))
1571 case 0: /* success */
1572 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
1576 /* We can't invert the chromaticities so we can't produce value XYZ
1577 * values. Likely as not a color management system will fail too.
1579 colorspace->flags |= PNG_COLORSPACE_INVALID;
1580 png_benign_error(png_ptr, "invalid chromaticities");
1584 /* libpng is broken; this should be a warning but if it happens we
1585 * want error reports so for the moment it is an error.
1587 colorspace->flags |= PNG_COLORSPACE_INVALID;
1588 png_error(png_ptr, "internal error checking chromaticities");
1592 return 0; /* failed */
1596 png_colorspace_set_endpoints(png_const_structrp png_ptr,
1597 png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
1599 png_XYZ XYZ = *XYZ_in;
1602 switch (png_colorspace_check_XYZ(&xy, &XYZ))
1605 return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
1609 /* End points are invalid. */
1610 colorspace->flags |= PNG_COLORSPACE_INVALID;
1611 png_benign_error(png_ptr, "invalid end points");
1615 colorspace->flags |= PNG_COLORSPACE_INVALID;
1616 png_error(png_ptr, "internal error checking chromaticities");
1620 return 0; /* failed */
1623 #if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)
1624 /* Error message generation */
1626 png_icc_tag_char(png_uint_32 byte)
1629 if (byte >= 32 && byte <= 126)
1636 png_icc_tag_name(char *name, png_uint_32 tag)
1639 name[1] = png_icc_tag_char(tag >> 24);
1640 name[2] = png_icc_tag_char(tag >> 16);
1641 name[3] = png_icc_tag_char(tag >> 8);
1642 name[4] = png_icc_tag_char(tag );
1647 is_ICC_signature_char(png_alloc_size_t it)
1649 return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||
1650 (it >= 97 && it <= 122);
1653 static int is_ICC_signature(png_alloc_size_t it)
1655 return is_ICC_signature_char(it >> 24) /* checks all the top bits */ &&
1656 is_ICC_signature_char((it >> 16) & 0xff) &&
1657 is_ICC_signature_char((it >> 8) & 0xff) &&
1658 is_ICC_signature_char(it & 0xff);
1662 png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
1663 png_const_charp name, png_alloc_size_t value, png_const_charp reason)
1666 char message[196]; /* see below for calculation */
1668 if (colorspace != NULL)
1669 colorspace->flags |= PNG_COLORSPACE_INVALID;
1671 pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */
1672 pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */
1673 pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */
1674 if (is_ICC_signature(value))
1676 /* So 'value' is at most 4 bytes and the following cast is safe */
1677 png_icc_tag_name(message+pos, (png_uint_32)value);
1678 pos += 6; /* total +8; less than the else clause */
1679 message[pos++] = ':';
1680 message[pos++] = ' ';
1682 # ifdef PNG_WARNINGS_SUPPORTED
1685 char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
1687 pos = png_safecat(message, (sizeof message), pos,
1688 png_format_number(number, number+(sizeof number),
1689 PNG_NUMBER_FORMAT_x, value));
1690 pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/
1693 /* The 'reason' is an arbitrary message, allow +79 maximum 195 */
1694 pos = png_safecat(message, (sizeof message), pos, reason);
1697 /* This is recoverable, but make it unconditionally an app_error on write to
1698 * avoid writing invalid ICC profiles into PNG files. (I.e. we handle them
1699 * on read, with a warning, but on write unless the app turns off
1700 * application errors the PNG won't be written.)
1702 png_chunk_report(png_ptr, message,
1703 (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
1707 #endif /* sRGB || iCCP */
1709 #ifdef PNG_sRGB_SUPPORTED
1711 png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
1714 /* sRGB sets known gamma, end points and (from the chunk) intent. */
1715 /* IMPORTANT: these are not necessarily the values found in an ICC profile
1716 * because ICC profiles store values adapted to a D50 environment; it is
1717 * expected that the ICC profile mediaWhitePointTag will be D50, see the
1718 * checks and code elsewhere to understand this better.
1720 * These XYZ values, which are accurate to 5dp, produce rgb to gray
1721 * coefficients of (6968,23435,2366), which are reduced (because they add up
1722 * to 32769 not 32768) to (6968,23434,2366). These are the values that
1723 * libpng has traditionally used (and are the best values given the 15bit
1724 * algorithm used by the rgb to gray code.)
1726 static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
1729 /* red */ 41239, 21264, 1933,
1730 /* green */ 35758, 71517, 11919,
1731 /* blue */ 18048, 7219, 95053
1734 /* Do nothing if the colorspace is already invalidated. */
1735 if (colorspace->flags & PNG_COLORSPACE_INVALID)
1738 /* Check the intent, then check for existing settings. It is valid for the
1739 * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must
1740 * be consistent with the correct values. If, however, this function is
1741 * called below because an iCCP chunk matches sRGB then it is quite
1742 * conceivable that an older app recorded incorrect gAMA and cHRM because of
1743 * an incorrect calculation based on the values in the profile - this does
1744 * *not* invalidate the profile (though it still produces an error, which can
1747 if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
1748 return png_icc_profile_error(png_ptr, colorspace, "sRGB",
1749 (unsigned)intent, "invalid sRGB rendering intent");
1751 if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
1752 colorspace->rendering_intent != intent)
1753 return png_icc_profile_error(png_ptr, colorspace, "sRGB",
1754 (unsigned)intent, "inconsistent rendering intents");
1756 if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
1758 png_benign_error(png_ptr, "duplicate sRGB information ignored");
1762 /* If the standard sRGB cHRM chunk does not match the one from the PNG file
1763 * warn but overwrite the value with the correct one.
1765 if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
1766 !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
1768 png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
1771 /* This check is just done for the error reporting - the routine always
1772 * returns true when the 'from' argument corresponds to sRGB (2).
1774 (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
1777 /* intent: bugs in GCC force 'int' to be used as the parameter type. */
1778 colorspace->rendering_intent = (png_uint_16)intent;
1779 colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;
1782 colorspace->end_points_xy = sRGB_xy;
1783 colorspace->end_points_XYZ = sRGB_XYZ;
1784 colorspace->flags |=
1785 (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
1788 colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
1789 colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
1791 /* Finally record that we have an sRGB profile */
1792 colorspace->flags |=
1793 (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
1799 #ifdef PNG_iCCP_SUPPORTED
1800 /* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value
1801 * is XYZ(0.9642,1.0,0.8249), which scales to:
1803 * (63189.8112, 65536, 54060.6464)
1805 static const png_byte D50_nCIEXYZ[12] =
1806 { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };
1809 png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
1810 png_const_charp name, png_uint_32 profile_length)
1812 if (profile_length < 132)
1813 return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
1816 if (profile_length & 3)
1817 return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
1824 png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
1825 png_const_charp name, png_uint_32 profile_length,
1826 png_const_bytep profile/* first 132 bytes only */, int color_type)
1830 /* Length check; this cannot be ignored in this code because profile_length
1831 * is used later to check the tag table, so even if the profile seems over
1832 * long profile_length from the caller must be correct. The caller can fix
1833 * this up on read or write by just passing in the profile header length.
1835 temp = png_get_uint_32(profile);
1836 if (temp != profile_length)
1837 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1838 "length does not match profile");
1840 temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
1841 if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
1842 profile_length < 132+12*temp) /* truncated tag table */
1843 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1844 "tag count too large");
1846 /* The 'intent' must be valid or we can't store it, ICC limits the intent to
1849 temp = png_get_uint_32(profile+64);
1850 if (temp >= 0xffff) /* The ICC limit */
1851 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1852 "invalid rendering intent");
1854 /* This is just a warning because the profile may be valid in future
1857 if (temp >= PNG_sRGB_INTENT_LAST)
1858 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
1859 "intent outside defined range");
1861 /* At this point the tag table can't be checked because it hasn't necessarily
1862 * been loaded; however, various header fields can be checked. These checks
1863 * are for values permitted by the PNG spec in an ICC profile; the PNG spec
1864 * restricts the profiles that can be passed in an iCCP chunk (they must be
1865 * appropriate to processing PNG data!)
1868 /* Data checks (could be skipped). These checks must be independent of the
1869 * version number; however, the version number doesn't accomodate changes in
1870 * the header fields (just the known tags and the interpretation of the
1873 temp = png_get_uint_32(profile+36); /* signature 'ascp' */
1874 if (temp != 0x61637370)
1875 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1876 "invalid signature");
1878 /* Currently the PCS illuminant/adopted white point (the computational
1879 * white point) are required to be D50,
1880 * however the profile contains a record of the illuminant so perhaps ICC
1881 * expects to be able to change this in the future (despite the rationale in
1882 * the introduction for using a fixed PCS adopted white.) Consequently the
1883 * following is just a warning.
1885 if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
1886 (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
1887 "PCS illuminant is not D50");
1889 /* The PNG spec requires this:
1890 * "If the iCCP chunk is present, the image samples conform to the colour
1891 * space represented by the embedded ICC profile as defined by the
1892 * International Color Consortium [ICC]. The colour space of the ICC profile
1893 * shall be an RGB colour space for colour images (PNG colour types 2, 3, and
1894 * 6), or a greyscale colour space for greyscale images (PNG colour types 0
1897 * This checking code ensures the embedded profile (on either read or write)
1898 * conforms to the specification requirements. Notice that an ICC 'gray'
1899 * color-space profile contains the information to transform the monochrome
1900 * data to XYZ or L*a*b (according to which PCS the profile uses) and this
1901 * should be used in preference to the standard libpng K channel replication
1902 * into R, G and B channels.
1904 * Previously it was suggested that an RGB profile on grayscale data could be
1905 * handled. However it it is clear that using an RGB profile in this context
1906 * must be an error - there is no specification of what it means. Thus it is
1907 * almost certainly more correct to ignore the profile.
1909 temp = png_get_uint_32(profile+16); /* data colour space field */
1912 case 0x52474220: /* 'RGB ' */
1913 if (!(color_type & PNG_COLOR_MASK_COLOR))
1914 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1915 "RGB color space not permitted on grayscale PNG");
1918 case 0x47524159: /* 'GRAY' */
1919 if (color_type & PNG_COLOR_MASK_COLOR)
1920 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1921 "Gray color space not permitted on RGB PNG");
1925 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1926 "invalid ICC profile color space");
1929 /* It is up to the application to check that the profile class matches the
1930 * application requirements; the spec provides no guidance, but it's pretty
1931 * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer
1932 * ('prtr') or 'spac' (for generic color spaces). Issue a warning in these
1933 * cases. Issue an error for device link or abstract profiles - these don't
1934 * contain the records necessary to transform the color-space to anything
1935 * other than the target device (and not even that for an abstract profile).
1936 * Profiles of these classes may not be embedded in images.
1938 temp = png_get_uint_32(profile+12); /* profile/device class */
1941 case 0x73636E72: /* 'scnr' */
1942 case 0x6D6E7472: /* 'mntr' */
1943 case 0x70727472: /* 'prtr' */
1944 case 0x73706163: /* 'spac' */
1948 case 0x61627374: /* 'abst' */
1949 /* May not be embedded in an image */
1950 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1951 "invalid embedded Abstract ICC profile");
1953 case 0x6C696E6B: /* 'link' */
1954 /* DeviceLink profiles cannnot be interpreted in a non-device specific
1955 * fashion, if an app uses the AToB0Tag in the profile the results are
1956 * undefined unless the result is sent to the intended device,
1957 * therefore a DeviceLink profile should not be found embedded in a
1960 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1961 "unexpected DeviceLink ICC profile class");
1963 case 0x6E6D636C: /* 'nmcl' */
1964 /* A NamedColor profile is also device specific, however it doesn't
1965 * contain an AToB0 tag that is open to misintrepretation. Almost
1966 * certainly it will fail the tests below.
1968 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
1969 "unexpected NamedColor ICC profile class");
1973 /* To allow for future enhancements to the profile accept unrecognized
1974 * profile classes with a warning, these then hit the test below on the
1975 * tag content to ensure they are backward compatible with one of the
1976 * understood profiles.
1978 (void)png_icc_profile_error(png_ptr, NULL, name, temp,
1979 "unrecognized ICC profile class");
1983 /* For any profile other than a device link one the PCS must be encoded
1984 * either in XYZ or Lab.
1986 temp = png_get_uint_32(profile+20);
1989 case 0x58595A20: /* 'XYZ ' */
1990 case 0x4C616220: /* 'Lab ' */
1994 return png_icc_profile_error(png_ptr, colorspace, name, temp,
1995 "unexpected ICC PCS encoding");
2002 png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
2003 png_const_charp name, png_uint_32 profile_length,
2004 png_const_bytep profile /* header plus whole tag table */)
2006 png_uint_32 tag_count = png_get_uint_32(profile+128);
2008 png_const_bytep tag = profile+132; /* The first tag */
2010 /* First scan all the tags in the table and add bits to the icc_info value
2011 * (temporarily in 'tags').
2013 for (itag=0; itag < tag_count; ++itag, tag += 12)
2015 png_uint_32 tag_id = png_get_uint_32(tag+0);
2016 png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */
2017 png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */
2019 /* The ICC specification does not exclude zero length tags, therefore the
2020 * start might actually be anywhere if there is no data, but this would be
2021 * a clear abuse of the intent of the standard so the start is checked for
2022 * being in range. All defined tag types have an 8 byte header - a 4 byte
2023 * type signature then 0.
2025 if ((tag_start & 3) != 0)
2027 /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is
2028 * only a warning here because libpng does not care about the
2031 (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
2032 "ICC profile tag start not a multiple of 4");
2035 /* This is a hard error; potentially it can cause read outside the
2038 if (tag_start > profile_length || tag_length > profile_length - tag_start)
2039 return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
2040 "ICC profile tag outside profile");
2043 return 1; /* success, maybe with warnings */
2046 #ifdef PNG_sRGB_SUPPORTED
2047 /* Information about the known ICC sRGB profiles */
2050 png_uint_32 adler, crc, length;
2056 # define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0)
2057 # define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\
2058 { adler, crc, length, md5, broke, intent },
2060 } png_sRGB_checks[] =
2062 /* This data comes from contrib/tools/checksum-icc run on downloads of
2063 * all four ICC sRGB profiles from www.color.org.
2065 /* adler32, crc32, MD5[4], intent, date, length, file-name */
2066 PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,
2067 PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,
2068 "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")
2070 /* ICC sRGB v2 perceptual no black-compensation: */
2071 PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,
2072 PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,
2073 "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")
2075 PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,
2076 PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,
2077 "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")
2079 /* ICC sRGB v4 perceptual */
2080 PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,
2081 PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,
2082 "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")
2084 /* The following profiles have no known MD5 checksum. If there is a match
2085 * on the (empty) MD5 the other fields are used to attempt a match and
2086 * a warning is produced. The first two of these profiles have a 'cprt' tag
2087 * which suggests that they were also made by Hewlett Packard.
2089 PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,
2090 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,
2091 "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")
2093 /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not
2094 * match the D50 PCS illuminant in the header (it is in fact the D65 values,
2095 * so the white point is recorded as the un-adapted value.) The profiles
2096 * below only differ in one byte - the intent - and are basically the same as
2097 * the previous profile except for the mediaWhitePointTag error and a missing
2098 * chromaticAdaptationTag.
2100 PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,
2101 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,
2102 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")
2104 PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,
2105 PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,
2106 "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")
2110 png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
2111 png_const_bytep profile, uLong adler)
2113 /* The quick check is to verify just the MD5 signature and trust the
2114 * rest of the data. Because the profile has already been verified for
2115 * correctness this is safe. png_colorspace_set_sRGB will check the 'intent'
2116 * field too, so if the profile has been edited with an intent not defined
2117 * by sRGB (but maybe defined by a later ICC specification) the read of
2118 * the profile will fail at that point.
2120 png_uint_32 length = 0;
2121 png_uint_32 intent = 0x10000; /* invalid */
2122 #if PNG_sRGB_PROFILE_CHECKS > 1
2123 uLong crc = 0; /* the value for 0 length data */
2127 for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)
2129 if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] &&
2130 png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] &&
2131 png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] &&
2132 png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3])
2134 /* This may be one of the old HP profiles without an MD5, in that
2135 * case we can only use the length and Adler32 (note that these
2136 * are not used by default if there is an MD5!)
2138 # if PNG_sRGB_PROFILE_CHECKS == 0
2139 if (png_sRGB_checks[i].have_md5)
2140 return 1+png_sRGB_checks[i].is_broken;
2143 /* Profile is unsigned or more checks have been configured in. */
2146 length = png_get_uint_32(profile);
2147 intent = png_get_uint_32(profile+64);
2150 /* Length *and* intent must match */
2151 if (length == png_sRGB_checks[i].length &&
2152 intent == png_sRGB_checks[i].intent)
2154 /* Now calculate the adler32 if not done already. */
2157 adler = adler32(0, NULL, 0);
2158 adler = adler32(adler, profile, length);
2161 if (adler == png_sRGB_checks[i].adler)
2163 /* These basic checks suggest that the data has not been
2164 * modified, but if the check level is more than 1 perform
2165 * our own crc32 checksum on the data.
2167 # if PNG_sRGB_PROFILE_CHECKS > 1
2170 crc = crc32(0, NULL, 0);
2171 crc = crc32(crc, profile, length);
2174 /* So this check must pass for the 'return' below to happen.
2176 if (crc == png_sRGB_checks[i].crc)
2179 if (png_sRGB_checks[i].is_broken)
2181 /* These profiles are known to have bad data that may cause
2182 * problems if they are used, therefore attempt to
2183 * discourage their use, skip the 'have_md5' warning below,
2184 * which is made irrelevant by this error.
2186 png_chunk_report(png_ptr, "known incorrect sRGB profile",
2190 /* Warn that this being done; this isn't even an error since
2191 * the profile is perfectly valid, but it would be nice if
2192 * people used the up-to-date ones.
2194 else if (!png_sRGB_checks[i].have_md5)
2196 png_chunk_report(png_ptr,
2197 "out-of-date sRGB profile with no signature",
2201 return 1+png_sRGB_checks[i].is_broken;
2206 # if PNG_sRGB_PROFILE_CHECKS > 0
2207 /* The signature matched, but the profile had been changed in some
2208 * way. This is an apparent violation of the ICC terms of use and,
2209 * anyway, probably indicates a data error or uninformed hacking.
2211 if (png_sRGB_checks[i].have_md5)
2212 png_benign_error(png_ptr,
2213 "copyright violation: edited ICC profile ignored");
2218 return 0; /* no match */
2222 #ifdef PNG_sRGB_SUPPORTED
2224 png_icc_set_sRGB(png_const_structrp png_ptr,
2225 png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
2227 /* Is this profile one of the known ICC sRGB profiles? If it is, just set
2228 * the sRGB information.
2230 if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler))
2231 (void)png_colorspace_set_sRGB(png_ptr, colorspace,
2232 (int)/*already checked*/png_get_uint_32(profile+64));
2234 #endif /* PNG_READ_sRGB_SUPPORTED */
2237 png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
2238 png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
2241 if (colorspace->flags & PNG_COLORSPACE_INVALID)
2244 if (png_icc_check_length(png_ptr, colorspace, name, profile_length) &&
2245 png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
2247 png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
2250 # ifdef PNG_sRGB_SUPPORTED
2251 /* If no sRGB support, don't try storing sRGB information */
2252 png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
2262 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
2264 png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
2266 /* Set the rgb_to_gray coefficients from the colorspace. */
2267 if ((png_ptr->colorspace.flags & PNG_COLORSPACE_RGB_TO_GRAY_SET) == 0 &&
2268 (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
2270 /* png_set_background has not been called, get the coefficients from the Y
2271 * values of the colorspace colorants.
2273 png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
2274 png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
2275 png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
2276 png_fixed_point total = r+g+b;
2279 r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
2280 g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
2281 b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
2284 /* We allow 0 coefficients here. r+g+b may be 32769 if two or
2285 * all of the coefficients were rounded up. Handle this by
2286 * reducing the *largest* coefficient by 1; this matches the
2287 * approach used for the default coefficients in pngrtran.c
2293 else if (r+g+b < 32768)
2298 if (g >= r && g >= b)
2300 else if (r >= g && r >= b)
2306 /* Check for an internal error. */
2309 "internal error handling cHRM coefficients");
2313 png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
2314 png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
2318 /* This is a png_error at present even though it could be ignored -
2319 * it should never happen, but it is important that if it does, the
2323 png_error(png_ptr, "internal error handling cHRM->XYZ");
2328 #endif /* COLORSPACE */
2331 png_check_IHDR(png_const_structrp png_ptr,
2332 png_uint_32 width, png_uint_32 height, int bit_depth,
2333 int color_type, int interlace_type, int compression_type,
2338 /* Check for width and height valid values */
2341 png_warning(png_ptr, "Image width is zero in IHDR");
2347 png_warning(png_ptr, "Image height is zero in IHDR");
2351 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
2352 if (width > png_ptr->user_width_max)
2355 if (width > PNG_USER_WIDTH_MAX)
2358 png_warning(png_ptr, "Image width exceeds user limit in IHDR");
2362 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
2363 if (height > png_ptr->user_height_max)
2365 if (height > PNG_USER_HEIGHT_MAX)
2368 png_warning(png_ptr, "Image height exceeds user limit in IHDR");
2372 if (width > PNG_UINT_31_MAX)
2374 png_warning(png_ptr, "Invalid image width in IHDR");
2378 if (height > PNG_UINT_31_MAX)
2380 png_warning(png_ptr, "Invalid image height in IHDR");
2384 /* Check other values */
2385 if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
2386 bit_depth != 8 && bit_depth != 16)
2388 png_warning(png_ptr, "Invalid bit depth in IHDR");
2392 if (color_type < 0 || color_type == 1 ||
2393 color_type == 5 || color_type > 6)
2395 png_warning(png_ptr, "Invalid color type in IHDR");
2399 if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
2400 ((color_type == PNG_COLOR_TYPE_RGB ||
2401 color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
2402 color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
2404 png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
2408 if (interlace_type >= PNG_INTERLACE_LAST)
2410 png_warning(png_ptr, "Unknown interlace method in IHDR");
2414 if (compression_type != PNG_COMPRESSION_TYPE_BASE)
2416 png_warning(png_ptr, "Unknown compression method in IHDR");
2420 # ifdef PNG_MNG_FEATURES_SUPPORTED
2421 /* Accept filter_method 64 (intrapixel differencing) only if
2422 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
2423 * 2. Libpng did not read a PNG signature (this filter_method is only
2424 * used in PNG datastreams that are embedded in MNG datastreams) and
2425 * 3. The application called png_permit_mng_features with a mask that
2426 * included PNG_FLAG_MNG_FILTER_64 and
2427 * 4. The filter_method is 64 and
2428 * 5. The color_type is RGB or RGBA
2430 if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&
2431 png_ptr->mng_features_permitted)
2432 png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
2434 if (filter_type != PNG_FILTER_TYPE_BASE)
2436 if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
2437 (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
2438 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
2439 (color_type == PNG_COLOR_TYPE_RGB ||
2440 color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
2442 png_warning(png_ptr, "Unknown filter method in IHDR");
2446 if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)
2448 png_warning(png_ptr, "Invalid filter method in IHDR");
2454 if (filter_type != PNG_FILTER_TYPE_BASE)
2456 png_warning(png_ptr, "Unknown filter method in IHDR");
2462 png_error(png_ptr, "Invalid IHDR data");
2465 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
2466 /* ASCII to fp functions */
2467 /* Check an ASCII formated floating point value, see the more detailed
2468 * comments in pngpriv.h
2470 /* The following is used internally to preserve the sticky flags */
2471 #define png_fp_add(state, flags) ((state) |= (flags))
2472 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
2475 png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
2476 png_size_tp whereami)
2478 int state = *statep;
2479 png_size_t i = *whereami;
2484 /* First find the type of the next character */
2487 case 43: type = PNG_FP_SAW_SIGN; break;
2488 case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
2489 case 46: type = PNG_FP_SAW_DOT; break;
2490 case 48: type = PNG_FP_SAW_DIGIT; break;
2491 case 49: case 50: case 51: case 52:
2492 case 53: case 54: case 55: case 56:
2493 case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
2495 case 101: type = PNG_FP_SAW_E; break;
2496 default: goto PNG_FP_End;
2499 /* Now deal with this type according to the current
2500 * state, the type is arranged to not overlap the
2501 * bits of the PNG_FP_STATE.
2503 switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
2505 case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
2506 if (state & PNG_FP_SAW_ANY)
2507 goto PNG_FP_End; /* not a part of the number */
2509 png_fp_add(state, type);
2512 case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
2513 /* Ok as trailer, ok as lead of fraction. */
2514 if (state & PNG_FP_SAW_DOT) /* two dots */
2517 else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */
2518 png_fp_add(state, type);
2521 png_fp_set(state, PNG_FP_FRACTION | type);
2525 case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
2526 if (state & PNG_FP_SAW_DOT) /* delayed fraction */
2527 png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
2529 png_fp_add(state, type | PNG_FP_WAS_VALID);
2533 case PNG_FP_INTEGER + PNG_FP_SAW_E:
2534 if ((state & PNG_FP_SAW_DIGIT) == 0)
2537 png_fp_set(state, PNG_FP_EXPONENT);
2541 /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
2542 goto PNG_FP_End; ** no sign in fraction */
2544 /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
2545 goto PNG_FP_End; ** Because SAW_DOT is always set */
2547 case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
2548 png_fp_add(state, type | PNG_FP_WAS_VALID);
2551 case PNG_FP_FRACTION + PNG_FP_SAW_E:
2552 /* This is correct because the trailing '.' on an
2553 * integer is handled above - so we can only get here
2554 * with the sequence ".E" (with no preceding digits).
2556 if ((state & PNG_FP_SAW_DIGIT) == 0)
2559 png_fp_set(state, PNG_FP_EXPONENT);
2563 case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
2564 if (state & PNG_FP_SAW_ANY)
2565 goto PNG_FP_End; /* not a part of the number */
2567 png_fp_add(state, PNG_FP_SAW_SIGN);
2571 /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
2574 case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
2575 png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
2579 /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
2582 default: goto PNG_FP_End; /* I.e. break 2 */
2585 /* The character seems ok, continue. */
2590 /* Here at the end, update the state and return the correct
2596 return (state & PNG_FP_SAW_DIGIT) != 0;
2600 /* The same but for a complete string. */
2602 png_check_fp_string(png_const_charp string, png_size_t size)
2605 png_size_t char_index=0;
2607 if (png_check_fp_number(string, size, &state, &char_index) &&
2608 (char_index == size || string[char_index] == 0))
2609 return state /* must be non-zero - see above */;
2611 return 0; /* i.e. fail */
2613 #endif /* pCAL or sCAL */
2615 #ifdef PNG_sCAL_SUPPORTED
2616 # ifdef PNG_FLOATING_POINT_SUPPORTED
2617 /* Utility used below - a simple accurate power of ten from an integral
2621 png_pow10(int power)
2626 /* Handle negative exponent with a reciprocal at the end because
2627 * 10 is exact whereas .1 is inexact in base 2
2631 if (power < DBL_MIN_10_EXP) return 0;
2632 recip = 1, power = -power;
2637 /* Decompose power bitwise. */
2641 if (power & 1) d *= mult;
2649 /* else power is 0 and d is 1 */
2654 /* Function to format a floating point value in ASCII with a given
2658 png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
2659 double fp, unsigned int precision)
2661 /* We use standard functions from math.h, but not printf because
2662 * that would require stdio. The caller must supply a buffer of
2663 * sufficient size or we will png_error. The tests on size and
2664 * the space in ascii[] consumed are indicated below.
2667 precision = DBL_DIG;
2669 /* Enforce the limit of the implementation precision too. */
2670 if (precision > DBL_DIG+1)
2671 precision = DBL_DIG+1;
2673 /* Basic sanity checks */
2674 if (size >= precision+5) /* See the requirements below. */
2679 *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */
2683 if (fp >= DBL_MIN && fp <= DBL_MAX)
2685 int exp_b10; /* A base 10 exponent */
2686 double base; /* 10^exp_b10 */
2688 /* First extract a base 10 exponent of the number,
2689 * the calculation below rounds down when converting
2690 * from base 2 to base 10 (multiply by log10(2) -
2691 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
2692 * be increased. Note that the arithmetic shift
2693 * performs a floor() unlike C arithmetic - using a
2694 * C multiply would break the following for negative
2697 (void)frexp(fp, &exp_b10); /* exponent to base 2 */
2699 exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
2701 /* Avoid underflow here. */
2702 base = png_pow10(exp_b10); /* May underflow */
2704 while (base < DBL_MIN || base < fp)
2706 /* And this may overflow. */
2707 double test = png_pow10(exp_b10+1);
2709 if (test <= DBL_MAX)
2710 ++exp_b10, base = test;
2716 /* Normalize fp and correct exp_b10, after this fp is in the
2717 * range [.1,1) and exp_b10 is both the exponent and the digit
2718 * *before* which the decimal point should be inserted
2719 * (starting with 0 for the first digit). Note that this
2720 * works even if 10^exp_b10 is out of range because of the
2721 * test on DBL_MAX above.
2724 while (fp >= 1) fp /= 10, ++exp_b10;
2726 /* Because of the code above fp may, at this point, be
2727 * less than .1, this is ok because the code below can
2728 * handle the leading zeros this generates, so no attempt
2729 * is made to correct that here.
2733 int czero, clead, cdigits;
2736 /* Allow up to two leading zeros - this will not lengthen
2737 * the number compared to using E-n.
2739 if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
2741 czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
2742 exp_b10 = 0; /* Dot added below before first output. */
2745 czero = 0; /* No zeros to add */
2747 /* Generate the digit list, stripping trailing zeros and
2748 * inserting a '.' before a digit if the exponent is 0.
2750 clead = czero; /* Count of leading zeros */
2751 cdigits = 0; /* Count of digits in list. */
2758 /* Use modf here, not floor and subtract, so that
2759 * the separation is done in one step. At the end
2760 * of the loop don't break the number into parts so
2761 * that the final digit is rounded.
2763 if (cdigits+czero-clead+1 < (int)precision)
2772 /* Rounding up to 10, handle that here. */
2776 if (cdigits == 0) --clead;
2780 while (cdigits > 0 && d > 9)
2784 if (exp_b10 != (-1))
2789 ch = *--ascii, ++size;
2790 /* Advance exp_b10 to '1', so that the
2791 * decimal point happens after the
2798 d = ch - 47; /* I.e. 1+(ch-48) */
2801 /* Did we reach the beginning? If so adjust the
2802 * exponent but take into account the leading
2805 if (d > 9) /* cdigits == 0 */
2807 if (exp_b10 == (-1))
2809 /* Leading decimal point (plus zeros?), if
2810 * we lose the decimal point here it must
2811 * be reentered below.
2816 ++size, exp_b10 = 1;
2818 /* Else lost a leading zero, so 'exp_b10' is
2825 /* In all cases we output a '1' */
2830 fp = 0; /* Guarantees termination below. */
2836 if (cdigits == 0) ++clead;
2840 /* Included embedded zeros in the digit count. */
2841 cdigits += czero - clead;
2846 /* exp_b10 == (-1) means we just output the decimal
2847 * place - after the DP don't adjust 'exp_b10' any
2850 if (exp_b10 != (-1))
2852 if (exp_b10 == 0) *ascii++ = 46, --size;
2853 /* PLUS 1: TOTAL 4 */
2856 *ascii++ = 48, --czero;
2859 if (exp_b10 != (-1))
2861 if (exp_b10 == 0) *ascii++ = 46, --size; /* counted
2865 *ascii++ = (char)(48 + (int)d), ++cdigits;
2868 while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);
2870 /* The total output count (max) is now 4+precision */
2872 /* Check for an exponent, if we don't need one we are
2873 * done and just need to terminate the string. At
2874 * this point exp_b10==(-1) is effectively if flag - it got
2875 * to '-1' because of the decrement after outputing
2876 * the decimal point above (the exponent required is
2879 if (exp_b10 >= (-1) && exp_b10 <= 2)
2881 /* The following only happens if we didn't output the
2882 * leading zeros above for negative exponent, so this
2883 * doest add to the digit requirement. Note that the
2884 * two zeros here can only be output if the two leading
2885 * zeros were *not* output, so this doesn't increase
2888 while (--exp_b10 >= 0) *ascii++ = 48;
2892 /* Total buffer requirement (including the '\0') is
2893 * 5+precision - see check at the start.
2898 /* Here if an exponent is required, adjust size for
2899 * the digits we output but did not count. The total
2900 * digit output here so far is at most 1+precision - no
2901 * decimal point and no leading or trailing zeros have
2906 *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */
2908 /* The following use of an unsigned temporary avoids ambiguities in
2909 * the signed arithmetic on exp_b10 and permits GCC at least to do
2910 * better optimization.
2913 unsigned int uexp_b10;
2917 *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
2918 uexp_b10 = -exp_b10;
2926 while (uexp_b10 > 0)
2928 exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
2933 /* Need another size check here for the exponent digits, so
2934 * this need not be considered above.
2936 if ((int)size > cdigits)
2938 while (cdigits > 0) *ascii++ = exponent[--cdigits];
2946 else if (!(fp >= DBL_MIN))
2948 *ascii++ = 48; /* '0' */
2954 *ascii++ = 105; /* 'i' */
2955 *ascii++ = 110; /* 'n' */
2956 *ascii++ = 102; /* 'f' */
2962 /* Here on buffer too small. */
2963 png_error(png_ptr, "ASCII conversion buffer too small");
2966 # endif /* FLOATING_POINT */
2968 # ifdef PNG_FIXED_POINT_SUPPORTED
2969 /* Function to format a fixed point value in ASCII.
2972 png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
2973 png_size_t size, png_fixed_point fp)
2975 /* Require space for 10 decimal digits, a decimal point, a minus sign and a
2976 * trailing \0, 13 characters:
2982 /* Avoid overflow here on the minimum integer. */
2984 *ascii++ = 45, --size, num = -fp;
2988 if (num <= 0x80000000) /* else overflowed */
2990 unsigned int ndigits = 0, first = 16 /* flag value */;
2995 /* Split the low digit off num: */
2996 unsigned int tmp = num/10;
2998 digits[ndigits++] = (char)(48 + num);
2999 /* Record the first non-zero digit, note that this is a number
3000 * starting at 1, it's not actually the array index.
3002 if (first == 16 && num > 0)
3009 while (ndigits > 5) *ascii++ = digits[--ndigits];
3010 /* The remaining digits are fractional digits, ndigits is '5' or
3011 * smaller at this point. It is certainly not zero. Check for a
3012 * non-zero fractional digit:
3017 *ascii++ = 46; /* decimal point */
3018 /* ndigits may be <5 for small numbers, output leading zeros
3019 * then ndigits digits to first:
3022 while (ndigits < i) *ascii++ = 48, --i;
3023 while (ndigits >= first) *ascii++ = digits[--ndigits];
3024 /* Don't output the trailing zeros! */
3030 /* And null terminate the string: */
3036 /* Here on buffer too small. */
3037 png_error(png_ptr, "ASCII conversion buffer too small");
3039 # endif /* FIXED_POINT */
3042 #if !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && (\
3043 defined(PNG_FLOATING_POINT_SUPPORTED) && \
3044 (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
3045 defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
3046 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
3047 (defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) &&\
3048 defined(PNG_sCAL_SUPPORTED)))
3050 png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
3054 if (fp > -21474.836485)
3055 return (png_fixed_point)(100000*fp - .5);
3060 if (fp < 21474.836475)
3061 return (png_fixed_point)(100000*fp + .5);
3065 png_fixed_error(png_ptr, text);
3067 # ifndef PNG_ERROR_TEXT_SUPPORTED
3073 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\
3074 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
3075 /* muldiv functions */
3076 /* This API takes signed arguments and rounds the result to the nearest
3077 * integer (or, for a fixed point number - the standard argument - to
3078 * the nearest .00001). Overflow and divide by zero are signalled in
3079 * the result, a boolean - true on success, false on overflow.
3082 png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
3085 /* Return a * times / divisor, rounded. */
3088 if (a == 0 || times == 0)
3095 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3101 /* A png_fixed_point is a 32-bit integer. */
3102 if (r <= 2147483647. && r >= -2147483648.)
3104 *res = (png_fixed_point)r;
3109 png_uint_32 A, T, D;
3110 png_uint_32 s16, s32, s00;
3113 negative = 1, A = -a;
3118 negative = !negative, T = -times;
3123 negative = !negative, D = -divisor;
3127 /* Following can't overflow because the arguments only
3128 * have 31 bits each, however the result may be 32 bits.
3130 s16 = (A >> 16) * (T & 0xffff) +
3131 (A & 0xffff) * (T >> 16);
3132 /* Can't overflow because the a*times bit is only 30
3135 s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
3136 s00 = (A & 0xffff) * (T & 0xffff);
3138 s16 = (s16 & 0xffff) << 16;
3144 if (s32 < D) /* else overflow */
3146 /* s32.s00 is now the 64-bit product, do a standard
3147 * division, we know that s32 < D, so the maximum
3148 * required shift is 31.
3151 png_fixed_point result = 0; /* NOTE: signed */
3153 while (--bitshift >= 0)
3155 png_uint_32 d32, d00;
3158 d32 = D >> (32-bitshift), d00 = D << bitshift;
3165 if (s00 < d00) --s32; /* carry */
3166 s32 -= d32, s00 -= d00, result += 1<<bitshift;
3170 if (s32 == d32 && s00 >= d00)
3171 s32 = 0, s00 -= d00, result += 1<<bitshift;
3174 /* Handle the rounding. */
3175 if (s00 >= (D >> 1))
3181 /* Check for overflow. */
3182 if ((negative && result <= 0) || (!negative && result >= 0))
3194 #endif /* READ_GAMMA || INCH_CONVERSIONS */
3196 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
3197 /* The following is for when the caller doesn't much care about the
3201 png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
3204 png_fixed_point result;
3206 if (png_muldiv(&result, a, times, divisor))
3209 png_warning(png_ptr, "fixed point overflow ignored");
3214 #ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */
3215 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
3217 png_reciprocal(png_fixed_point a)
3219 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3220 double r = floor(1E10/a+.5);
3222 if (r <= 2147483647. && r >= -2147483648.)
3223 return (png_fixed_point)r;
3225 png_fixed_point res;
3227 if (png_muldiv(&res, 100000, 100000, a))
3231 return 0; /* error/overflow */
3234 /* This is the shared test on whether a gamma value is 'significant' - whether
3235 * it is worth doing gamma correction.
3238 png_gamma_significant(png_fixed_point gamma_val)
3240 return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
3241 gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
3245 #ifdef PNG_READ_GAMMA_SUPPORTED
3246 /* A local convenience routine. */
3247 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
3248 static png_fixed_point
3249 png_product2(png_fixed_point a, png_fixed_point b)
3251 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3252 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3253 double r = a * 1E-5;
3257 if (r <= 2147483647. && r >= -2147483648.)
3258 return (png_fixed_point)r;
3260 png_fixed_point res;
3262 if (png_muldiv(&res, a, b, 100000))
3266 return 0; /* overflow */
3270 /* The inverse of the above. */
3272 png_reciprocal2(png_fixed_point a, png_fixed_point b)
3274 /* The required result is 1/a * 1/b; the following preserves accuracy. */
3275 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3280 if (r <= 2147483647. && r >= -2147483648.)
3281 return (png_fixed_point)r;
3283 /* This may overflow because the range of png_fixed_point isn't symmetric,
3284 * but this API is only used for the product of file and screen gamma so it
3285 * doesn't matter that the smallest number it can produce is 1/21474, not
3288 png_fixed_point res = png_product2(a, b);
3291 return png_reciprocal(res);
3294 return 0; /* overflow */
3296 #endif /* READ_GAMMA */
3298 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
3299 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
3300 /* Fixed point gamma.
3302 * The code to calculate the tables used below can be found in the shell script
3303 * contrib/tools/intgamma.sh
3305 * To calculate gamma this code implements fast log() and exp() calls using only
3306 * fixed point arithmetic. This code has sufficient precision for either 8-bit
3307 * or 16-bit sample values.
3309 * The tables used here were calculated using simple 'bc' programs, but C double
3310 * precision floating point arithmetic would work fine.
3313 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
3314 * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
3315 * mantissa. The numbers are 32-bit fractions.
3317 static const png_uint_32
3320 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
3321 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
3322 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
3323 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
3324 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
3325 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
3326 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
3327 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
3328 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
3329 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
3330 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
3331 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
3332 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
3333 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
3334 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
3335 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
3336 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
3337 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
3338 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
3339 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
3340 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
3344 /* The following are the values for 16-bit tables - these work fine for the
3345 * 8-bit conversions but produce very slightly larger errors in the 16-bit
3346 * log (about 1.2 as opposed to 0.7 absolute error in the final value). To
3347 * use these all the shifts below must be adjusted appropriately.
3349 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
3350 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
3351 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
3352 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
3353 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
3354 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
3355 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
3356 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
3357 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
3358 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
3359 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
3365 png_log8bit(unsigned int x)
3367 unsigned int lg2 = 0;
3368 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
3369 * because the log is actually negate that means adding 1. The final
3370 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
3371 * input), return -1 for the overflow (log 0) case, - so the result is
3372 * always at most 19 bits.
3374 if ((x &= 0xff) == 0)
3377 if ((x & 0xf0) == 0)
3380 if ((x & 0xc0) == 0)
3383 if ((x & 0x80) == 0)
3386 /* result is at most 19 bits, so this cast is safe: */
3387 return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
3390 /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
3391 * for 16-bit images we use the most significant 8 bits of the 16-bit value to
3392 * get an approximation then multiply the approximation by a correction factor
3393 * determined by the remaining up to 8 bits. This requires an additional step
3394 * in the 16-bit case.
3396 * We want log2(value/65535), we have log2(v'/255), where:
3398 * value = v' * 256 + v''
3401 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
3402 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
3403 * than 258. The final factor also needs to correct for the fact that our 8-bit
3404 * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
3406 * This gives a final formula using a calculated value 'x' which is value/v' and
3407 * scaling by 65536 to match the above table:
3409 * log2(x/257) * 65536
3411 * Since these numbers are so close to '1' we can use simple linear
3412 * interpolation between the two end values 256/257 (result -368.61) and 258/257
3413 * (result 367.179). The values used below are scaled by a further 64 to give
3414 * 16-bit precision in the interpolation:
3416 * Start (256): -23591
3421 png_log16bit(png_uint_32 x)
3423 unsigned int lg2 = 0;
3425 /* As above, but now the input has 16 bits. */
3426 if ((x &= 0xffff) == 0)
3429 if ((x & 0xff00) == 0)
3432 if ((x & 0xf000) == 0)
3435 if ((x & 0xc000) == 0)
3438 if ((x & 0x8000) == 0)
3441 /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
3445 lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
3447 /* Now we need to interpolate the factor, this requires a division by the top
3448 * 8 bits. Do this with maximum precision.
3450 x = ((x << 16) + (x >> 9)) / (x >> 8);
3452 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
3453 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
3454 * 16 bits to interpolate to get the low bits of the result. Round the
3455 * answer. Note that the end point values are scaled by 64 to retain overall
3456 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
3457 * the overall scaling by 6-12. Round at every step.
3461 if (x <= 65536U) /* <= '257' */
3462 lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
3465 lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
3467 /* Safe, because the result can't have more than 20 bits: */
3468 return (png_int_32)((lg2 + 2048) >> 12);
3471 /* The 'exp()' case must invert the above, taking a 20-bit fixed point
3472 * logarithmic value and returning a 16 or 8-bit number as appropriate. In
3473 * each case only the low 16 bits are relevant - the fraction - since the
3474 * integer bits (the top 4) simply determine a shift.
3476 * The worst case is the 16-bit distinction between 65535 and 65534, this
3477 * requires perhaps spurious accuracty in the decoding of the logarithm to
3478 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
3479 * of getting this accuracy in practice.
3481 * To deal with this the following exp() function works out the exponent of the
3482 * frational part of the logarithm by using an accurate 32-bit value from the
3483 * top four fractional bits then multiplying in the remaining bits.
3485 static const png_uint_32
3488 /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
3489 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
3490 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
3491 2553802834U, 2445529972U, 2341847524U, 2242560872U
3494 /* Adjustment table; provided to explain the numbers in the code below. */
3496 for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
3497 11 44937.64284865548751208448
3498 10 45180.98734845585101160448
3499 9 45303.31936980687359311872
3500 8 45364.65110595323018870784
3501 7 45395.35850361789624614912
3502 6 45410.72259715102037508096
3503 5 45418.40724413220722311168
3504 4 45422.25021786898173001728
3505 3 45424.17186732298419044352
3506 2 45425.13273269940811464704
3507 1 45425.61317555035558641664
3508 0 45425.85339951654943850496
3512 png_exp(png_fixed_point x)
3514 if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
3516 /* Obtain a 4-bit approximation */
3517 png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf];
3519 /* Incorporate the low 12 bits - these decrease the returned value by
3520 * multiplying by a number less than 1 if the bit is set. The multiplier
3521 * is determined by the above table and the shift. Notice that the values
3522 * converge on 45426 and this is used to allow linear interpolation of the
3526 e -= (((e >> 16) * 44938U) + 16U) >> 5;
3529 e -= (((e >> 16) * 45181U) + 32U) >> 6;
3532 e -= (((e >> 16) * 45303U) + 64U) >> 7;
3535 e -= (((e >> 16) * 45365U) + 128U) >> 8;
3538 e -= (((e >> 16) * 45395U) + 256U) >> 9;
3541 e -= (((e >> 16) * 45410U) + 512U) >> 10;
3543 /* And handle the low 6 bits in a single block. */
3544 e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
3546 /* Handle the upper bits of x. */
3551 /* Check for overflow */
3553 return png_32bit_exp[0];
3555 /* Else underflow */
3560 png_exp8bit(png_fixed_point lg2)
3562 /* Get a 32-bit value: */
3563 png_uint_32 x = png_exp(lg2);
3565 /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the
3566 * second, rounding, step can't overflow because of the first, subtraction,
3570 return (png_byte)((x + 0x7fffffU) >> 24);
3574 png_exp16bit(png_fixed_point lg2)
3576 /* Get a 32-bit value: */
3577 png_uint_32 x = png_exp(lg2);
3579 /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
3581 return (png_uint_16)((x + 32767U) >> 16);
3583 #endif /* FLOATING_ARITHMETIC */
3586 png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
3588 if (value > 0 && value < 255)
3590 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3591 double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
3594 png_int_32 lg2 = png_log8bit(value);
3595 png_fixed_point res;
3597 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
3598 return png_exp8bit(res);
3605 return (png_byte)value;
3609 png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
3611 if (value > 0 && value < 65535)
3613 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
3614 double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
3615 return (png_uint_16)r;
3617 png_int_32 lg2 = png_log16bit(value);
3618 png_fixed_point res;
3620 if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
3621 return png_exp16bit(res);
3628 return (png_uint_16)value;
3631 /* This does the right thing based on the bit_depth field of the
3632 * png_struct, interpreting values as 8-bit or 16-bit. While the result
3633 * is nominally a 16-bit value if bit depth is 8 then the result is
3634 * 8-bit (as are the arguments.)
3636 png_uint_16 /* PRIVATE */
3637 png_gamma_correct(png_structrp png_ptr, unsigned int value,
3638 png_fixed_point gamma_val)
3640 if (png_ptr->bit_depth == 8)
3641 return png_gamma_8bit_correct(value, gamma_val);
3644 return png_gamma_16bit_correct(value, gamma_val);
3647 #define PNG_GAMMA_TABLE_8 0 /* 8-bit entries in png_byte */
3648 #define PNG_GAMMA_TABLE_8_IN_16 1 /* 8-bit entries * 257 in png_uint_16 */
3649 #define PNG_GAMMA_TABLE_16 2 /* 16-bit entries in png_uint_16 */
3653 png_fixed_point gamma;
3656 unsigned int shift; /* input value is (i * mult + add) >> shift */
3657 int output; /* One of the above values */
3658 int adjust; /* Divide or multiple output by 257 */
3659 png_voidp table; /* Lookup table */
3663 write_gamma_table_entry(const gamma_table_data *data, png_uint_32 i)
3664 /* Calculate and write a single entry into table[i], the value of the entry
3665 * written is returned.
3668 png_uint_32 in = (i * data->mult + data->add) >> data->shift;
3671 /* If the output is TABLE_8 with no adjust, or the output is not with an
3672 * adjust, use 8-bit correction.
3674 if ((data->output == PNG_GAMMA_TABLE_8) != (data->adjust != 0))
3676 out = png_gamma_8bit_correct((unsigned int)in, data->gamma);
3678 if (data->adjust != 0)
3682 else /* 16-bit correction */
3684 out = png_gamma_16bit_correct((unsigned int)in, data->gamma);
3686 if (data->adjust != 0)
3687 out = PNG_DIV257(out);
3690 if (data->output == PNG_GAMMA_TABLE_8)
3691 ((png_bytep)data->table)[i] = (png_byte)out;
3694 ((png_uint_16p)data->table)[i] = (png_uint_16)out;
3700 write_gamma_table(const gamma_table_data *data, png_uint_32 lo,
3701 unsigned int loval, png_uint_32 hi, unsigned int hival)
3702 /* Fill in gamma table entries between lo and hi, exclusive. The entries at
3703 * table[lo] and table[hi] have already been written, the intervening entries
3707 if (hi > lo+1) /* Else nothing to fill in */
3711 /* All intervening entries must be the same. */
3712 if (data->output == PNG_GAMMA_TABLE_8)
3714 png_bytep table8 = ((png_bytep)data->table);
3717 table8[lo] = (png_byte)loval;
3722 png_uint_16p table16 = ((png_uint_16p)data->table);
3725 table16[lo] = (png_uint_16)loval;
3731 png_uint_32 mid = (lo+hi) >> 1;
3732 unsigned int midval = write_gamma_table_entry(data, mid);
3734 /* The algorithm used is to divide the entries to be written in half
3735 * and fill in the middle. For all practical tables with significant
3736 * gamma this will result in a performance gain because the expensive
3737 * gamma correction arithmetic is avoided for some entries.
3739 write_gamma_table(data, lo, loval, mid, midval);
3740 write_gamma_table(data, mid, midval, hi, hival);
3746 png_build_gamma_table(png_structrp png_ptr, png_fixed_point gamma_val,
3747 int output/*as above*/, int input_depth, int use_shift)
3748 /* Build a gamma lookup table to encode input_depth bit input values.
3749 * The table will have 2^input_depth entries plus an extra one if use_shift
3750 * is specified. With shift the table is accessed:
3752 * table[(original-value + rounding) >> shift]
3754 * And an extra entry exists to accomodate overflow of original-value on
3755 * rounding. If use_shift is not specified the table is accessed with an
3756 * input_depth bit value and the original values must have been correctly
3757 * scaled to this range (not using a shift!)
3759 * Each table entry contains input-value^gamma_val rounded to the output
3760 * precision. This is 8 bit precision unless output is specified as
3761 * PNG_GAMMA_TABLE_16, in which case it is 16-bit precision. For
3762 * PNG_GAMMA_TABLE_8_IN_16 the 8-bit value is scaled to 16-bits by
3763 * multiplying by 257.
3768 gamma_table_data data;
3770 /* If use_shift is true or if the input or output is not 8-bit the gamma
3771 * correction will use the 16-bit correction code. This requires a value in
3772 * the range 0..65535. For use_shift the value is simply:
3776 * For the scaling case the value is:
3778 * round(input * 65535 / ((1<<input_depth)-1)
3780 * Both these expressions can be rewritten as:
3782 * (input * mult + add) >> shift;
3784 * With 'mult' and 'add' chosen to minimize the error for all input values
3785 * in the range 0..((1<<input_depth)-1). The following table does this for
3786 * the scaling case. In fact all the answers are except except for the
3787 * 13-bit case, where the maximum error (from the exact value) is 0.500183.
3789 * This table can be produced using the code in contrib/tools/scale.c
3796 } multadd65535[16] =
3798 { 65535, 0, 0 }, /* 65535/1 */
3799 { 21845, 0, 0 }, /* 65535/3 */
3800 { 37449, 0, 2 }, /* 65535/7 */
3801 { 4369, 0, 0 }, /* 65535/15 */
3802 { 33825, 0, 4 }, /* 65535/31 */
3803 { 266301, 121, 8 }, /* 65535/63 */
3804 { 1056817, 970, 11 }, /* 65535/127 */
3805 { 257, 0, 0 }, /* 65535/255 */
3806 { 262653, 1020, 11 }, /* 65535/511 */
3807 { 1049585, 8165, 14 }, /* 65535/1023 */
3808 { 2098145, 31774, 16 }, /* 65535/2047 */
3809 { 65551, 2055, 12 }, /* 65535/4095 */
3810 { 65543, 4100, 13 }, /* 65535/8191 ERROR: .5+0.000183128*/
3811 { 65539, 8193, 14 }, /* 65535/16383 */
3812 { 32769, 0, 14 }, /* 65535/32767 */
3813 { 1, 0, 0 } /* 65535/65535 */
3814 # if 0 /* inverse */
3815 { 1, 0, 15 }, /* 1/65535 */
3816 { 3, 32769, 16 }, /* 3/65535 */
3817 { 28673, 134188470, 28 }, /* 7/65535 */
3818 { 15, 32775, 16 }, /* 15/65535 */
3819 { 31745, 33522654, 26 }, /* 31/65535 */
3820 { 64513, 33552693, 26 }, /* 63/65535 */
3821 { 65025, 16776620, 25 }, /* 127/65535 */
3822 { 255, 32895, 16 }, /* 255/65535 */
3823 { 65409, 4194134, 23 }, /* 511/65535 */
3824 { 65473, 2097037, 22 }, /* 1023/65535 */
3825 { 65505, 1048544, 21 }, /* 2047/65535 */
3826 { 65521, 524167, 20 }, /* 4095/65535 */
3827 { 65529, 262136, 19 }, /* 8191/65535 */
3828 { 65533, 131065, 18 }, /* 16383/65535 */
3829 { 1, 0, 1 }, /* 32767/65535 */
3830 { 1, 0, 0 } /* 65535/65535 */
3834 /* When both the input and output are 8-bit (i.e. the output is not
3835 * PNG_GAMMA_TABLE_16 and the input_depth is <9) the 8-bit gamma correction
3836 * code can be used, it is slightly faster. This requires values scaled to
3846 { 255, 0, 0 }, /* 255/1 */
3847 { 85, 0, 0 }, /* 255/3 */
3848 { 73, 0, 1 }, /* 255/7 */
3849 { 17, 0, 0 }, /* 255/15 */
3850 { 527, 23, 6 }, /* 255/31 */
3851 { 259, 33, 6 }, /* 255/63 */
3852 { 129, 0, 6 }, /* 255/127 */
3853 { 1, 0, 0 } /* 255/255 */
3854 # if 0 /* inverse */
3855 { 1, 0, 7 }, /* 1/255 */
3856 { 3, 129, 8 }, /* 3/255 */
3857 { 225, 4060, 13 }, /* 7/255 */
3858 { 15, 135, 8 }, /* 15/255 */
3859 { 249, 1014, 11 }, /* 31/255 */
3860 { 253, 505, 10 }, /* 63/255 */
3861 { 1, 0, 1 }, /* 127/255 */
3862 { 1, 0, 0 } /* 255/255 */
3866 /* Basic table size, increased by one below in the use_shift case where the
3869 size = 1U << input_depth;
3870 data.gamma = gamma_val;
3871 data.output = output;
3873 if (output < PNG_GAMMA_TABLE_16 && input_depth <= 8)
3875 /* The 8-bit correction can only be used if both input and output have no
3876 * more than 8 bits of precision.
3878 data.adjust = output > PNG_GAMMA_TABLE_8;
3882 /* The multiplier does the shift: */
3883 data.mult = 1U << (8-input_depth);
3886 if (input_depth < 8) ++size;
3891 data.mult = multadd255[input_depth-1].mult;
3892 data.add = multadd255[input_depth-1].add;
3893 data.shift = multadd255[input_depth-1].shift;
3899 /* 16-bit correction is used for cases where input or output require more
3902 data.adjust = output == PNG_GAMMA_TABLE_8;
3906 data.mult = 1U << (16-input_depth);
3909 if (input_depth < 16) ++size;
3914 data.mult = multadd65535[input_depth-1].mult;
3915 data.add = multadd65535[input_depth-1].add;
3916 data.shift = multadd65535[input_depth-1].shift;
3920 if (output == PNG_GAMMA_TABLE_8)
3922 data.table = png_malloc(png_ptr, size * sizeof (png_byte));
3923 ((png_bytep)data.table)[0] = 0;
3924 hival = ((png_bytep)data.table)[size-1] = 255;
3929 /* Output is 16 bits, although it may only have 8 bits of precision */
3930 data.table = png_malloc(png_ptr, size * sizeof (png_uint_16));
3931 ((png_uint_16p)data.table)[0] = 0;
3932 hival = ((png_uint_16p)data.table)[size-1] = 65535;
3935 if (png_gamma_significant(gamma_val))
3936 write_gamma_table(&data, 0, 0, size-1, hival);
3938 else /* gamma_val not significant */
3940 if (output == PNG_GAMMA_TABLE_8)
3943 png_bytep table8 = ((png_bytep)data.table);
3946 for (i=1; i<size-1; ++i)
3947 table8[i] = (png_byte)PNG_DIV257((i * data.mult + data.add) >>
3951 for (i=1; i<size-1; ++i)
3952 table8[i] = (png_byte)((i * data.mult + data.add) >> data.shift);
3958 png_uint_16p table16 = ((png_uint_16p)data.table);
3961 for (i=1; i<size-1; ++i)
3962 table16[i] = (png_uint_16)(((i * data.mult + data.add) >>
3963 data.shift) * 257U);
3966 for (i=1; i<size-1; ++i)
3967 table16[i] = (png_uint_16)((i * data.mult + data.add) >>
3975 /* Used from png_read_destroy and below to release the memory used by the gamma
3979 png_destroy_gamma_table(png_structrp png_ptr)
3981 png_free(png_ptr, png_ptr->gamma_table);
3982 png_ptr->gamma_table = NULL;
3984 png_free(png_ptr, png_ptr->gamma_16_table);
3985 png_ptr->gamma_16_table = NULL;
3987 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
3988 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
3989 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
3990 png_free(png_ptr, png_ptr->gamma_from_1);
3991 png_ptr->gamma_from_1 = NULL;
3992 png_free(png_ptr, png_ptr->gamma_to_1);
3993 png_ptr->gamma_to_1 = NULL;
3995 png_free(png_ptr, png_ptr->gamma_16_from_1);
3996 png_ptr->gamma_16_from_1 = NULL;
3997 png_free(png_ptr, png_ptr->gamma_16_to_1);
3998 png_ptr->gamma_16_to_1 = NULL;
3999 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4002 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
4003 * tables, we don't make a full table if we are reducing to 8-bit in
4004 * the future. Note also how the gamma_16 tables are segmented so that
4005 * we don't need to allocate > 64K chunks for a full 16-bit table.
4008 png_build_gamma_tables(png_structrp png_ptr, int bit_depth)
4010 png_debug(1, "in png_build_gamma_table");
4012 /* Remove any existing table; this copes with multiple calls to
4013 * png_read_update_info. The warning is because building the gamma tables
4014 * multiple times is a performance hit - it's harmless but the ability to call
4015 * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
4016 * to warn if the app introduces such a hit.
4018 if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
4020 png_warning(png_ptr, "gamma table being rebuilt");
4021 png_destroy_gamma_table(png_ptr);
4026 png_ptr->gamma_table = png_voidcast(png_bytep, png_build_gamma_table(
4027 png_ptr, png_ptr->screen_gamma > 0 ?
4028 png_reciprocal2(png_ptr->colorspace.gamma, png_ptr->screen_gamma) :
4029 PNG_FP_1, PNG_GAMMA_TABLE_8, 8/*input depth*/, 0/*scale*/));
4031 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4032 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4033 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4034 if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
4036 /* This sets the accuracy of 8-bit composition and the 8-bit RGB to gray
4037 * conversion - PNG_MAX_GAMMA_8 (the number of bits in the sixteen bit
4038 * value that are considered significant.)
4040 png_ptr->gamma_to_1 = png_voidcast(png_uint_16p, png_build_gamma_table(
4041 png_ptr, png_reciprocal(png_ptr->colorspace.gamma),
4042 PNG_GAMMA_TABLE_16, 8/*input depth*/, 0/*scale*/));
4044 png_ptr->gamma_from_1 = png_voidcast(png_bytep, png_build_gamma_table(
4045 png_ptr, png_ptr->screen_gamma > 0 ?
4046 png_reciprocal(png_ptr->screen_gamma) :
4047 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */,
4048 PNG_GAMMA_TABLE_8, PNG_MAX_GAMMA_8/*input depth*/, 1/*shift*/));
4050 png_ptr->gamma_shift = 16-PNG_MAX_GAMMA_8;
4052 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4056 png_byte shift, sig_bit;
4059 # ifdef PNG_16BIT_SUPPORTED
4060 table_type = PNG_GAMMA_TABLE_16;
4062 table_type = PNG_GAMMA_TABLE_8_IN_16;
4065 if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
4067 sig_bit = png_ptr->sig_bit.red;
4069 if (png_ptr->sig_bit.green > sig_bit)
4070 sig_bit = png_ptr->sig_bit.green;
4072 if (png_ptr->sig_bit.blue > sig_bit)
4073 sig_bit = png_ptr->sig_bit.blue;
4076 sig_bit = png_ptr->sig_bit.gray;
4078 if (sig_bit > 0 && sig_bit < 16U)
4079 shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */
4082 shift = 0; /* keep all 16 bits */
4084 if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))
4086 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
4087 * the significant bits in the *input* when the output will
4088 * eventually be 8 bits.
4090 if (shift < (16U - PNG_MAX_GAMMA_8))
4091 shift = (16U - PNG_MAX_GAMMA_8);
4093 table_type = PNG_GAMMA_TABLE_8_IN_16;
4096 png_ptr->gamma_shift = shift;
4098 png_ptr->gamma_16_table = png_voidcast(png_uint_16p, png_build_gamma_table(
4099 png_ptr, png_ptr->screen_gamma > 0 ? png_reciprocal2(
4100 png_ptr->colorspace.gamma, png_ptr->screen_gamma) : PNG_FP_1,
4101 table_type, (16-shift)/*input depth*/, 1/*shift*/));
4103 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
4104 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
4105 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
4106 if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))
4108 png_ptr->gamma_16_to_1 = png_voidcast(png_uint_16p,
4109 png_build_gamma_table(png_ptr,
4110 png_reciprocal(png_ptr->colorspace.gamma), PNG_GAMMA_TABLE_16,
4111 (16-shift)/*input depth*/, 1/*shift*/));
4113 /* Notice that the '16 from 1' table should be full precision, however
4114 * the lookup on this table still uses gamma_shift, so it can't be.
4117 png_ptr->gamma_16_from_1 = png_voidcast(png_uint_16p,
4118 png_build_gamma_table(png_ptr, png_ptr->screen_gamma > 0 ?
4119 png_reciprocal(png_ptr->screen_gamma) :
4120 png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */,
4121 PNG_GAMMA_TABLE_16, (16-shift)/*input depth*/, 1/*shift*/));
4123 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
4126 #endif /* READ_GAMMA */
4128 /* HARDWARE OPTION SUPPORT */
4129 #ifdef PNG_SET_OPTION_SUPPORTED
4131 png_set_option(png_structrp png_ptr, int option, int onoff)
4133 if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
4136 int mask = 3 << option;
4137 int setting = (2 + (onoff != 0)) << option;
4138 int current = png_ptr->options;
4140 png_ptr->options = (png_byte)((current & ~mask) | setting);
4142 return (current & mask) >> option;
4145 return PNG_OPTION_INVALID;
4150 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4151 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4152 /* sRGB conversion tables; these are machine generated with the code in
4153 * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the
4154 * specification (see the article at http://en.wikipedia.org/wiki/SRGB)
4155 * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.
4156 * The sRGB to linear table is exact (to the nearest 16 bit linear fraction).
4157 * The inverse (linear to sRGB) table has accuracies as follows:
4159 * For all possible (255*65535+1) input values:
4161 * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact
4163 * For the input values corresponding to the 65536 16-bit values:
4165 * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact
4167 * In all cases the inexact readings are off by one.
4170 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4171 /* The convert-to-sRGB table is only currently required for read. */
4172 const png_uint_16 png_sRGB_table[256] =
4174 0,20,40,60,80,99,119,139,
4175 159,179,199,219,241,264,288,313,
4176 340,367,396,427,458,491,526,562,
4177 599,637,677,718,761,805,851,898,
4178 947,997,1048,1101,1156,1212,1270,1330,
4179 1391,1453,1517,1583,1651,1720,1790,1863,
4180 1937,2013,2090,2170,2250,2333,2418,2504,
4181 2592,2681,2773,2866,2961,3058,3157,3258,
4182 3360,3464,3570,3678,3788,3900,4014,4129,
4183 4247,4366,4488,4611,4736,4864,4993,5124,
4184 5257,5392,5530,5669,5810,5953,6099,6246,
4185 6395,6547,6700,6856,7014,7174,7335,7500,
4186 7666,7834,8004,8177,8352,8528,8708,8889,
4187 9072,9258,9445,9635,9828,10022,10219,10417,
4188 10619,10822,11028,11235,11446,11658,11873,12090,
4189 12309,12530,12754,12980,13209,13440,13673,13909,
4190 14146,14387,14629,14874,15122,15371,15623,15878,
4191 16135,16394,16656,16920,17187,17456,17727,18001,
4192 18277,18556,18837,19121,19407,19696,19987,20281,
4193 20577,20876,21177,21481,21787,22096,22407,22721,
4194 23038,23357,23678,24002,24329,24658,24990,25325,
4195 25662,26001,26344,26688,27036,27386,27739,28094,
4196 28452,28813,29176,29542,29911,30282,30656,31033,
4197 31412,31794,32179,32567,32957,33350,33745,34143,
4198 34544,34948,35355,35764,36176,36591,37008,37429,
4199 37852,38278,38706,39138,39572,40009,40449,40891,
4200 41337,41785,42236,42690,43147,43606,44069,44534,
4201 45002,45473,45947,46423,46903,47385,47871,48359,
4202 48850,49344,49841,50341,50844,51349,51858,52369,
4203 52884,53401,53921,54445,54971,55500,56032,56567,
4204 57105,57646,58190,58737,59287,59840,60396,60955,
4205 61517,62082,62650,63221,63795,64372,64952,65535
4208 #endif /* simplified read only */
4210 /* The base/delta tables are required for both read and write (but currently
4211 * only the simplified versions.)
4213 const png_uint_16 png_sRGB_base[512] =
4215 128,1782,3383,4644,5675,6564,7357,8074,
4216 8732,9346,9921,10463,10977,11466,11935,12384,
4217 12816,13233,13634,14024,14402,14769,15125,15473,
4218 15812,16142,16466,16781,17090,17393,17690,17981,
4219 18266,18546,18822,19093,19359,19621,19879,20133,
4220 20383,20630,20873,21113,21349,21583,21813,22041,
4221 22265,22487,22707,22923,23138,23350,23559,23767,
4222 23972,24175,24376,24575,24772,24967,25160,25352,
4223 25542,25730,25916,26101,26284,26465,26645,26823,
4224 27000,27176,27350,27523,27695,27865,28034,28201,
4225 28368,28533,28697,28860,29021,29182,29341,29500,
4226 29657,29813,29969,30123,30276,30429,30580,30730,
4227 30880,31028,31176,31323,31469,31614,31758,31902,
4228 32045,32186,32327,32468,32607,32746,32884,33021,
4229 33158,33294,33429,33564,33697,33831,33963,34095,
4230 34226,34357,34486,34616,34744,34873,35000,35127,
4231 35253,35379,35504,35629,35753,35876,35999,36122,
4232 36244,36365,36486,36606,36726,36845,36964,37083,
4233 37201,37318,37435,37551,37668,37783,37898,38013,
4234 38127,38241,38354,38467,38580,38692,38803,38915,
4235 39026,39136,39246,39356,39465,39574,39682,39790,
4236 39898,40005,40112,40219,40325,40431,40537,40642,
4237 40747,40851,40955,41059,41163,41266,41369,41471,
4238 41573,41675,41777,41878,41979,42079,42179,42279,
4239 42379,42478,42577,42676,42775,42873,42971,43068,
4240 43165,43262,43359,43456,43552,43648,43743,43839,
4241 43934,44028,44123,44217,44311,44405,44499,44592,
4242 44685,44778,44870,44962,45054,45146,45238,45329,
4243 45420,45511,45601,45692,45782,45872,45961,46051,
4244 46140,46229,46318,46406,46494,46583,46670,46758,
4245 46846,46933,47020,47107,47193,47280,47366,47452,
4246 47538,47623,47709,47794,47879,47964,48048,48133,
4247 48217,48301,48385,48468,48552,48635,48718,48801,
4248 48884,48966,49048,49131,49213,49294,49376,49458,
4249 49539,49620,49701,49782,49862,49943,50023,50103,
4250 50183,50263,50342,50422,50501,50580,50659,50738,
4251 50816,50895,50973,51051,51129,51207,51285,51362,
4252 51439,51517,51594,51671,51747,51824,51900,51977,
4253 52053,52129,52205,52280,52356,52432,52507,52582,
4254 52657,52732,52807,52881,52956,53030,53104,53178,
4255 53252,53326,53400,53473,53546,53620,53693,53766,
4256 53839,53911,53984,54056,54129,54201,54273,54345,
4257 54417,54489,54560,54632,54703,54774,54845,54916,
4258 54987,55058,55129,55199,55269,55340,55410,55480,
4259 55550,55620,55689,55759,55828,55898,55967,56036,
4260 56105,56174,56243,56311,56380,56448,56517,56585,
4261 56653,56721,56789,56857,56924,56992,57059,57127,
4262 57194,57261,57328,57395,57462,57529,57595,57662,
4263 57728,57795,57861,57927,57993,58059,58125,58191,
4264 58256,58322,58387,58453,58518,58583,58648,58713,
4265 58778,58843,58908,58972,59037,59101,59165,59230,
4266 59294,59358,59422,59486,59549,59613,59677,59740,
4267 59804,59867,59930,59993,60056,60119,60182,60245,
4268 60308,60370,60433,60495,60558,60620,60682,60744,
4269 60806,60868,60930,60992,61054,61115,61177,61238,
4270 61300,61361,61422,61483,61544,61605,61666,61727,
4271 61788,61848,61909,61969,62030,62090,62150,62211,
4272 62271,62331,62391,62450,62510,62570,62630,62689,
4273 62749,62808,62867,62927,62986,63045,63104,63163,
4274 63222,63281,63340,63398,63457,63515,63574,63632,
4275 63691,63749,63807,63865,63923,63981,64039,64097,
4276 64155,64212,64270,64328,64385,64443,64500,64557,
4277 64614,64672,64729,64786,64843,64900,64956,65013,
4278 65070,65126,65183,65239,65296,65352,65409,65465
4281 const png_byte png_sRGB_delta[512] =
4283 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,
4284 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,
4285 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,
4286 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,
4287 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,
4288 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,
4289 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,
4290 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
4291 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,
4292 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,
4293 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,
4294 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,
4295 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
4296 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,
4297 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4298 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
4299 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4300 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4301 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
4302 10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4303 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4304 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4305 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
4306 9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4307 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4308 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4309 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4310 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
4311 8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,
4312 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
4313 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
4314 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
4316 #endif /* SIMPLIFIED READ/WRITE sRGB support */
4318 /* SIMPLIFIED READ/WRITE SUPPORT */
4319 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
4320 defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
4322 png_image_free_function(png_voidp argument)
4324 png_imagep image = png_voidcast(png_imagep, argument);
4325 png_controlp cp = image->opaque;
4328 /* Double check that we have a png_ptr - it should be impossible to get here
4331 if (cp->png_ptr == NULL)
4334 /* First free any data held in the control structure. */
4335 # ifdef PNG_STDIO_SUPPORTED
4338 FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
4341 /* Ignore errors here. */
4344 cp->png_ptr->io_ptr = NULL;
4350 /* Copy the control structure so that the original, allocated, version can be
4351 * safely freed. Notice that a png_error here stops the remainder of the
4352 * cleanup, but this is probably fine because that would indicate bad memory
4357 png_free(c.png_ptr, cp);
4359 /* Then the structures, calling the correct API. */
4362 # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
4363 png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
4365 png_error(c.png_ptr, "simplified write not supported");
4370 # ifdef PNG_SIMPLIFIED_READ_SUPPORTED
4371 png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
4373 png_error(c.png_ptr, "simplified read not supported");
4382 png_image_free(png_imagep image)
4384 /* Safely call the real function, but only if doing so is safe at this point
4385 * (if not inside an error handling context). Otherwise assume
4386 * png_safe_execute will call this API after the return.
4388 if (image != NULL && image->opaque != NULL &&
4389 image->opaque->error_buf == NULL)
4391 /* Ignore errors here: */
4392 (void)png_safe_execute(image, png_image_free_function, image);
4393 image->opaque = NULL;
4398 png_image_error(png_imagep image, png_const_charp error_message)
4400 /* Utility to log an error. */
4401 png_safecat(image->message, (sizeof image->message), 0, error_message);
4402 image->warning_or_error |= PNG_IMAGE_ERROR;
4403 png_image_free(image);
4407 #endif /* SIMPLIFIED READ/WRITE */
4408 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */