2 /* png.c - location for general purpose libpng functions
4 * Last changed in libpng 1.5.14 [January 24, 2013]
5 * Copyright (c) 1998-2013 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_5_14 Your_png_h_is_not_version_1_5_14
;
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_structp 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)(png_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
)
77 png_uint_32 save_flags
;
78 png_alloc_size_t num_bytes
;
83 p
=(png_structp
)png_ptr
;
86 if (items
> PNG_UINT_32_MAX
/size
)
88 png_warning (p
, "Potential overflow in png_zalloc()");
91 num_bytes
= (png_alloc_size_t
)items
* size
;
93 p
->flags
|=PNG_FLAG_MALLOC_NULL_MEM_OK
;
94 ptr
= (png_voidp
)png_malloc((png_structp
)png_ptr
, num_bytes
);
100 /* Function to free memory for zlib */
102 png_zfree(voidpf png_ptr
, voidpf ptr
)
104 png_free((png_structp
)png_ptr
, (png_voidp
)ptr
);
107 /* Reset the CRC variable to 32 bits of 1's. Care must be taken
108 * in case CRC is > 32 bits to leave the top bits 0.
111 png_reset_crc(png_structp png_ptr
)
113 /* The cast is safe because the crc is a 32 bit value. */
114 png_ptr
->crc
= (png_uint_32
)crc32(0, Z_NULL
, 0);
117 /* Calculate the CRC over a section of data. We can only pass as
118 * much data to this routine as the largest single buffer size. We
119 * also check that this data will actually be used before going to the
120 * trouble of calculating it.
123 png_calculate_crc(png_structp png_ptr
, png_const_bytep ptr
, png_size_t length
)
127 if (PNG_CHUNK_ANCILLIARY(png_ptr
->chunk_name
))
129 if ((png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_MASK
) ==
130 (PNG_FLAG_CRC_ANCILLARY_USE
| PNG_FLAG_CRC_ANCILLARY_NOWARN
))
136 if (png_ptr
->flags
& PNG_FLAG_CRC_CRITICAL_IGNORE
)
140 /* 'uLong' is defined as unsigned long, this means that on some systems it is
141 * a 64 bit value. crc32, however, returns 32 bits so the following cast is
142 * safe. 'uInt' may be no more than 16 bits, so it is necessary to perform a
145 if (need_crc
&& length
> 0)
147 uLong crc
= png_ptr
->crc
; /* Should never issue a warning */
151 uInt safeLength
= (uInt
)length
;
153 safeLength
= (uInt
)-1; /* evil, but safe */
155 crc
= crc32(crc
, ptr
, safeLength
);
157 /* The following should never issue compiler warnings, if they do the
158 * target system has characteristics that will probably violate other
159 * assumptions within the libpng code.
162 length
-= safeLength
;
166 /* And the following is always safe because the crc is only 32 bits. */
167 png_ptr
->crc
= (png_uint_32
)crc
;
171 /* Check a user supplied version number, called from both read and write
172 * functions that create a png_struct
175 png_user_version_check(png_structp png_ptr
, png_const_charp user_png_ver
)
183 if (user_png_ver
[i
] != png_libpng_ver
[i
])
184 png_ptr
->flags
|= PNG_FLAG_LIBRARY_MISMATCH
;
185 } while (png_libpng_ver
[i
++]);
189 png_ptr
->flags
|= PNG_FLAG_LIBRARY_MISMATCH
;
191 if (png_ptr
->flags
& PNG_FLAG_LIBRARY_MISMATCH
)
193 /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
194 * we must recompile any applications that use any older library version.
195 * For versions after libpng 1.0, we will be compatible, so we need
196 * only check the first digit.
198 if (user_png_ver
== NULL
|| user_png_ver
[0] != png_libpng_ver
[0] ||
199 (user_png_ver
[0] == '1' && user_png_ver
[2] != png_libpng_ver
[2]) ||
200 (user_png_ver
[0] == '0' && user_png_ver
[2] < '9'))
202 #ifdef PNG_WARNINGS_SUPPORTED
206 pos
= png_safecat(m
, sizeof m
, pos
, "Application built with libpng-");
207 pos
= png_safecat(m
, sizeof m
, pos
, user_png_ver
);
208 pos
= png_safecat(m
, sizeof m
, pos
, " but running with ");
209 pos
= png_safecat(m
, sizeof m
, pos
, png_libpng_ver
);
211 png_warning(png_ptr
, m
);
214 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
222 /* Success return. */
226 /* Allocate the memory for an info_struct for the application. We don't
227 * really need the png_ptr, but it could potentially be useful in the
228 * future. This should be used in favour of malloc(png_sizeof(png_info))
229 * and png_info_init() so that applications that want to use a shared
230 * libpng don't have to be recompiled if png_info changes size.
232 PNG_FUNCTION(png_infop
,PNGAPI
233 png_create_info_struct
,(png_structp png_ptr
),PNG_ALLOCATED
)
237 png_debug(1, "in png_create_info_struct");
242 #ifdef PNG_USER_MEM_SUPPORTED
243 info_ptr
= (png_infop
)png_create_struct_2(PNG_STRUCT_INFO
,
244 png_ptr
->malloc_fn
, png_ptr
->mem_ptr
);
246 info_ptr
= (png_infop
)png_create_struct(PNG_STRUCT_INFO
);
248 if (info_ptr
!= NULL
)
249 png_info_init_3(&info_ptr
, png_sizeof(png_info
));
254 /* This function frees the memory associated with a single info struct.
255 * Normally, one would use either png_destroy_read_struct() or
256 * png_destroy_write_struct() to free an info struct, but this may be
257 * useful for some applications.
260 png_destroy_info_struct(png_structp png_ptr
, png_infopp info_ptr_ptr
)
262 png_infop info_ptr
= NULL
;
264 png_debug(1, "in png_destroy_info_struct");
269 if (info_ptr_ptr
!= NULL
)
270 info_ptr
= *info_ptr_ptr
;
272 if (info_ptr
!= NULL
)
274 png_info_destroy(png_ptr
, info_ptr
);
276 #ifdef PNG_USER_MEM_SUPPORTED
277 png_destroy_struct_2((png_voidp
)info_ptr
, png_ptr
->free_fn
,
280 png_destroy_struct((png_voidp
)info_ptr
);
282 *info_ptr_ptr
= NULL
;
286 /* Initialize the info structure. This is now an internal function (0.89)
287 * and applications using it are urged to use png_create_info_struct()
292 png_info_init_3(png_infopp ptr_ptr
, png_size_t png_info_struct_size
)
294 png_infop info_ptr
= *ptr_ptr
;
296 png_debug(1, "in png_info_init_3");
298 if (info_ptr
== NULL
)
301 if (png_sizeof(png_info
) > png_info_struct_size
)
303 png_destroy_struct(info_ptr
);
304 info_ptr
= (png_infop
)png_create_struct(PNG_STRUCT_INFO
);
308 /* Set everything to 0 */
309 png_memset(info_ptr
, 0, png_sizeof(png_info
));
313 png_data_freer(png_structp png_ptr
, png_infop info_ptr
,
314 int freer
, png_uint_32 mask
)
316 png_debug(1, "in png_data_freer");
318 if (png_ptr
== NULL
|| info_ptr
== NULL
)
321 if (freer
== PNG_DESTROY_WILL_FREE_DATA
)
322 info_ptr
->free_me
|= mask
;
324 else if (freer
== PNG_USER_WILL_FREE_DATA
)
325 info_ptr
->free_me
&= ~mask
;
329 "Unknown freer parameter in png_data_freer");
333 png_free_data(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 mask
,
336 png_debug(1, "in png_free_data");
338 if (png_ptr
== NULL
|| info_ptr
== NULL
)
341 #ifdef PNG_TEXT_SUPPORTED
342 /* Free text item num or (if num == -1) all text items */
343 if ((mask
& PNG_FREE_TEXT
) & info_ptr
->free_me
)
347 if (info_ptr
->text
&& info_ptr
->text
[num
].key
)
349 png_free(png_ptr
, info_ptr
->text
[num
].key
);
350 info_ptr
->text
[num
].key
= NULL
;
357 for (i
= 0; i
< info_ptr
->num_text
; i
++)
358 png_free_data(png_ptr
, info_ptr
, PNG_FREE_TEXT
, i
);
359 png_free(png_ptr
, info_ptr
->text
);
360 info_ptr
->text
= NULL
;
361 info_ptr
->num_text
=0;
366 #ifdef PNG_tRNS_SUPPORTED
367 /* Free any tRNS entry */
368 if ((mask
& PNG_FREE_TRNS
) & info_ptr
->free_me
)
370 png_free(png_ptr
, info_ptr
->trans_alpha
);
371 info_ptr
->trans_alpha
= NULL
;
372 info_ptr
->valid
&= ~PNG_INFO_tRNS
;
376 #ifdef PNG_sCAL_SUPPORTED
377 /* Free any sCAL entry */
378 if ((mask
& PNG_FREE_SCAL
) & info_ptr
->free_me
)
380 png_free(png_ptr
, info_ptr
->scal_s_width
);
381 png_free(png_ptr
, info_ptr
->scal_s_height
);
382 info_ptr
->scal_s_width
= NULL
;
383 info_ptr
->scal_s_height
= NULL
;
384 info_ptr
->valid
&= ~PNG_INFO_sCAL
;
388 #ifdef PNG_pCAL_SUPPORTED
389 /* Free any pCAL entry */
390 if ((mask
& PNG_FREE_PCAL
) & info_ptr
->free_me
)
392 png_free(png_ptr
, info_ptr
->pcal_purpose
);
393 png_free(png_ptr
, info_ptr
->pcal_units
);
394 info_ptr
->pcal_purpose
= NULL
;
395 info_ptr
->pcal_units
= NULL
;
396 if (info_ptr
->pcal_params
!= NULL
)
399 for (i
= 0; i
< (int)info_ptr
->pcal_nparams
; i
++)
401 png_free(png_ptr
, info_ptr
->pcal_params
[i
]);
402 info_ptr
->pcal_params
[i
] = NULL
;
404 png_free(png_ptr
, info_ptr
->pcal_params
);
405 info_ptr
->pcal_params
= NULL
;
407 info_ptr
->valid
&= ~PNG_INFO_pCAL
;
411 #ifdef PNG_iCCP_SUPPORTED
412 /* Free any iCCP entry */
413 if ((mask
& PNG_FREE_ICCP
) & info_ptr
->free_me
)
415 png_free(png_ptr
, info_ptr
->iccp_name
);
416 png_free(png_ptr
, info_ptr
->iccp_profile
);
417 info_ptr
->iccp_name
= NULL
;
418 info_ptr
->iccp_profile
= NULL
;
419 info_ptr
->valid
&= ~PNG_INFO_iCCP
;
423 #ifdef PNG_sPLT_SUPPORTED
424 /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
425 if ((mask
& PNG_FREE_SPLT
) & info_ptr
->free_me
)
429 if (info_ptr
->splt_palettes
)
431 png_free(png_ptr
, info_ptr
->splt_palettes
[num
].name
);
432 png_free(png_ptr
, info_ptr
->splt_palettes
[num
].entries
);
433 info_ptr
->splt_palettes
[num
].name
= NULL
;
434 info_ptr
->splt_palettes
[num
].entries
= NULL
;
440 if (info_ptr
->splt_palettes_num
)
443 for (i
= 0; i
< (int)info_ptr
->splt_palettes_num
; i
++)
444 png_free_data(png_ptr
, info_ptr
, PNG_FREE_SPLT
, i
);
446 png_free(png_ptr
, info_ptr
->splt_palettes
);
447 info_ptr
->splt_palettes
= NULL
;
448 info_ptr
->splt_palettes_num
= 0;
450 info_ptr
->valid
&= ~PNG_INFO_sPLT
;
455 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
456 if (png_ptr
->unknown_chunk
.data
)
458 png_free(png_ptr
, png_ptr
->unknown_chunk
.data
);
459 png_ptr
->unknown_chunk
.data
= NULL
;
462 if ((mask
& PNG_FREE_UNKN
) & info_ptr
->free_me
)
466 if (info_ptr
->unknown_chunks
)
468 png_free(png_ptr
, info_ptr
->unknown_chunks
[num
].data
);
469 info_ptr
->unknown_chunks
[num
].data
= NULL
;
477 if (info_ptr
->unknown_chunks_num
)
479 for (i
= 0; i
< info_ptr
->unknown_chunks_num
; i
++)
480 png_free_data(png_ptr
, info_ptr
, PNG_FREE_UNKN
, i
);
482 png_free(png_ptr
, info_ptr
->unknown_chunks
);
483 info_ptr
->unknown_chunks
= NULL
;
484 info_ptr
->unknown_chunks_num
= 0;
490 #ifdef PNG_hIST_SUPPORTED
491 /* Free any hIST entry */
492 if ((mask
& PNG_FREE_HIST
) & info_ptr
->free_me
)
494 png_free(png_ptr
, info_ptr
->hist
);
495 info_ptr
->hist
= NULL
;
496 info_ptr
->valid
&= ~PNG_INFO_hIST
;
500 /* Free any PLTE entry that was internally allocated */
501 if ((mask
& PNG_FREE_PLTE
) & info_ptr
->free_me
)
503 png_zfree(png_ptr
, info_ptr
->palette
);
504 info_ptr
->palette
= NULL
;
505 info_ptr
->valid
&= ~PNG_INFO_PLTE
;
506 info_ptr
->num_palette
= 0;
509 #ifdef PNG_INFO_IMAGE_SUPPORTED
510 /* Free any image bits attached to the info structure */
511 if ((mask
& PNG_FREE_ROWS
) & info_ptr
->free_me
)
513 if (info_ptr
->row_pointers
)
516 for (row
= 0; row
< (int)info_ptr
->height
; row
++)
518 png_free(png_ptr
, info_ptr
->row_pointers
[row
]);
519 info_ptr
->row_pointers
[row
] = NULL
;
521 png_free(png_ptr
, info_ptr
->row_pointers
);
522 info_ptr
->row_pointers
= NULL
;
524 info_ptr
->valid
&= ~PNG_INFO_IDAT
;
529 mask
&= ~PNG_FREE_MUL
;
531 info_ptr
->free_me
&= ~mask
;
534 /* This is an internal routine to free any memory that the info struct is
535 * pointing to before re-using it or freeing the struct itself. Recall
536 * that png_free() checks for NULL pointers for us.
539 png_info_destroy(png_structp png_ptr
, png_infop info_ptr
)
541 png_debug(1, "in png_info_destroy");
543 png_free_data(png_ptr
, info_ptr
, PNG_FREE_ALL
, -1);
545 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
546 if (png_ptr
->num_chunk_list
)
548 png_free(png_ptr
, png_ptr
->chunk_list
);
549 png_ptr
->chunk_list
= NULL
;
550 png_ptr
->num_chunk_list
= 0;
554 png_info_init_3(&info_ptr
, png_sizeof(png_info
));
556 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
558 /* This function returns a pointer to the io_ptr associated with the user
559 * functions. The application should free any memory associated with this
560 * pointer before png_write_destroy() or png_read_destroy() are called.
563 png_get_io_ptr(png_structp png_ptr
)
568 return (png_ptr
->io_ptr
);
571 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
572 # ifdef PNG_STDIO_SUPPORTED
573 /* Initialize the default input/output functions for the PNG file. If you
574 * use your own read or write routines, you can call either png_set_read_fn()
575 * or png_set_write_fn() instead of png_init_io(). If you have defined
576 * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
577 * function of your own because "FILE *" isn't necessarily available.
580 png_init_io(png_structp png_ptr
, png_FILE_p fp
)
582 png_debug(1, "in png_init_io");
587 png_ptr
->io_ptr
= (png_voidp
)fp
;
591 # ifdef PNG_TIME_RFC1123_SUPPORTED
592 /* Convert the supplied time into an RFC 1123 string suitable for use in
593 * a "Creation Time" or other text-based time string.
595 png_const_charp PNGAPI
596 png_convert_to_rfc1123(png_structp png_ptr
, png_const_timep ptime
)
598 static PNG_CONST
char short_months
[12][4] =
599 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
600 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
605 if (ptime
->year
> 9999 /* RFC1123 limitation */ ||
606 ptime
->month
== 0 || ptime
->month
> 12 ||
607 ptime
->day
== 0 || ptime
->day
> 31 ||
608 ptime
->hour
> 23 || ptime
->minute
> 59 ||
611 png_warning(png_ptr
, "Ignoring invalid time value");
617 char number_buf
[5]; /* enough for a four-digit year */
619 # define APPEND_STRING(string)\
620 pos = png_safecat(png_ptr->time_buffer, sizeof png_ptr->time_buffer,\
622 # define APPEND_NUMBER(format, value)\
623 APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
625 if (pos < (sizeof png_ptr->time_buffer)-1)\
626 png_ptr->time_buffer[pos++] = (ch)
628 APPEND_NUMBER(PNG_NUMBER_FORMAT_u
, (unsigned)ptime
->day
);
630 APPEND_STRING(short_months
[(ptime
->month
- 1)]);
632 APPEND_NUMBER(PNG_NUMBER_FORMAT_u
, ptime
->year
);
634 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u
, (unsigned)ptime
->hour
);
636 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u
, (unsigned)ptime
->minute
);
638 APPEND_NUMBER(PNG_NUMBER_FORMAT_02u
, (unsigned)ptime
->second
);
639 APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
642 # undef APPEND_NUMBER
643 # undef APPEND_STRING
646 return png_ptr
->time_buffer
;
648 # endif /* PNG_TIME_RFC1123_SUPPORTED */
650 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
652 png_const_charp PNGAPI
653 png_get_copyright(png_const_structp png_ptr
)
655 PNG_UNUSED(png_ptr
) /* Silence compiler warning about unused png_ptr */
656 #ifdef PNG_STRING_COPYRIGHT
657 return PNG_STRING_COPYRIGHT
660 return PNG_STRING_NEWLINE \
661 "libpng version 1.5.14 - January 24, 2013" PNG_STRING_NEWLINE \
662 "Copyright (c) 1998-2013 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
663 "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
664 "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
667 return "libpng version 1.5.14 - January 24, 2013\
668 Copyright (c) 1998-2013 Glenn Randers-Pehrson\
669 Copyright (c) 1996-1997 Andreas Dilger\
670 Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
675 /* The following return the library version as a short string in the
676 * format 1.0.0 through 99.99.99zz. To get the version of *.h files
677 * used with your application, print out PNG_LIBPNG_VER_STRING, which
678 * is defined in png.h.
679 * Note: now there is no difference between png_get_libpng_ver() and
680 * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
681 * it is guaranteed that png.c uses the correct version of png.h.
683 png_const_charp PNGAPI
684 png_get_libpng_ver(png_const_structp png_ptr
)
686 /* Version of *.c files used when building libpng */
687 return png_get_header_ver(png_ptr
);
690 png_const_charp PNGAPI
691 png_get_header_ver(png_const_structp png_ptr
)
693 /* Version of *.h files used when building libpng */
694 PNG_UNUSED(png_ptr
) /* Silence compiler warning about unused png_ptr */
695 return PNG_LIBPNG_VER_STRING
;
698 png_const_charp PNGAPI
699 png_get_header_version(png_const_structp png_ptr
)
701 /* Returns longer string containing both version and date */
702 PNG_UNUSED(png_ptr
) /* Silence compiler warning about unused png_ptr */
704 return PNG_HEADER_VERSION_STRING
705 # ifndef PNG_READ_SUPPORTED
710 return PNG_HEADER_VERSION_STRING
;
714 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
716 png_handle_as_unknown(png_structp png_ptr
, png_const_bytep chunk_name
)
718 /* Check chunk_name and return "keep" value if it's on the list, else 0 */
719 png_const_bytep p
, p_end
;
721 if (png_ptr
== NULL
|| chunk_name
== NULL
|| png_ptr
->num_chunk_list
<= 0)
722 return PNG_HANDLE_CHUNK_AS_DEFAULT
;
724 p_end
= png_ptr
->chunk_list
;
725 p
= p_end
+ png_ptr
->num_chunk_list
*5; /* beyond end */
727 /* The code is the fifth byte after each four byte string. Historically this
728 * code was always searched from the end of the list, so it should continue
729 * to do so in case there are duplicated entries.
731 do /* num_chunk_list > 0, so at least one */
734 if (!png_memcmp(chunk_name
, p
, 4))
739 return PNG_HANDLE_CHUNK_AS_DEFAULT
;
743 png_chunk_unknown_handling(png_structp png_ptr
, png_uint_32 chunk_name
)
745 png_byte chunk_string
[5];
747 PNG_CSTRING_FROM_CHUNK(chunk_string
, chunk_name
);
748 return png_handle_as_unknown(png_ptr
, chunk_string
);
752 #ifdef PNG_READ_SUPPORTED
753 /* This function, added to libpng-1.0.6g, is untested. */
755 png_reset_zstream(png_structp png_ptr
)
758 return Z_STREAM_ERROR
;
760 return (inflateReset(&png_ptr
->zstream
));
762 #endif /* PNG_READ_SUPPORTED */
764 /* This function was added to libpng-1.0.7 */
766 png_access_version_number(void)
768 /* Version of *.c files used when building libpng */
769 return((png_uint_32
)PNG_LIBPNG_VER
);
774 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
775 /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
779 /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
780 # ifdef PNG_CHECK_cHRM_SUPPORTED
783 png_check_cHRM_fixed(png_structp png_ptr
,
784 png_fixed_point white_x
, png_fixed_point white_y
, png_fixed_point red_x
,
785 png_fixed_point red_y
, png_fixed_point green_x
, png_fixed_point green_y
,
786 png_fixed_point blue_x
, png_fixed_point blue_y
)
789 unsigned long xy_hi
,xy_lo
,yx_hi
,yx_lo
;
791 png_debug(1, "in function png_check_cHRM_fixed");
796 /* (x,y,z) values are first limited to 0..100000 (PNG_FP_1), the white
797 * y must also be greater than 0. To test for the upper limit calculate
798 * (PNG_FP_1-y) - x must be <= to this for z to be >= 0 (and the expression
799 * cannot overflow.) At this point we know x and y are >= 0 and (x+y) is
800 * <= PNG_FP_1. The previous test on PNG_MAX_UINT_31 is removed because it
801 * pointless (and it produces compiler warnings!)
803 if (white_x
< 0 || white_y
<= 0 ||
804 red_x
< 0 || red_y
< 0 ||
805 green_x
< 0 || green_y
< 0 ||
806 blue_x
< 0 || blue_y
< 0)
809 "Ignoring attempt to set negative chromaticity value");
812 /* And (x+y) must be <= PNG_FP_1 (so z is >= 0) */
813 if (white_x
> PNG_FP_1
- white_y
)
815 png_warning(png_ptr
, "Invalid cHRM white point");
819 if (red_x
> PNG_FP_1
- red_y
)
821 png_warning(png_ptr
, "Invalid cHRM red point");
825 if (green_x
> PNG_FP_1
- green_y
)
827 png_warning(png_ptr
, "Invalid cHRM green point");
831 if (blue_x
> PNG_FP_1
- blue_y
)
833 png_warning(png_ptr
, "Invalid cHRM blue point");
837 png_64bit_product(green_x
- red_x
, blue_y
- red_y
, &xy_hi
, &xy_lo
);
838 png_64bit_product(green_y
- red_y
, blue_x
- red_x
, &yx_hi
, &yx_lo
);
840 if (xy_hi
== yx_hi
&& xy_lo
== yx_lo
)
843 "Ignoring attempt to set cHRM RGB triangle with zero area");
849 # endif /* PNG_CHECK_cHRM_SUPPORTED */
851 #ifdef PNG_cHRM_SUPPORTED
852 /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
853 * cHRM, as opposed to using chromaticities. These internal APIs return
854 * non-zero on a parameter error. The X, Y and Z values are required to be
855 * positive and less than 1.0.
857 int png_xy_from_XYZ(png_xy
*xy
, png_XYZ XYZ
)
859 png_int_32 d
, dwhite
, whiteX
, whiteY
;
861 d
= XYZ
.redX
+ XYZ
.redY
+ XYZ
.redZ
;
862 if (!png_muldiv(&xy
->redx
, XYZ
.redX
, PNG_FP_1
, d
)) return 1;
863 if (!png_muldiv(&xy
->redy
, XYZ
.redY
, PNG_FP_1
, d
)) return 1;
868 d
= XYZ
.greenX
+ XYZ
.greenY
+ XYZ
.greenZ
;
869 if (!png_muldiv(&xy
->greenx
, XYZ
.greenX
, PNG_FP_1
, d
)) return 1;
870 if (!png_muldiv(&xy
->greeny
, XYZ
.greenY
, PNG_FP_1
, d
)) return 1;
872 whiteX
+= XYZ
.greenX
;
873 whiteY
+= XYZ
.greenY
;
875 d
= XYZ
.blueX
+ XYZ
.blueY
+ XYZ
.blueZ
;
876 if (!png_muldiv(&xy
->bluex
, XYZ
.blueX
, PNG_FP_1
, d
)) return 1;
877 if (!png_muldiv(&xy
->bluey
, XYZ
.blueY
, PNG_FP_1
, d
)) return 1;
882 /* The reference white is simply the same of the end-point (X,Y,Z) vectors,
885 if (!png_muldiv(&xy
->whitex
, whiteX
, PNG_FP_1
, dwhite
)) return 1;
886 if (!png_muldiv(&xy
->whitey
, whiteY
, PNG_FP_1
, dwhite
)) return 1;
891 int png_XYZ_from_xy(png_XYZ
*XYZ
, png_xy xy
)
893 png_fixed_point red_inverse
, green_inverse
, blue_scale
;
894 png_fixed_point left
, right
, denominator
;
896 /* Check xy and, implicitly, z. Note that wide gamut color spaces typically
897 * have end points with 0 tristimulus values (these are impossible end
898 * points, but they are used to cover the possible colors.)
900 if (xy
.redx
< 0 || xy
.redx
> PNG_FP_1
) return 1;
901 if (xy
.redy
< 0 || xy
.redy
> PNG_FP_1
-xy
.redx
) return 1;
902 if (xy
.greenx
< 0 || xy
.greenx
> PNG_FP_1
) return 1;
903 if (xy
.greeny
< 0 || xy
.greeny
> PNG_FP_1
-xy
.greenx
) return 1;
904 if (xy
.bluex
< 0 || xy
.bluex
> PNG_FP_1
) return 1;
905 if (xy
.bluey
< 0 || xy
.bluey
> PNG_FP_1
-xy
.bluex
) return 1;
906 if (xy
.whitex
< 0 || xy
.whitex
> PNG_FP_1
) return 1;
907 if (xy
.whitey
< 0 || xy
.whitey
> PNG_FP_1
-xy
.whitex
) return 1;
909 /* The reverse calculation is more difficult because the original tristimulus
910 * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
911 * derived values were recorded in the cHRM chunk;
912 * (red,green,blue,white)x(x,y). This loses one degree of freedom and
913 * therefore an arbitrary ninth value has to be introduced to undo the
914 * original transformations.
916 * Think of the original end-points as points in (X,Y,Z) space. The
917 * chromaticity values (c) have the property:
923 * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the
924 * three chromaticity values (x,y,z) for each end-point obey the
929 * This describes the plane in (X,Y,Z) space that intersects each axis at the
930 * value 1.0; call this the chromaticity plane. Thus the chromaticity
931 * calculation has scaled each end-point so that it is on the x+y+z=1 plane
932 * and chromaticity is the intersection of the vector from the origin to the
933 * (X,Y,Z) value with the chromaticity plane.
935 * To fully invert the chromaticity calculation we would need the three
936 * end-point scale factors, (red-scale, green-scale, blue-scale), but these
937 * were not recorded. Instead we calculated the reference white (X,Y,Z) and
938 * recorded the chromaticity of this. The reference white (X,Y,Z) would have
939 * given all three of the scale factors since:
941 * color-C = color-c * color-scale
942 * white-C = red-C + green-C + blue-C
943 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
945 * But cHRM records only white-x and white-y, so we have lost the white scale
948 * white-C = white-c*white-scale
950 * To handle this the inverse transformation makes an arbitrary assumption
953 * Assume: white-Y = 1.0
954 * Hence: white-scale = 1/white-y
955 * Or: red-Y + green-Y + blue-Y = 1.0
957 * Notice the last statement of the assumption gives an equation in three of
958 * the nine values we want to calculate. 8 more equations come from the
959 * above routine as summarised at the top above (the chromaticity
962 * Given: color-x = color-X / (color-X + color-Y + color-Z)
963 * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
965 * This is 9 simultaneous equations in the 9 variables "color-C" and can be
966 * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix
967 * determinants, however this is not as bad as it seems because only 28 of
968 * the total of 90 terms in the various matrices are non-zero. Nevertheless
969 * Cramer's rule is notoriously numerically unstable because the determinant
970 * calculation involves the difference of large, but similar, numbers. It is
971 * difficult to be sure that the calculation is stable for real world values
972 * and it is certain that it becomes unstable where the end points are close
975 * So this code uses the perhaps slightly less optimal but more
976 * understandable and totally obvious approach of calculating color-scale.
978 * This algorithm depends on the precision in white-scale and that is
979 * (1/white-y), so we can immediately see that as white-y approaches 0 the
980 * accuracy inherent in the cHRM chunk drops off substantially.
982 * libpng arithmetic: a simple invertion of the above equations
983 * ------------------------------------------------------------
985 * white_scale = 1/white-y
986 * white-X = white-x * white-scale
988 * white-Z = (1 - white-x - white-y) * white_scale
990 * white-C = red-C + green-C + blue-C
991 * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
993 * This gives us three equations in (red-scale,green-scale,blue-scale) where
994 * all the coefficients are now known:
996 * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
998 * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
999 * red-z*red-scale + green-z*green-scale + blue-z*blue-scale
1000 * = (1 - white-x - white-y)/white-y
1002 * In the last equation color-z is (1 - color-x - color-y) so we can add all
1003 * three equations together to get an alternative third:
1005 * red-scale + green-scale + blue-scale = 1/white-y = white-scale
1007 * So now we have a Cramer's rule solution where the determinants are just
1008 * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve
1009 * multiplication of three coefficients so we can't guarantee to avoid
1010 * overflow in the libpng fixed point representation. Using Cramer's rule in
1011 * floating point is probably a good choice here, but it's not an option for
1012 * fixed point. Instead proceed to simplify the first two equations by
1013 * eliminating what is likely to be the largest value, blue-scale:
1015 * blue-scale = white-scale - red-scale - green-scale
1019 * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
1020 * (white-x - blue-x)*white-scale
1022 * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
1023 * 1 - blue-y*white-scale
1025 * And now we can trivially solve for (red-scale,green-scale):
1028 * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
1029 * -----------------------------------------------------------
1033 * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
1034 * ---------------------------------------------------------
1040 * ( (green-x - blue-x) * (white-y - blue-y) -
1041 * (green-y - blue-y) * (white-x - blue-x) ) / white-y
1042 * -------------------------------------------------------------------------
1043 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1046 * ( (red-y - blue-y) * (white-x - blue-x) -
1047 * (red-x - blue-x) * (white-y - blue-y) ) / white-y
1048 * -------------------------------------------------------------------------
1049 * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
1052 * The input values have 5 decimal digits of accuracy. The values are all in
1053 * the range 0 < value < 1, so simple products are in the same range but may
1054 * need up to 10 decimal digits to preserve the original precision and avoid
1055 * underflow. Because we are using a 32-bit signed representation we cannot
1056 * match this; the best is a little over 9 decimal digits, less than 10.
1058 * The approach used here is to preserve the maximum precision within the
1059 * signed representation. Because the red-scale calculation above uses the
1060 * difference between two products of values that must be in the range -1..+1
1061 * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The
1062 * factor is irrelevant in the calculation because it is applied to both
1063 * numerator and denominator.
1065 * Note that the values of the differences of the products of the
1066 * chromaticities in the above equations tend to be small, for example for
1067 * the sRGB chromaticities they are:
1069 * red numerator: -0.04751
1070 * green numerator: -0.08788
1071 * denominator: -0.2241 (without white-y multiplication)
1073 * The resultant Y coefficients from the chromaticities of some widely used
1074 * color space definitions are (to 15 decimal places):
1077 * 0.212639005871510 0.715168678767756 0.072192315360734
1079 * 0.288071128229293 0.711843217810102 0.000085653960605
1081 * 0.297344975250536 0.627363566255466 0.075291458493998
1082 * Adobe Wide Gamut RGB
1083 * 0.258728243040113 0.724682314948566 0.016589442011321
1085 /* By the argument, above overflow should be impossible here. The return
1086 * value of 2 indicates an internal error to the caller.
1088 if (!png_muldiv(&left
, xy
.greenx
-xy
.bluex
, xy
.redy
- xy
.bluey
, 7)) return 2;
1089 if (!png_muldiv(&right
, xy
.greeny
-xy
.bluey
, xy
.redx
- xy
.bluex
, 7)) return 2;
1090 denominator
= left
- right
;
1092 /* Now find the red numerator. */
1093 if (!png_muldiv(&left
, xy
.greenx
-xy
.bluex
, xy
.whitey
-xy
.bluey
, 7)) return 2;
1094 if (!png_muldiv(&right
, xy
.greeny
-xy
.bluey
, xy
.whitex
-xy
.bluex
, 7)) return 2;
1096 /* Overflow is possible here and it indicates an extreme set of PNG cHRM
1097 * chunk values. This calculation actually returns the reciprocal of the
1098 * scale value because this allows us to delay the multiplication of white-y
1099 * into the denominator, which tends to produce a small number.
1101 if (!png_muldiv(&red_inverse
, xy
.whitey
, denominator
, left
-right
) ||
1102 red_inverse
<= xy
.whitey
/* r+g+b scales = white scale */)
1105 /* Similarly for green_inverse: */
1106 if (!png_muldiv(&left
, xy
.redy
-xy
.bluey
, xy
.whitex
-xy
.bluex
, 7)) return 2;
1107 if (!png_muldiv(&right
, xy
.redx
-xy
.bluex
, xy
.whitey
-xy
.bluey
, 7)) return 2;
1108 if (!png_muldiv(&green_inverse
, xy
.whitey
, denominator
, left
-right
) ||
1109 green_inverse
<= xy
.whitey
)
1112 /* And the blue scale, the checks above guarantee this can't overflow but it
1113 * can still produce 0 for extreme cHRM values.
1115 blue_scale
= png_reciprocal(xy
.whitey
) - png_reciprocal(red_inverse
) -
1116 png_reciprocal(green_inverse
);
1117 if (blue_scale
<= 0) return 1;
1120 /* And fill in the png_XYZ: */
1121 if (!png_muldiv(&XYZ
->redX
, xy
.redx
, PNG_FP_1
, red_inverse
)) return 1;
1122 if (!png_muldiv(&XYZ
->redY
, xy
.redy
, PNG_FP_1
, red_inverse
)) return 1;
1123 if (!png_muldiv(&XYZ
->redZ
, PNG_FP_1
- xy
.redx
- xy
.redy
, PNG_FP_1
,
1127 if (!png_muldiv(&XYZ
->greenX
, xy
.greenx
, PNG_FP_1
, green_inverse
)) return 1;
1128 if (!png_muldiv(&XYZ
->greenY
, xy
.greeny
, PNG_FP_1
, green_inverse
)) return 1;
1129 if (!png_muldiv(&XYZ
->greenZ
, PNG_FP_1
- xy
.greenx
- xy
.greeny
, PNG_FP_1
,
1133 if (!png_muldiv(&XYZ
->blueX
, xy
.bluex
, blue_scale
, PNG_FP_1
)) return 1;
1134 if (!png_muldiv(&XYZ
->blueY
, xy
.bluey
, blue_scale
, PNG_FP_1
)) return 1;
1135 if (!png_muldiv(&XYZ
->blueZ
, PNG_FP_1
- xy
.bluex
- xy
.bluey
, blue_scale
,
1139 return 0; /*success*/
1142 int png_XYZ_from_xy_checked(png_structp png_ptr
, png_XYZ
*XYZ
, png_xy xy
)
1144 switch (png_XYZ_from_xy(XYZ
, xy
))
1146 case 0: /* success */
1150 /* The chunk may be technically valid, but we got png_fixed_point
1151 * overflow while trying to get XYZ values out of it. This is
1152 * entirely benign - the cHRM chunk is pretty extreme.
1154 png_warning(png_ptr
,
1155 "extreme cHRM chunk cannot be converted to tristimulus values");
1159 /* libpng is broken; this should be a warning but if it happens we
1160 * want error reports so for the moment it is an error.
1162 png_error(png_ptr
, "internal error in png_XYZ_from_xy");
1172 png_check_IHDR(png_structp png_ptr
,
1173 png_uint_32 width
, png_uint_32 height
, int bit_depth
,
1174 int color_type
, int interlace_type
, int compression_type
,
1179 /* Check for width and height valid values */
1182 png_warning(png_ptr
, "Image width is zero in IHDR");
1188 png_warning(png_ptr
, "Image height is zero in IHDR");
1192 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
1193 if (width
> png_ptr
->user_width_max
)
1196 if (width
> PNG_USER_WIDTH_MAX
)
1199 png_warning(png_ptr
, "Image width exceeds user limit in IHDR");
1203 # ifdef PNG_SET_USER_LIMITS_SUPPORTED
1204 if (height
> png_ptr
->user_height_max
)
1206 if (height
> PNG_USER_HEIGHT_MAX
)
1209 png_warning(png_ptr
, "Image height exceeds user limit in IHDR");
1213 if (width
> PNG_UINT_31_MAX
)
1215 png_warning(png_ptr
, "Invalid image width in IHDR");
1219 if (height
> PNG_UINT_31_MAX
)
1221 png_warning(png_ptr
, "Invalid image height in IHDR");
1225 if (width
> (PNG_UINT_32_MAX
1226 >> 3) /* 8-byte RGBA pixels */
1227 - 48 /* bigrowbuf hack */
1228 - 1 /* filter byte */
1229 - 7*8 /* rounding of width to multiple of 8 pixels */
1230 - 8) /* extra max_pixel_depth pad */
1231 png_warning(png_ptr
, "Width is too large for libpng to process pixels");
1233 /* Check other values */
1234 if (bit_depth
!= 1 && bit_depth
!= 2 && bit_depth
!= 4 &&
1235 bit_depth
!= 8 && bit_depth
!= 16)
1237 png_warning(png_ptr
, "Invalid bit depth in IHDR");
1241 if (color_type
< 0 || color_type
== 1 ||
1242 color_type
== 5 || color_type
> 6)
1244 png_warning(png_ptr
, "Invalid color type in IHDR");
1248 if (((color_type
== PNG_COLOR_TYPE_PALETTE
) && bit_depth
> 8) ||
1249 ((color_type
== PNG_COLOR_TYPE_RGB
||
1250 color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
||
1251 color_type
== PNG_COLOR_TYPE_RGB_ALPHA
) && bit_depth
< 8))
1253 png_warning(png_ptr
, "Invalid color type/bit depth combination in IHDR");
1257 if (interlace_type
>= PNG_INTERLACE_LAST
)
1259 png_warning(png_ptr
, "Unknown interlace method in IHDR");
1263 if (compression_type
!= PNG_COMPRESSION_TYPE_BASE
)
1265 png_warning(png_ptr
, "Unknown compression method in IHDR");
1269 # ifdef PNG_MNG_FEATURES_SUPPORTED
1270 /* Accept filter_method 64 (intrapixel differencing) only if
1271 * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
1272 * 2. Libpng did not read a PNG signature (this filter_method is only
1273 * used in PNG datastreams that are embedded in MNG datastreams) and
1274 * 3. The application called png_permit_mng_features with a mask that
1275 * included PNG_FLAG_MNG_FILTER_64 and
1276 * 4. The filter_method is 64 and
1277 * 5. The color_type is RGB or RGBA
1279 if ((png_ptr
->mode
& PNG_HAVE_PNG_SIGNATURE
) &&
1280 png_ptr
->mng_features_permitted
)
1281 png_warning(png_ptr
, "MNG features are not allowed in a PNG datastream");
1283 if (filter_type
!= PNG_FILTER_TYPE_BASE
)
1285 if (!((png_ptr
->mng_features_permitted
& PNG_FLAG_MNG_FILTER_64
) &&
1286 (filter_type
== PNG_INTRAPIXEL_DIFFERENCING
) &&
1287 ((png_ptr
->mode
& PNG_HAVE_PNG_SIGNATURE
) == 0) &&
1288 (color_type
== PNG_COLOR_TYPE_RGB
||
1289 color_type
== PNG_COLOR_TYPE_RGB_ALPHA
)))
1291 png_warning(png_ptr
, "Unknown filter method in IHDR");
1295 if (png_ptr
->mode
& PNG_HAVE_PNG_SIGNATURE
)
1297 png_warning(png_ptr
, "Invalid filter method in IHDR");
1303 if (filter_type
!= PNG_FILTER_TYPE_BASE
)
1305 png_warning(png_ptr
, "Unknown filter method in IHDR");
1311 png_error(png_ptr
, "Invalid IHDR data");
1314 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
1315 /* ASCII to fp functions */
1316 /* Check an ASCII formated floating point value, see the more detailed
1317 * comments in pngpriv.h
1319 /* The following is used internally to preserve the sticky flags */
1320 #define png_fp_add(state, flags) ((state) |= (flags))
1321 #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
1324 png_check_fp_number(png_const_charp string
, png_size_t size
, int *statep
,
1325 png_size_tp whereami
)
1327 int state
= *statep
;
1328 png_size_t i
= *whereami
;
1333 /* First find the type of the next character */
1336 case 43: type
= PNG_FP_SAW_SIGN
; break;
1337 case 45: type
= PNG_FP_SAW_SIGN
+ PNG_FP_NEGATIVE
; break;
1338 case 46: type
= PNG_FP_SAW_DOT
; break;
1339 case 48: type
= PNG_FP_SAW_DIGIT
; break;
1340 case 49: case 50: case 51: case 52:
1341 case 53: case 54: case 55: case 56:
1342 case 57: type
= PNG_FP_SAW_DIGIT
+ PNG_FP_NONZERO
; break;
1344 case 101: type
= PNG_FP_SAW_E
; break;
1345 default: goto PNG_FP_End
;
1348 /* Now deal with this type according to the current
1349 * state, the type is arranged to not overlap the
1350 * bits of the PNG_FP_STATE.
1352 switch ((state
& PNG_FP_STATE
) + (type
& PNG_FP_SAW_ANY
))
1354 case PNG_FP_INTEGER
+ PNG_FP_SAW_SIGN
:
1355 if (state
& PNG_FP_SAW_ANY
)
1356 goto PNG_FP_End
; /* not a part of the number */
1358 png_fp_add(state
, type
);
1361 case PNG_FP_INTEGER
+ PNG_FP_SAW_DOT
:
1362 /* Ok as trailer, ok as lead of fraction. */
1363 if (state
& PNG_FP_SAW_DOT
) /* two dots */
1366 else if (state
& PNG_FP_SAW_DIGIT
) /* trailing dot? */
1367 png_fp_add(state
, type
);
1370 png_fp_set(state
, PNG_FP_FRACTION
| type
);
1374 case PNG_FP_INTEGER
+ PNG_FP_SAW_DIGIT
:
1375 if (state
& PNG_FP_SAW_DOT
) /* delayed fraction */
1376 png_fp_set(state
, PNG_FP_FRACTION
| PNG_FP_SAW_DOT
);
1378 png_fp_add(state
, type
| PNG_FP_WAS_VALID
);
1382 case PNG_FP_INTEGER
+ PNG_FP_SAW_E
:
1383 if ((state
& PNG_FP_SAW_DIGIT
) == 0)
1386 png_fp_set(state
, PNG_FP_EXPONENT
);
1390 /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
1391 goto PNG_FP_End; ** no sign in fraction */
1393 /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
1394 goto PNG_FP_End; ** Because SAW_DOT is always set */
1396 case PNG_FP_FRACTION
+ PNG_FP_SAW_DIGIT
:
1397 png_fp_add(state
, type
| PNG_FP_WAS_VALID
);
1400 case PNG_FP_FRACTION
+ PNG_FP_SAW_E
:
1401 /* This is correct because the trailing '.' on an
1402 * integer is handled above - so we can only get here
1403 * with the sequence ".E" (with no preceding digits).
1405 if ((state
& PNG_FP_SAW_DIGIT
) == 0)
1408 png_fp_set(state
, PNG_FP_EXPONENT
);
1412 case PNG_FP_EXPONENT
+ PNG_FP_SAW_SIGN
:
1413 if (state
& PNG_FP_SAW_ANY
)
1414 goto PNG_FP_End
; /* not a part of the number */
1416 png_fp_add(state
, PNG_FP_SAW_SIGN
);
1420 /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
1423 case PNG_FP_EXPONENT
+ PNG_FP_SAW_DIGIT
:
1424 png_fp_add(state
, PNG_FP_SAW_DIGIT
| PNG_FP_WAS_VALID
);
1428 /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
1431 default: goto PNG_FP_End
; /* I.e. break 2 */
1434 /* The character seems ok, continue. */
1439 /* Here at the end, update the state and return the correct
1445 return (state
& PNG_FP_SAW_DIGIT
) != 0;
1449 /* The same but for a complete string. */
1451 png_check_fp_string(png_const_charp string
, png_size_t size
)
1454 png_size_t char_index
=0;
1456 if (png_check_fp_number(string
, size
, &state
, &char_index
) &&
1457 (char_index
== size
|| string
[char_index
] == 0))
1458 return state
/* must be non-zero - see above */;
1460 return 0; /* i.e. fail */
1462 #endif /* pCAL or sCAL */
1464 #ifdef PNG_sCAL_SUPPORTED
1465 # ifdef PNG_FLOATING_POINT_SUPPORTED
1466 /* Utility used below - a simple accurate power of ten from an integral
1470 png_pow10(int power
)
1475 /* Handle negative exponent with a reciprocal at the end because
1476 * 10 is exact whereas .1 is inexact in base 2
1480 if (power
< DBL_MIN_10_EXP
) return 0;
1481 recip
= 1, power
= -power
;
1486 /* Decompose power bitwise. */
1490 if (power
& 1) d
*= mult
;
1498 /* else power is 0 and d is 1 */
1503 /* Function to format a floating point value in ASCII with a given
1507 png_ascii_from_fp(png_structp png_ptr
, png_charp ascii
, png_size_t size
,
1508 double fp
, unsigned int precision
)
1510 /* We use standard functions from math.h, but not printf because
1511 * that would require stdio. The caller must supply a buffer of
1512 * sufficient size or we will png_error. The tests on size and
1513 * the space in ascii[] consumed are indicated below.
1516 precision
= DBL_DIG
;
1518 /* Enforce the limit of the implementation precision too. */
1519 if (precision
> DBL_DIG
+1)
1520 precision
= DBL_DIG
+1;
1522 /* Basic sanity checks */
1523 if (size
>= precision
+5) /* See the requirements below. */
1528 *ascii
++ = 45; /* '-' PLUS 1 TOTAL 1 */
1532 if (fp
>= DBL_MIN
&& fp
<= DBL_MAX
)
1534 int exp_b10
; /* A base 10 exponent */
1535 double base
; /* 10^exp_b10 */
1537 /* First extract a base 10 exponent of the number,
1538 * the calculation below rounds down when converting
1539 * from base 2 to base 10 (multiply by log10(2) -
1540 * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
1541 * be increased. Note that the arithmetic shift
1542 * performs a floor() unlike C arithmetic - using a
1543 * C multiply would break the following for negative
1546 (void)frexp(fp
, &exp_b10
); /* exponent to base 2 */
1548 exp_b10
= (exp_b10
* 77) >> 8; /* <= exponent to base 10 */
1550 /* Avoid underflow here. */
1551 base
= png_pow10(exp_b10
); /* May underflow */
1553 while (base
< DBL_MIN
|| base
< fp
)
1555 /* And this may overflow. */
1556 double test
= png_pow10(exp_b10
+1);
1558 if (test
<= DBL_MAX
)
1559 ++exp_b10
, base
= test
;
1565 /* Normalize fp and correct exp_b10, after this fp is in the
1566 * range [.1,1) and exp_b10 is both the exponent and the digit
1567 * *before* which the decimal point should be inserted
1568 * (starting with 0 for the first digit). Note that this
1569 * works even if 10^exp_b10 is out of range because of the
1570 * test on DBL_MAX above.
1573 while (fp
>= 1) fp
/= 10, ++exp_b10
;
1575 /* Because of the code above fp may, at this point, be
1576 * less than .1, this is ok because the code below can
1577 * handle the leading zeros this generates, so no attempt
1578 * is made to correct that here.
1582 int czero
, clead
, cdigits
;
1585 /* Allow up to two leading zeros - this will not lengthen
1586 * the number compared to using E-n.
1588 if (exp_b10
< 0 && exp_b10
> -3) /* PLUS 3 TOTAL 4 */
1590 czero
= -exp_b10
; /* PLUS 2 digits: TOTAL 3 */
1591 exp_b10
= 0; /* Dot added below before first output. */
1594 czero
= 0; /* No zeros to add */
1596 /* Generate the digit list, stripping trailing zeros and
1597 * inserting a '.' before a digit if the exponent is 0.
1599 clead
= czero
; /* Count of leading zeros */
1600 cdigits
= 0; /* Count of digits in list. */
1608 /* Use modf here, not floor and subtract, so that
1609 * the separation is done in one step. At the end
1610 * of the loop don't break the number into parts so
1611 * that the final digit is rounded.
1613 if (cdigits
+czero
-clead
+1 < (int)precision
)
1622 /* Rounding up to 10, handle that here. */
1626 if (cdigits
== 0) --clead
;
1631 while (cdigits
> 0 && d
> 9.0)
1635 if (exp_b10
!= (-1))
1640 ch
= *--ascii
, ++size
;
1641 /* Advance exp_b10 to '1', so that the
1642 * decimal point happens after the
1649 d
= ch
- 47; /* I.e. 1+(ch-48) */
1652 /* Did we reach the beginning? If so adjust the
1653 * exponent but take into account the leading
1656 if (d
> 9.0) /* cdigits == 0 */
1658 if (exp_b10
== (-1))
1660 /* Leading decimal point (plus zeros?), if
1661 * we lose the decimal point here it must
1662 * be reentered below.
1667 ++size
, exp_b10
= 1;
1669 /* Else lost a leading zero, so 'exp_b10' is
1676 /* In all cases we output a '1' */
1681 fp
= 0; /* Guarantees termination below. */
1687 if (cdigits
== 0) ++clead
;
1692 /* Included embedded zeros in the digit count. */
1693 cdigits
+= czero
- clead
;
1698 /* exp_b10 == (-1) means we just output the decimal
1699 * place - after the DP don't adjust 'exp_b10' any
1702 if (exp_b10
!= (-1))
1704 if (exp_b10
== 0) *ascii
++ = 46, --size
;
1705 /* PLUS 1: TOTAL 4 */
1708 *ascii
++ = 48, --czero
;
1711 if (exp_b10
!= (-1))
1713 if (exp_b10
== 0) *ascii
++ = 46, --size
; /* counted
1718 *ascii
++ = (char)(48 + (int)d
), ++cdigits
;
1721 while (cdigits
+czero
-clead
< (int)precision
&& fp
> DBL_MIN
);
1723 /* The total output count (max) is now 4+precision */
1725 /* Check for an exponent, if we don't need one we are
1726 * done and just need to terminate the string. At
1727 * this point exp_b10==(-1) is effectively if flag - it got
1728 * to '-1' because of the decrement after outputing
1729 * the decimal point above (the exponent required is
1732 if (exp_b10
>= (-1) && exp_b10
<= 2)
1734 /* The following only happens if we didn't output the
1735 * leading zeros above for negative exponent, so this
1736 * doest add to the digit requirement. Note that the
1737 * two zeros here can only be output if the two leading
1738 * zeros were *not* output, so this doesn't increase
1741 while (--exp_b10
>= 0) *ascii
++ = 48;
1745 /* Total buffer requirement (including the '\0') is
1746 * 5+precision - see check at the start.
1751 /* Here if an exponent is required, adjust size for
1752 * the digits we output but did not count. The total
1753 * digit output here so far is at most 1+precision - no
1754 * decimal point and no leading or trailing zeros have
1759 *ascii
++ = 69, --size
; /* 'E': PLUS 1 TOTAL 2+precision */
1761 /* The following use of an unsigned temporary avoids ambiguities in
1762 * the signed arithmetic on exp_b10 and permits GCC at least to do
1763 * better optimization.
1766 unsigned int uexp_b10
;
1770 *ascii
++ = 45, --size
; /* '-': PLUS 1 TOTAL 3+precision */
1771 uexp_b10
= -exp_b10
;
1779 while (uexp_b10
> 0)
1781 exponent
[cdigits
++] = (char)(48 + uexp_b10
% 10);
1786 /* Need another size check here for the exponent digits, so
1787 * this need not be considered above.
1789 if ((int)size
> cdigits
)
1791 while (cdigits
> 0) *ascii
++ = exponent
[--cdigits
];
1799 else if (!(fp
>= DBL_MIN
))
1801 *ascii
++ = 48; /* '0' */
1807 *ascii
++ = 105; /* 'i' */
1808 *ascii
++ = 110; /* 'n' */
1809 *ascii
++ = 102; /* 'f' */
1815 /* Here on buffer too small. */
1816 png_error(png_ptr
, "ASCII conversion buffer too small");
1819 # endif /* FLOATING_POINT */
1821 # ifdef PNG_FIXED_POINT_SUPPORTED
1822 /* Function to format a fixed point value in ASCII.
1825 png_ascii_from_fixed(png_structp png_ptr
, png_charp ascii
, png_size_t size
,
1828 /* Require space for 10 decimal digits, a decimal point, a minus sign and a
1829 * trailing \0, 13 characters:
1835 /* Avoid overflow here on the minimum integer. */
1837 *ascii
++ = 45, --size
, num
= -fp
;
1841 if (num
<= 0x80000000) /* else overflowed */
1843 unsigned int ndigits
= 0, first
= 16 /* flag value */;
1848 /* Split the low digit off num: */
1849 unsigned int tmp
= num
/10;
1851 digits
[ndigits
++] = (char)(48 + num
);
1852 /* Record the first non-zero digit, note that this is a number
1853 * starting at 1, it's not actually the array index.
1855 if (first
== 16 && num
> 0)
1862 while (ndigits
> 5) *ascii
++ = digits
[--ndigits
];
1863 /* The remaining digits are fractional digits, ndigits is '5' or
1864 * smaller at this point. It is certainly not zero. Check for a
1865 * non-zero fractional digit:
1870 *ascii
++ = 46; /* decimal point */
1871 /* ndigits may be <5 for small numbers, output leading zeros
1872 * then ndigits digits to first:
1875 while (ndigits
< i
) *ascii
++ = 48, --i
;
1876 while (ndigits
>= first
) *ascii
++ = digits
[--ndigits
];
1877 /* Don't output the trailing zeros! */
1883 /* And null terminate the string: */
1889 /* Here on buffer too small. */
1890 png_error(png_ptr
, "ASCII conversion buffer too small");
1892 # endif /* FIXED_POINT */
1893 #endif /* READ_SCAL */
1895 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
1896 !defined(PNG_FIXED_POINT_MACRO_SUPPORTED)
1898 png_fixed(png_structp png_ptr
, double fp
, png_const_charp text
)
1900 double r
= floor(100000 * fp
+ .5);
1902 if (r
> 2147483647. || r
< -2147483648.)
1903 png_fixed_error(png_ptr
, text
);
1905 return (png_fixed_point
)r
;
1909 #if defined(PNG_READ_GAMMA_SUPPORTED) || \
1910 defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED)
1911 /* muldiv functions */
1912 /* This API takes signed arguments and rounds the result to the nearest
1913 * integer (or, for a fixed point number - the standard argument - to
1914 * the nearest .00001). Overflow and divide by zero are signalled in
1915 * the result, a boolean - true on success, false on overflow.
1918 png_muldiv(png_fixed_point_p res
, png_fixed_point a
, png_int_32 times
,
1921 /* Return a * times / divisor, rounded. */
1924 if (a
== 0 || times
== 0)
1931 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
1937 /* A png_fixed_point is a 32-bit integer. */
1938 if (r
<= 2147483647. && r
>= -2147483648.)
1940 *res
= (png_fixed_point
)r
;
1945 png_uint_32 A
, T
, D
;
1946 png_uint_32 s16
, s32
, s00
;
1949 negative
= 1, A
= -a
;
1954 negative
= !negative
, T
= -times
;
1959 negative
= !negative
, D
= -divisor
;
1963 /* Following can't overflow because the arguments only
1964 * have 31 bits each, however the result may be 32 bits.
1966 s16
= (A
>> 16) * (T
& 0xffff) +
1967 (A
& 0xffff) * (T
>> 16);
1968 /* Can't overflow because the a*times bit is only 30
1971 s32
= (A
>> 16) * (T
>> 16) + (s16
>> 16);
1972 s00
= (A
& 0xffff) * (T
& 0xffff);
1974 s16
= (s16
& 0xffff) << 16;
1980 if (s32
< D
) /* else overflow */
1982 /* s32.s00 is now the 64-bit product, do a standard
1983 * division, we know that s32 < D, so the maximum
1984 * required shift is 31.
1987 png_fixed_point result
= 0; /* NOTE: signed */
1989 while (--bitshift
>= 0)
1991 png_uint_32 d32
, d00
;
1994 d32
= D
>> (32-bitshift
), d00
= D
<< bitshift
;
2001 if (s00
< d00
) --s32
; /* carry */
2002 s32
-= d32
, s00
-= d00
, result
+= 1<<bitshift
;
2006 if (s32
== d32
&& s00
>= d00
)
2007 s32
= 0, s00
-= d00
, result
+= 1<<bitshift
;
2010 /* Handle the rounding. */
2011 if (s00
>= (D
>> 1))
2017 /* Check for overflow. */
2018 if ((negative
&& result
<= 0) || (!negative
&& result
>= 0))
2030 #endif /* READ_GAMMA || INCH_CONVERSIONS */
2032 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
2033 /* The following is for when the caller doesn't much care about the
2037 png_muldiv_warn(png_structp png_ptr
, png_fixed_point a
, png_int_32 times
,
2040 png_fixed_point result
;
2042 if (png_muldiv(&result
, a
, times
, divisor
))
2045 png_warning(png_ptr
, "fixed point overflow ignored");
2050 #if (defined PNG_READ_GAMMA_SUPPORTED) || (defined PNG_cHRM_SUPPORTED)
2051 /* more fixed point functions for gamma and cHRM (xy/XYZ) suport. */
2052 /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
2054 png_reciprocal(png_fixed_point a
)
2056 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2057 double r
= floor(1E10
/a
+.5);
2059 if (r
<= 2147483647. && r
>= -2147483648.)
2060 return (png_fixed_point
)r
;
2062 png_fixed_point res
;
2064 if (png_muldiv(&res
, 100000, 100000, a
))
2068 return 0; /* error/overflow */
2071 #ifdef PNG_READ_GAMMA_SUPPORTED
2072 /* A local convenience routine. */
2073 static png_fixed_point
2074 png_product2(png_fixed_point a
, png_fixed_point b
)
2076 /* The required result is 1/a * 1/b; the following preserves accuracy. */
2077 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2078 double r
= a
* 1E-5;
2082 if (r
<= 2147483647. && r
>= -2147483648.)
2083 return (png_fixed_point
)r
;
2085 png_fixed_point res
;
2087 if (png_muldiv(&res
, a
, b
, 100000))
2091 return 0; /* overflow */
2093 #endif /* READ_GAMMA */
2095 /* The inverse of the above. */
2097 png_reciprocal2(png_fixed_point a
, png_fixed_point b
)
2099 /* The required result is 1/a * 1/b; the following preserves accuracy. */
2100 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2105 if (r
<= 2147483647. && r
>= -2147483648.)
2106 return (png_fixed_point
)r
;
2108 /* This may overflow because the range of png_fixed_point isn't symmetric,
2109 * but this API is only used for the product of file and screen gamma so it
2110 * doesn't matter that the smallest number it can produce is 1/21474, not
2113 png_fixed_point res
= png_product2(a
, b
);
2116 return png_reciprocal(res
);
2119 return 0; /* overflow */
2121 #endif /* READ_GAMMA || cHRM */
2123 #ifdef PNG_CHECK_cHRM_SUPPORTED
2124 /* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2,
2125 * 2010: moved from pngset.c) */
2127 * Multiply two 32-bit numbers, V1 and V2, using 32-bit
2128 * arithmetic, to produce a 64-bit result in the HI/LO words.
2136 * where A and B are the high and low 16-bit words of V1,
2137 * C and D are the 16-bit words of V2, AD is the product of
2138 * A and D, and X || Y is (X << 16) + Y.
2142 png_64bit_product (long v1
, long v2
, unsigned long *hi_product
,
2143 unsigned long *lo_product
)
2148 a
= (v1
>> 16) & 0xffff;
2150 c
= (v2
>> 16) & 0xffff;
2153 lo
= b
* d
; /* BD */
2154 x
= a
* d
+ c
* b
; /* AD + CB */
2155 y
= ((lo
>> 16) & 0xffff) + x
;
2157 lo
= (lo
& 0xffff) | ((y
& 0xffff) << 16);
2158 hi
= (y
>> 16) & 0xffff;
2160 hi
+= a
* c
; /* AC */
2162 *hi_product
= (unsigned long)hi
;
2163 *lo_product
= (unsigned long)lo
;
2165 #endif /* CHECK_cHRM */
2167 #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
2168 #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
2169 /* Fixed point gamma.
2171 * To calculate gamma this code implements fast log() and exp() calls using only
2172 * fixed point arithmetic. This code has sufficient precision for either 8-bit
2173 * or 16-bit sample values.
2175 * The tables used here were calculated using simple 'bc' programs, but C double
2176 * precision floating point arithmetic would work fine. The programs are given
2177 * at the head of each table.
2180 * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
2181 * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
2182 * mantissa. The numbers are 32-bit fractions.
2188 for (i
=128;i
<256;++i
) { .5 - l(i
/255)/l(2)*65536*65536; }
2190 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
2191 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
2192 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
2193 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
2194 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
2195 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
2196 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
2197 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
2198 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
2199 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
2200 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
2201 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
2202 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
2203 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
2204 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
2205 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
2206 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
2207 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
2208 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
2209 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
2210 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
2215 /* The following are the values for 16-bit tables - these work fine for the
2216 * 8-bit conversions but produce very slightly larger errors in the 16-bit
2217 * log (about 1.2 as opposed to 0.7 absolute error in the final value). To
2218 * use these all the shifts below must be adjusted appropriately.
2220 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
2221 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
2222 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
2223 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
2224 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
2225 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
2226 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
2227 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
2228 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
2229 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
2230 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
2235 PNG_STATIC png_int_32
2236 png_log8bit(unsigned int x
)
2238 unsigned int lg2
= 0;
2239 /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
2240 * because the log is actually negate that means adding 1. The final
2241 * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
2242 * input), return 7.99998 for the overflow (log 0) case - so the result is
2243 * always at most 19 bits.
2245 if ((x
&= 0xff) == 0)
2248 if ((x
& 0xf0) == 0)
2251 if ((x
& 0xc0) == 0)
2254 if ((x
& 0x80) == 0)
2257 /* result is at most 19 bits, so this cast is safe: */
2258 return (png_int_32
)((lg2
<< 16) + ((png_8bit_l2
[x
-128]+32768)>>16));
2261 /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
2262 * for 16-bit images we use the most significant 8 bits of the 16-bit value to
2263 * get an approximation then multiply the approximation by a correction factor
2264 * determined by the remaining up to 8 bits. This requires an additional step
2265 * in the 16-bit case.
2267 * We want log2(value/65535), we have log2(v'/255), where:
2269 * value = v' * 256 + v''
2272 * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
2273 * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
2274 * than 258. The final factor also needs to correct for the fact that our 8-bit
2275 * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
2277 * This gives a final formula using a calculated value 'x' which is value/v' and
2278 * scaling by 65536 to match the above table:
2280 * log2(x/257) * 65536
2282 * Since these numbers are so close to '1' we can use simple linear
2283 * interpolation between the two end values 256/257 (result -368.61) and 258/257
2284 * (result 367.179). The values used below are scaled by a further 64 to give
2285 * 16-bit precision in the interpolation:
2287 * Start (256): -23591
2291 PNG_STATIC png_int_32
2292 png_log16bit(png_uint_32 x
)
2294 unsigned int lg2
= 0;
2296 /* As above, but now the input has 16 bits. */
2297 if ((x
&= 0xffff) == 0)
2300 if ((x
& 0xff00) == 0)
2303 if ((x
& 0xf000) == 0)
2306 if ((x
& 0xc000) == 0)
2309 if ((x
& 0x8000) == 0)
2312 /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
2316 lg2
+= (png_8bit_l2
[(x
>>8)-128]+8) >> 4;
2318 /* Now we need to interpolate the factor, this requires a division by the top
2319 * 8 bits. Do this with maximum precision.
2321 x
= ((x
<< 16) + (x
>> 9)) / (x
>> 8);
2323 /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
2324 * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
2325 * 16 bits to interpolate to get the low bits of the result. Round the
2326 * answer. Note that the end point values are scaled by 64 to retain overall
2327 * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
2328 * the overall scaling by 6-12. Round at every step.
2332 if (x
<= 65536U) /* <= '257' */
2333 lg2
+= ((23591U * (65536U-x
)) + (1U << (16+6-12-1))) >> (16+6-12);
2336 lg2
-= ((23499U * (x
-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
2338 /* Safe, because the result can't have more than 20 bits: */
2339 return (png_int_32
)((lg2
+ 2048) >> 12);
2342 /* The 'exp()' case must invert the above, taking a 20-bit fixed point
2343 * logarithmic value and returning a 16 or 8-bit number as appropriate. In
2344 * each case only the low 16 bits are relevant - the fraction - since the
2345 * integer bits (the top 4) simply determine a shift.
2347 * The worst case is the 16-bit distinction between 65535 and 65534, this
2348 * requires perhaps spurious accuracy in the decoding of the logarithm to
2349 * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
2350 * of getting this accuracy in practice.
2352 * To deal with this the following exp() function works out the exponent of the
2353 * frational part of the logarithm by using an accurate 32-bit value from the
2354 * top four fractional bits then multiplying in the remaining bits.
2360 for (i
=0;i
<16;++i
) { .5 + e(-i
/16*l(2))*2^32; }
2362 /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
2363 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
2364 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
2365 2553802834U, 2445529972U, 2341847524U, 2242560872U
2369 /* Adjustment table; provided to explain the numbers in the code below. */
2371 for (i
=11;i
>=0;--i
){ print i
, " ", (1 - e(-(2^i
)/65536*l(2))) * 2^(32-i
), "\n"}
2372 11 44937.64284865548751208448
2373 10 45180.98734845585101160448
2374 9 45303.31936980687359311872
2375 8 45364.65110595323018870784
2376 7 45395.35850361789624614912
2377 6 45410.72259715102037508096
2378 5 45418.40724413220722311168
2379 4 45422.25021786898173001728
2380 3 45424.17186732298419044352
2381 2 45425.13273269940811464704
2382 1 45425.61317555035558641664
2383 0 45425.85339951654943850496
2386 PNG_STATIC png_uint_32
2387 png_exp(png_fixed_point x
)
2389 if (x
> 0 && x
<= 0xfffff) /* Else overflow or zero (underflow) */
2391 /* Obtain a 4-bit approximation */
2392 png_uint_32 e
= png_32bit_exp
[(x
>> 12) & 0xf];
2394 /* Incorporate the low 12 bits - these decrease the returned value by
2395 * multiplying by a number less than 1 if the bit is set. The multiplier
2396 * is determined by the above table and the shift. Notice that the values
2397 * converge on 45426 and this is used to allow linear interpolation of the
2401 e
-= (((e
>> 16) * 44938U) + 16U) >> 5;
2404 e
-= (((e
>> 16) * 45181U) + 32U) >> 6;
2407 e
-= (((e
>> 16) * 45303U) + 64U) >> 7;
2410 e
-= (((e
>> 16) * 45365U) + 128U) >> 8;
2413 e
-= (((e
>> 16) * 45395U) + 256U) >> 9;
2416 e
-= (((e
>> 16) * 45410U) + 512U) >> 10;
2418 /* And handle the low 6 bits in a single block. */
2419 e
-= (((e
>> 16) * 355U * (x
& 0x3fU
)) + 256U) >> 9;
2421 /* Handle the upper bits of x. */
2426 /* Check for overflow */
2428 return png_32bit_exp
[0];
2430 /* Else underflow */
2435 png_exp8bit(png_fixed_point lg2
)
2437 /* Get a 32-bit value: */
2438 png_uint_32 x
= png_exp(lg2
);
2440 /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the
2441 * second, rounding, step can't overflow because of the first, subtraction,
2445 return (png_byte
)((x
+ 0x7fffffU
) >> 24);
2448 PNG_STATIC png_uint_16
2449 png_exp16bit(png_fixed_point lg2
)
2451 /* Get a 32-bit value: */
2452 png_uint_32 x
= png_exp(lg2
);
2454 /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
2456 return (png_uint_16
)((x
+ 32767U) >> 16);
2458 #endif /* FLOATING_ARITHMETIC */
2461 png_gamma_8bit_correct(unsigned int value
, png_fixed_point gamma_val
)
2463 if (value
> 0 && value
< 255)
2465 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2466 double r
= floor(255*pow(value
/255.,gamma_val
*.00001)+.5);
2469 png_int_32 lg2
= png_log8bit(value
);
2470 png_fixed_point res
;
2472 if (png_muldiv(&res
, gamma_val
, lg2
, PNG_FP_1
))
2473 return png_exp8bit(res
);
2480 return (png_byte
)value
;
2484 png_gamma_16bit_correct(unsigned int value
, png_fixed_point gamma_val
)
2486 if (value
> 0 && value
< 65535)
2488 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2489 double r
= floor(65535*pow(value
/65535.,gamma_val
*.00001)+.5);
2490 return (png_uint_16
)r
;
2492 png_int_32 lg2
= png_log16bit(value
);
2493 png_fixed_point res
;
2495 if (png_muldiv(&res
, gamma_val
, lg2
, PNG_FP_1
))
2496 return png_exp16bit(res
);
2503 return (png_uint_16
)value
;
2506 /* This does the right thing based on the bit_depth field of the
2507 * png_struct, interpreting values as 8-bit or 16-bit. While the result
2508 * is nominally a 16-bit value if bit depth is 8 then the result is
2509 * 8-bit (as are the arguments.)
2511 png_uint_16
/* PRIVATE */
2512 png_gamma_correct(png_structp png_ptr
, unsigned int value
,
2513 png_fixed_point gamma_val
)
2515 if (png_ptr
->bit_depth
== 8)
2516 return png_gamma_8bit_correct(value
, gamma_val
);
2519 return png_gamma_16bit_correct(value
, gamma_val
);
2522 /* This is the shared test on whether a gamma value is 'significant' - whether
2523 * it is worth doing gamma correction.
2526 png_gamma_significant(png_fixed_point gamma_val
)
2528 return gamma_val
< PNG_FP_1
- PNG_GAMMA_THRESHOLD_FIXED
||
2529 gamma_val
> PNG_FP_1
+ PNG_GAMMA_THRESHOLD_FIXED
;
2532 /* Internal function to build a single 16-bit table - the table consists of
2533 * 'num' 256-entry subtables, where 'num' is determined by 'shift' - the amount
2534 * to shift the input values right (or 16-number_of_signifiant_bits).
2536 * The caller is responsible for ensuring that the table gets cleaned up on
2537 * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
2538 * should be somewhere that will be cleaned.
2541 png_build_16bit_table(png_structp png_ptr
, png_uint_16pp
*ptable
,
2542 PNG_CONST
unsigned int shift
, PNG_CONST png_fixed_point gamma_val
)
2544 /* Various values derived from 'shift': */
2545 PNG_CONST
unsigned int num
= 1U << (8U - shift
);
2546 PNG_CONST
unsigned int max
= (1U << (16U - shift
))-1U;
2547 PNG_CONST
unsigned int max_by_2
= 1U << (15U-shift
);
2550 png_uint_16pp table
= *ptable
=
2551 (png_uint_16pp
)png_calloc(png_ptr
, num
* png_sizeof(png_uint_16p
));
2553 for (i
= 0; i
< num
; i
++)
2555 png_uint_16p sub_table
= table
[i
] =
2556 (png_uint_16p
)png_malloc(png_ptr
, 256 * png_sizeof(png_uint_16
));
2558 /* The 'threshold' test is repeated here because it can arise for one of
2559 * the 16-bit tables even if the others don't hit it.
2561 if (png_gamma_significant(gamma_val
))
2563 /* The old code would overflow at the end and this would cause the
2564 * 'pow' function to return a result >1, resulting in an
2565 * arithmetic error. This code follows the spec exactly; ig is
2566 * the recovered input sample, it always has 8-16 bits.
2568 * We want input * 65535/max, rounded, the arithmetic fits in 32
2569 * bits (unsigned) so long as max <= 32767.
2572 for (j
= 0; j
< 256; j
++)
2574 png_uint_32 ig
= (j
<< (8-shift
)) + i
;
2575 # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
2576 /* Inline the 'max' scaling operation: */
2577 double d
= floor(65535*pow(ig
/(double)max
, gamma_val
*.00001)+.5);
2578 sub_table
[j
] = (png_uint_16
)d
;
2581 ig
= (ig
* 65535U + max_by_2
)/max
;
2583 sub_table
[j
] = png_gamma_16bit_correct(ig
, gamma_val
);
2589 /* We must still build a table, but do it the fast way. */
2592 for (j
= 0; j
< 256; j
++)
2594 png_uint_32 ig
= (j
<< (8-shift
)) + i
;
2597 ig
= (ig
* 65535U + max_by_2
)/max
;
2599 sub_table
[j
] = (png_uint_16
)ig
;
2605 /* NOTE: this function expects the *inverse* of the overall gamma transformation
2609 png_build_16to8_table(png_structp png_ptr
, png_uint_16pp
*ptable
,
2610 PNG_CONST
unsigned int shift
, PNG_CONST png_fixed_point gamma_val
)
2612 PNG_CONST
unsigned int num
= 1U << (8U - shift
);
2613 PNG_CONST
unsigned int max
= (1U << (16U - shift
))-1U;
2617 png_uint_16pp table
= *ptable
=
2618 (png_uint_16pp
)png_calloc(png_ptr
, num
* png_sizeof(png_uint_16p
));
2620 /* 'num' is the number of tables and also the number of low bits of the
2621 * input 16-bit value used to select a table. Each table is itself indexed
2622 * by the high 8 bits of the value.
2624 for (i
= 0; i
< num
; i
++)
2625 table
[i
] = (png_uint_16p
)png_malloc(png_ptr
,
2626 256 * png_sizeof(png_uint_16
));
2628 /* 'gamma_val' is set to the reciprocal of the value calculated above, so
2629 * pow(out,g) is an *input* value. 'last' is the last input value set.
2631 * In the loop 'i' is used to find output values. Since the output is
2632 * 8-bit there are only 256 possible values. The tables are set up to
2633 * select the closest possible output value for each input by finding
2634 * the input value at the boundary between each pair of output values
2635 * and filling the table up to that boundary with the lower output
2638 * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit
2639 * values the code below uses a 16-bit value in i; the values start at
2640 * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
2641 * entries are filled with 255). Start i at 128 and fill all 'last'
2642 * table entries <= 'max'
2645 for (i
= 0; i
< 255; ++i
) /* 8-bit output value */
2647 /* Find the corresponding maximum input value */
2648 png_uint_16 out
= (png_uint_16
)(i
* 257U); /* 16-bit output value */
2650 /* Find the boundary value in 16 bits: */
2651 png_uint_32 bound
= png_gamma_16bit_correct(out
+128U, gamma_val
);
2653 /* Adjust (round) to (16-shift) bits: */
2654 bound
= (bound
* max
+ 32768U)/65535U + 1U;
2656 while (last
< bound
)
2658 table
[last
& (0xffU
>> shift
)][last
>> (8U - shift
)] = out
;
2663 /* And fill in the final entries. */
2664 while (last
< (num
<< 8))
2666 table
[last
& (0xff >> shift
)][last
>> (8U - shift
)] = 65535U;
2671 /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
2672 * typically much faster). Note that libpng currently does no sBIT processing
2673 * (apparently contrary to the spec) so a 256-entry table is always generated.
2676 png_build_8bit_table(png_structp png_ptr
, png_bytepp ptable
,
2677 PNG_CONST png_fixed_point gamma_val
)
2680 png_bytep table
= *ptable
= (png_bytep
)png_malloc(png_ptr
, 256);
2682 if (png_gamma_significant(gamma_val
)) for (i
=0; i
<256; i
++)
2683 table
[i
] = png_gamma_8bit_correct(i
, gamma_val
);
2685 else for (i
=0; i
<256; ++i
)
2686 table
[i
] = (png_byte
)i
;
2689 /* Used from png_read_destroy and below to release the memory used by the gamma
2693 png_destroy_gamma_table(png_structp png_ptr
)
2695 png_free(png_ptr
, png_ptr
->gamma_table
);
2696 png_ptr
->gamma_table
= NULL
;
2698 if (png_ptr
->gamma_16_table
!= NULL
)
2701 int istop
= (1 << (8 - png_ptr
->gamma_shift
));
2702 for (i
= 0; i
< istop
; i
++)
2704 png_free(png_ptr
, png_ptr
->gamma_16_table
[i
]);
2706 png_free(png_ptr
, png_ptr
->gamma_16_table
);
2707 png_ptr
->gamma_16_table
= NULL
;
2710 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
2711 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
2712 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2713 png_free(png_ptr
, png_ptr
->gamma_from_1
);
2714 png_ptr
->gamma_from_1
= NULL
;
2715 png_free(png_ptr
, png_ptr
->gamma_to_1
);
2716 png_ptr
->gamma_to_1
= NULL
;
2718 if (png_ptr
->gamma_16_from_1
!= NULL
)
2721 int istop
= (1 << (8 - png_ptr
->gamma_shift
));
2722 for (i
= 0; i
< istop
; i
++)
2724 png_free(png_ptr
, png_ptr
->gamma_16_from_1
[i
]);
2726 png_free(png_ptr
, png_ptr
->gamma_16_from_1
);
2727 png_ptr
->gamma_16_from_1
= NULL
;
2729 if (png_ptr
->gamma_16_to_1
!= NULL
)
2732 int istop
= (1 << (8 - png_ptr
->gamma_shift
));
2733 for (i
= 0; i
< istop
; i
++)
2735 png_free(png_ptr
, png_ptr
->gamma_16_to_1
[i
]);
2737 png_free(png_ptr
, png_ptr
->gamma_16_to_1
);
2738 png_ptr
->gamma_16_to_1
= NULL
;
2740 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
2743 /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
2744 * tables, we don't make a full table if we are reducing to 8-bit in
2745 * the future. Note also how the gamma_16 tables are segmented so that
2746 * we don't need to allocate > 64K chunks for a full 16-bit table.
2749 png_build_gamma_table(png_structp png_ptr
, int bit_depth
)
2751 png_debug(1, "in png_build_gamma_table");
2753 /* Remove any existing table; this copes with multiple calls to
2754 * png_read_update_info. The warning is because building the gamma tables
2755 * multiple times is a performance hit - it's harmless but the ability to call
2756 * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
2757 * to warn if the app introduces such a hit.
2759 if (png_ptr
->gamma_table
!= NULL
|| png_ptr
->gamma_16_table
!= NULL
)
2761 png_warning(png_ptr
, "gamma table being rebuilt");
2762 png_destroy_gamma_table(png_ptr
);
2767 png_build_8bit_table(png_ptr
, &png_ptr
->gamma_table
,
2768 png_ptr
->screen_gamma
> 0 ? png_reciprocal2(png_ptr
->gamma
,
2769 png_ptr
->screen_gamma
) : PNG_FP_1
);
2771 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
2772 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
2773 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2774 if (png_ptr
->transformations
& (PNG_COMPOSE
| PNG_RGB_TO_GRAY
))
2776 png_build_8bit_table(png_ptr
, &png_ptr
->gamma_to_1
,
2777 png_reciprocal(png_ptr
->gamma
));
2779 png_build_8bit_table(png_ptr
, &png_ptr
->gamma_from_1
,
2780 png_ptr
->screen_gamma
> 0 ? png_reciprocal(png_ptr
->screen_gamma
) :
2781 png_ptr
->gamma
/* Probably doing rgb_to_gray */);
2783 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
2787 png_byte shift
, sig_bit
;
2789 if (png_ptr
->color_type
& PNG_COLOR_MASK_COLOR
)
2791 sig_bit
= png_ptr
->sig_bit
.red
;
2793 if (png_ptr
->sig_bit
.green
> sig_bit
)
2794 sig_bit
= png_ptr
->sig_bit
.green
;
2796 if (png_ptr
->sig_bit
.blue
> sig_bit
)
2797 sig_bit
= png_ptr
->sig_bit
.blue
;
2800 sig_bit
= png_ptr
->sig_bit
.gray
;
2802 /* 16-bit gamma code uses this equation:
2804 * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
2806 * Where 'iv' is the input color value and 'ov' is the output value -
2809 * Thus the gamma table consists of up to 256 256-entry tables. The table
2810 * is selected by the (8-gamma_shift) most significant of the low 8 bits of
2811 * the color value then indexed by the upper 8 bits:
2813 * table[low bits][high 8 bits]
2815 * So the table 'n' corresponds to all those 'iv' of:
2817 * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
2820 if (sig_bit
> 0 && sig_bit
< 16U)
2821 shift
= (png_byte
)(16U - sig_bit
); /* shift == insignificant bits */
2824 shift
= 0; /* keep all 16 bits */
2826 if (png_ptr
->transformations
& (PNG_16_TO_8
| PNG_SCALE_16_TO_8
))
2828 /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
2829 * the significant bits in the *input* when the output will
2830 * eventually be 8 bits. By default it is 11.
2832 if (shift
< (16U - PNG_MAX_GAMMA_8
))
2833 shift
= (16U - PNG_MAX_GAMMA_8
);
2837 shift
= 8U; /* Guarantees at least one table! */
2839 png_ptr
->gamma_shift
= shift
;
2841 #ifdef PNG_16BIT_SUPPORTED
2842 /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
2843 * PNG_COMPOSE). This effectively smashed the background calculation for
2844 * 16-bit output because the 8-bit table assumes the result will be reduced
2847 if (png_ptr
->transformations
& (PNG_16_TO_8
| PNG_SCALE_16_TO_8
))
2849 png_build_16to8_table(png_ptr
, &png_ptr
->gamma_16_table
, shift
,
2850 png_ptr
->screen_gamma
> 0 ? png_product2(png_ptr
->gamma
,
2851 png_ptr
->screen_gamma
) : PNG_FP_1
);
2853 #ifdef PNG_16BIT_SUPPORTED
2855 png_build_16bit_table(png_ptr
, &png_ptr
->gamma_16_table
, shift
,
2856 png_ptr
->screen_gamma
> 0 ? png_reciprocal2(png_ptr
->gamma
,
2857 png_ptr
->screen_gamma
) : PNG_FP_1
);
2860 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
2861 defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
2862 defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
2863 if (png_ptr
->transformations
& (PNG_COMPOSE
| PNG_RGB_TO_GRAY
))
2865 png_build_16bit_table(png_ptr
, &png_ptr
->gamma_16_to_1
, shift
,
2866 png_reciprocal(png_ptr
->gamma
));
2868 /* Notice that the '16 from 1' table should be full precision, however
2869 * the lookup on this table still uses gamma_shift, so it can't be.
2872 png_build_16bit_table(png_ptr
, &png_ptr
->gamma_16_from_1
, shift
,
2873 png_ptr
->screen_gamma
> 0 ? png_reciprocal(png_ptr
->screen_gamma
) :
2874 png_ptr
->gamma
/* Probably doing rgb_to_gray */);
2876 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
2879 #endif /* READ_GAMMA */
2880 #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */