/programs/develop/libraries/libpng/symbols.def |
---|
File deleted |
/programs/develop/libraries/libpng/Makefile |
---|
1,28 → 1,32 |
LIBRARY= libpng |
LIBRARY= libpng16 |
CC=gcc |
CPP=gcc -E |
AR= ar rc |
CFLAGS = -U_Win32 -U_WIN32 -U__MINGW32__ -c -O2 -fomit-frame-pointer |
CFLAGS = -c -O2 -fomit-frame-pointer |
LD = ld |
LDIMPORT:= -nostdlib --out-implib libpngimp.a |
AR= ar |
LDFLAGS:= -shared -s -T../newlib/dll.lds --image-base 0 |
STRIP = $(PREFIX)strip |
LDFLAGS:= -shared -s -nostdlib -T ../newlib/dll.lds --entry _DllStartup --image-base=0 --out-implib libpng.dll.a |
INCLUDES= -I. -I../newlib/include -I../zlib |
LIBPATH:= -L../newlib -L../zlib |
LIBS:= -ldll -lc.dll -lz.dll |
DEFS = -DHAVE_CONFIG_H |
LIBPNG_DEFINES = -DPNG_CONFIGURE_LIBPNG |
DEFINES= $(DEFS) $(LIBPNG_DEFINES) |
INCLUDES= -I../newlib/include -I../zlib |
LIBPATH:= -L../newlib -L../zlib |
LIBS:= -lamz -lgcc -lzimp -lcimp |
SOURCES = png.c pngerror.c pngget.c pngmem.c pngpread.c \ |
pngread.c pngrio.c pngrtran.c pngrutil.c \ |
pngset.c pngtrans.c pngwio.c pngwrite.c \ |
41,8 → 45,11 |
$(LIBRARY).a: $(OBJECTS) Makefile |
ar cvrs $(LIBRARY).a $(OBJECTS) |
$(LIBRARY).dll: $(OBJECTS) Makefile |
ld $(LDFLAGS) $(LDIMPORT) $(LIBPATH) -o $@ $(OBJECTS) $(LIBS) symbols.def |
$(LIBRARY).dll: libpng16.def $(OBJECTS) Makefile |
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ libpng16.def $(OBJECTS) $(LIBS) |
$(STRIP) $@ |
sed -f ../newlib/cmd1.sed libpng16.def > mem |
sed -f ../newlib/cmd2.sed mem >libpng.inc |
%.o : %.c Makefile |
$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -o $@ $< |
/programs/develop/libraries/libpng/README |
---|
1,11 → 1,11 |
README for libpng version 1.5.1 - February 3, 2011 (shared library 15.0) |
README for libpng version 1.6.5 - September 14, 2013 (shared library 16.0) |
See the note about version numbers near the top of png.h |
See INSTALL for instructions on how to install libpng. |
Libpng comes in several distribution formats. Get libpng-*.tar.gz, |
libpng-*.tar.xz or libpng-*.tar.bz2 if you want UNIX-style line endings |
in the text files, or lpng*.zip if you want DOS-style line endings. |
Libpng comes in several distribution formats. Get libpng-*.tar.gz or |
libpng-*.tar.xz or if you want UNIX-style line endings in the text files, |
or lpng*.7z or lpng*.zip if you want DOS-style line endings. |
Version 0.89 was the first official release of libpng. Don't let the |
fact that it's the first release fool you. The libpng library has been in |
77,8 → 77,7 |
You can use zlib as a drop-in replacement for fread() and fwrite() if |
you are so inclined. |
zlib should be available at the same place that libpng is, or at. |
ftp://ftp.info-zip.org/pub/infozip/zlib |
zlib should be available at the same place that libpng is, or at zlib.net. |
You may also want a copy of the PNG specification. It is available |
as an RFC, a W3C Recommendation, and an ISO/IEC Standard. You can find |
85,9 → 84,8 |
these at http://www.libpng.org/pub/png/documents/ |
This code is currently being archived at libpng.sf.net in the |
[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT) |
at GO GRAPHSUP. If you can't find it in any of those places, |
e-mail me, and I'll help you find it. |
[DOWNLOAD] area, and at ftp://ftp.simplesystems.org. If you can't find it |
in any of those places, e-mail me, and I'll help you find it. |
If you have any code changes, requests, problems, etc., please e-mail |
them to me. Also, I'd appreciate any make files or project files, |
114,12 → 112,9 |
read mail addressed to the png-implement list, however. |
Please do not send general questions about PNG. Send them to |
the (png-list at ccrc.wustl.edu, subscription required, write to |
majordomo at ccrc.wustl.edu with "subscribe png-list" in your message). |
On the other hand, |
please do not send libpng questions to that address, send them to me |
or to the png-implement list. I'll |
get them in the end anyway. If you have a question about something |
png-mng-misc at lists.sf.net (subscription required; visit |
https://lists.sourceforge.net/lists/listinfo/png-mng-misc to |
subscribe). If you have a question about something |
in the PNG specification that is related to using libpng, send it |
to me. Send me any questions that start with "I was using libpng, |
and ...". If in doubt, send questions to me. I'll bounce them |
126,7 → 121,7 |
to others, if necessary. |
Please do not send suggestions on how to change PNG. We have |
been discussing PNG for nine years now, and it is official and |
been discussing PNG for eighteen years now, and it is official and |
finished. If you have suggestions for libpng, however, I'll |
gladly listen. Even if your suggestion is not used immediately, |
it may be used later. |
170,23 → 165,25 |
pngwrite.c => High-level write functions |
pngwtran.c => Write data transformations |
pngwutil.c => Write utility functions |
arm => Contains optimized code for the ARM platform |
contrib => Contributions |
examples => Example programs |
gregbook => source code for PNG reading and writing, from |
Greg Roelofs' "PNG: The Definitive Guide", |
O'Reilly, 1999 |
msvctest => Builds and runs pngtest using a MSVC workspace |
libtests => Test programs |
pngminim => Minimal decoder, encoder, and progressive decoder |
programs demonstrating use of pngusr.dfa |
pngminus => Simple pnm2png and png2pnm programs |
pngsuite => Test images |
tools => Various tools |
visupng => Contains a MSVC workspace for VisualPng |
projects => Contains project files and workspaces for |
building a DLL |
cbuilder5 => Contains a Borland workspace for building |
libpng and zlib |
visualc6 => Contains a Microsoft Visual C++ (MSVC) |
workspace for building libpng and zlib |
owatcom => Contains a WATCOM project for building libpng |
visualc71 => Contains a Microsoft Visual C++ (MSVC) |
workspace for building libpng and zlib |
xcode => Contains an Apple xcode |
vstudio => Contains a Microsoft Visual C++ (MSVC) |
workspace for building libpng and zlib |
scripts => Directory containing scripts for building libpng: |
(see scripts/README.txt for the list of scripts) |
/programs/develop/libraries/libpng/config.h |
---|
2,20 → 2,20 |
/* config.h.in. Generated from configure.ac by autoheader. */ |
/* Define to 1 if you have the <dlfcn.h> header file. */ |
#define HAVE_DLFCN_H 1 |
/* #undef HAVE_DLFCN_H */ |
/* Define to 1 if you have the `feenableexcept' function. */ |
/* #undef HAVE_FEENABLEEXCEPT */ |
/* Define to 1 if you have the <inttypes.h> header file. */ |
#define HAVE_INTTYPES_H 1 |
/* Define to 1 if you have the `m' library (-lm). */ |
#define HAVE_LIBM 1 |
/* #undef HAVE_LIBM */ |
/* Define to 1 if you have the `z' library (-lz). */ |
#define HAVE_LIBZ 1 |
/* Define to 1 if you have the <malloc.h> header file. */ |
#define HAVE_MALLOC_H 1 |
/* Define to 1 if you have the <memory.h> header file. */ |
#define HAVE_MEMORY_H 1 |
23,7 → 23,7 |
#define HAVE_MEMSET 1 |
/* Define to 1 if you have the `pow' function. */ |
/* #undef HAVE_POW */ |
#define HAVE_POW 1 |
/* Define to 1 if you have the <stdint.h> header file. */ |
#define HAVE_STDINT_H 1 |
60,7 → 60,7 |
#define PACKAGE_NAME "libpng" |
/* Define to the full name and version of this package. */ |
#define PACKAGE_STRING "libpng 1.5.1" |
#define PACKAGE_STRING "libpng 1.6.5" |
/* Define to the one symbol short name of this package. */ |
#define PACKAGE_TARNAME "libpng" |
69,8 → 69,17 |
#define PACKAGE_URL "" |
/* Define to the version of this package. */ |
#define PACKAGE_VERSION "1.5.1" |
#define PACKAGE_VERSION "1.6.5" |
/* Turn on ARM Neon optimizations at run-time */ |
/* #undef PNG_ARM_NEON_API_SUPPORTED */ |
/* Check for ARM Neon support at run-time */ |
/* #undef PNG_ARM_NEON_CHECK_SUPPORTED */ |
/* Enable ARM Neon optimizations */ |
/* #undef PNG_ARM_NEON_OPT */ |
/* Define to 1 if you have the ANSI C header files. */ |
#define STDC_HEADERS 1 |
78,10 → 87,24 |
/* #undef TM_IN_SYS_TIME */ |
/* Version number of package */ |
#define VERSION "1.5.1" |
#define VERSION "1.6.5" |
/* Define to empty if `const' does not conform to ANSI C. */ |
/* #undef const */ |
/* Define to the equivalent of the C99 'restrict' keyword, or to |
nothing if this is not supported. Do not define if restrict is |
supported directly. */ |
#define restrict __restrict |
/* Work around a bug in Sun C++: it does not support _Restrict or |
__restrict__, even though the corresponding Sun C compiler ends up with |
"#define restrict _Restrict" or "#define restrict __restrict__" in the |
previous line. Perhaps some future version of Sun C++ will work with |
restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ |
#if defined __SUNPRO_CC && !defined __RESTRICT |
# define _Restrict |
# define __restrict__ |
#endif |
/* Define to `unsigned int' if <sys/types.h> does not define. */ |
/* #undef size_t */ |
/programs/develop/libraries/libpng/libpng16.def |
---|
0,0 → 1,242 |
EXPORTS |
png_access_version_number |
png_set_sig_bytes |
png_sig_cmp |
png_create_read_struct |
png_create_write_struct |
png_get_compression_buffer_size |
png_set_compression_buffer_size |
png_set_longjmp_fn |
png_longjmp |
png_reset_zstream |
png_create_read_struct_2 |
png_create_write_struct_2 |
png_write_sig |
png_write_chunk |
png_write_chunk_start |
png_write_chunk_data |
png_write_chunk_end |
png_create_info_struct |
png_info_init_3 |
png_write_info_before_PLTE |
png_write_info |
png_read_info |
png_convert_to_rfc1123 |
png_convert_to_rfc1123_buffer |
png_convert_from_struct_tm |
png_convert_from_time_t |
png_set_expand |
png_set_expand_gray_1_2_4_to_8 |
png_set_palette_to_rgb |
png_set_tRNS_to_alpha |
png_set_expand_16 |
png_set_bgr |
png_set_gray_to_rgb |
png_set_rgb_to_gray |
png_set_rgb_to_gray_fixed |
png_get_rgb_to_gray_status |
png_build_grayscale_palette |
png_set_alpha_mode |
png_set_alpha_mode_fixed |
png_set_strip_alpha |
png_set_swap_alpha |
png_set_invert_alpha |
png_set_filler |
png_set_add_alpha |
png_set_swap |
png_set_packing |
png_set_packswap |
png_set_shift |
png_set_interlace_handling |
png_set_invert_mono |
png_set_background |
png_set_background_fixed |
png_set_scale_16 |
png_set_strip_16 |
png_set_quantize |
png_set_gamma |
png_set_gamma_fixed |
png_set_flush |
png_write_flush |
png_start_read_image |
png_read_update_info |
png_read_rows |
png_read_row |
png_read_image |
png_write_row |
png_write_rows |
png_write_image |
png_write_end |
png_read_end |
png_destroy_info_struct |
png_destroy_read_struct |
png_destroy_write_struct |
png_set_crc_action |
png_set_filter |
png_set_filter_heuristics |
png_set_filter_heuristics_fixed |
png_set_compression_level |
png_set_compression_mem_level |
png_set_compression_strategy |
png_set_compression_window_bits |
png_set_compression_method |
png_set_text_compression_level |
png_set_text_compression_mem_level |
png_set_text_compression_strategy |
png_set_text_compression_window_bits |
png_set_text_compression_method |
png_init_io |
png_set_error_fn |
png_get_error_ptr |
png_set_write_fn |
png_set_read_fn |
png_get_io_ptr |
png_set_read_status_fn |
png_set_write_status_fn |
png_set_mem_fn |
png_get_mem_ptr |
png_set_read_user_transform_fn |
png_set_write_user_transform_fn |
png_set_user_transform_info |
png_get_user_transform_ptr |
png_get_current_row_number |
png_get_current_pass_number |
png_set_read_user_chunk_fn |
png_get_user_chunk_ptr |
png_set_progressive_read_fn |
png_get_progressive_ptr |
png_process_data |
png_process_data_pause |
png_process_data_skip |
png_progressive_combine_row |
png_malloc |
png_calloc |
png_malloc_warn |
png_free |
png_free_data |
png_data_freer |
png_malloc_default |
png_free_default |
png_error |
png_chunk_error |
png_warning |
png_chunk_warning |
png_benign_error |
png_chunk_benign_error |
png_set_benign_errors |
png_get_valid |
png_get_rowbytes |
png_get_rows |
png_set_rows |
png_get_channels |
png_get_image_width |
png_get_image_height |
png_get_bit_depth |
png_get_color_type |
png_get_filter_type |
png_get_interlace_type |
png_get_compression_type |
png_get_pixels_per_meter |
png_get_x_pixels_per_meter |
png_get_y_pixels_per_meter |
png_get_pixel_aspect_ratio |
png_get_pixel_aspect_ratio_fixed |
png_get_x_offset_pixels |
png_get_y_offset_pixels |
png_get_x_offset_microns |
png_get_y_offset_microns |
png_get_signature |
png_get_bKGD |
png_set_bKGD |
png_get_cHRM |
png_get_cHRM_XYZ |
png_get_cHRM_fixed |
png_get_cHRM_XYZ_fixed |
png_set_cHRM |
png_set_cHRM_XYZ |
png_set_cHRM_fixed |
png_set_cHRM_XYZ_fixed |
png_get_gAMA |
png_get_gAMA_fixed |
png_set_gAMA |
png_set_gAMA_fixed |
png_get_hIST |
png_set_hIST |
png_get_IHDR |
png_set_IHDR |
png_get_oFFs |
png_set_oFFs |
png_get_pCAL |
png_set_pCAL |
png_get_pHYs |
png_set_pHYs |
png_get_PLTE |
png_set_PLTE |
png_get_sBIT |
png_set_sBIT |
png_get_sRGB |
png_set_sRGB |
png_set_sRGB_gAMA_and_cHRM |
png_get_iCCP |
png_set_iCCP |
png_get_sPLT |
png_set_sPLT |
png_get_text |
png_set_text |
png_get_tIME |
png_set_tIME |
png_get_tRNS |
png_set_tRNS |
png_get_sCAL |
png_get_sCAL_fixed |
png_get_sCAL_s |
png_set_sCAL |
png_set_sCAL_fixed |
png_set_sCAL_s |
png_set_keep_unknown_chunks |
png_handle_as_unknown |
png_set_unknown_chunks |
png_set_unknown_chunk_location |
png_get_unknown_chunks |
png_set_invalid |
png_read_png |
png_write_png |
png_get_copyright |
png_get_header_ver |
png_get_header_version |
png_get_libpng_ver |
png_permit_mng_features |
png_set_user_limits |
png_get_user_width_max |
png_get_user_height_max |
png_set_chunk_cache_max |
png_get_chunk_cache_max |
png_set_chunk_malloc_max |
png_get_chunk_malloc_max |
png_get_pixels_per_inch |
png_get_x_pixels_per_inch |
png_get_y_pixels_per_inch |
png_get_x_offset_inches |
png_get_x_offset_inches_fixed |
png_get_y_offset_inches |
png_get_y_offset_inches_fixed |
png_get_pHYs_dpi |
png_get_io_state |
png_get_io_chunk_type |
png_get_uint_32 |
png_get_uint_16 |
png_get_int_32 |
png_get_uint_31 |
png_save_uint_32 |
png_save_int_32 |
png_save_uint_16 |
png_image_begin_read_from_file |
png_image_begin_read_from_stdio |
png_image_begin_read_from_memory |
png_image_finish_read |
png_image_free |
png_image_write_to_file |
png_image_write_to_stdio |
png_set_check_for_invalid_index |
png_get_palette_max |
png_set_option |
/programs/develop/libraries/libpng/png.c |
---|
1,8 → 1,8 |
/* png.c - location for general purpose libpng functions |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.2 [April 25, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
14,7 → 14,7 |
#include "pngpriv.h" |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef png_libpng_version_1_5_1 Your_png_h_is_not_version_1_5_1; |
typedef png_libpng_version_1_6_5 Your_png_h_is_not_version_1_6_5; |
/* Tells libpng that we have already handled the first "num_bytes" bytes |
* of the PNG file signature. If the PNG data is embedded into another |
24,7 → 24,7 |
#ifdef PNG_READ_SUPPORTED |
void PNGAPI |
png_set_sig_bytes(png_structp png_ptr, int num_bytes) |
png_set_sig_bytes(png_structrp png_ptr, int num_bytes) |
{ |
png_debug(1, "in png_set_sig_bytes"); |
43,7 → 43,7 |
* can simply check the remaining bytes for extra assurance. Returns |
* an integer less than, equal to, or greater than zero if sig is found, |
* respectively, to be less than, to match, or be greater than the correct |
* PNG signature (this is the same behaviour as strcmp, memcmp, etc). |
* PNG signature (this is the same behavior as strcmp, memcmp, etc). |
*/ |
int PNGAPI |
png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check) |
62,7 → 62,7 |
if (start + num_to_check > 8) |
num_to_check = 8 - start; |
return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); |
return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check))); |
} |
#endif /* PNG_READ_SUPPORTED */ |
72,26 → 72,20 |
PNG_FUNCTION(voidpf /* PRIVATE */, |
png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED) |
{ |
png_voidp ptr; |
png_structp p=(png_structp)png_ptr; |
png_uint_32 save_flags=p->flags; |
png_alloc_size_t num_bytes; |
png_alloc_size_t num_bytes = size; |
if (png_ptr == NULL) |
return (NULL); |
return NULL; |
if (items > PNG_UINT_32_MAX/size) |
if (items >= (~(png_alloc_size_t)0)/size) |
{ |
png_warning (p, "Potential overflow in png_zalloc()"); |
return (NULL); |
png_warning (png_voidcast(png_structrp, png_ptr), |
"Potential overflow in png_zalloc()"); |
return NULL; |
} |
num_bytes = (png_alloc_size_t)items * size; |
p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); |
p->flags=save_flags; |
return ((voidpf)ptr); |
num_bytes *= items; |
return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes); |
} |
/* Function to free memory for zlib */ |
98,7 → 92,7 |
void /* PRIVATE */ |
png_zfree(voidpf png_ptr, voidpf ptr) |
{ |
png_free((png_structp)png_ptr, (png_voidp)ptr); |
png_free(png_voidcast(png_const_structrp,png_ptr), ptr); |
} |
/* Reset the CRC variable to 32 bits of 1's. Care must be taken |
105,9 → 99,10 |
* in case CRC is > 32 bits to leave the top bits 0. |
*/ |
void /* PRIVATE */ |
png_reset_crc(png_structp png_ptr) |
png_reset_crc(png_structrp png_ptr) |
{ |
png_ptr->crc = crc32(0, Z_NULL, 0); |
/* The cast is safe because the crc is a 32 bit value. */ |
png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0); |
} |
/* Calculate the CRC over a section of data. We can only pass as |
116,11 → 111,11 |
* trouble of calculating it. |
*/ |
void /* PRIVATE */ |
png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length) |
png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length) |
{ |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)) |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
133,47 → 128,234 |
need_crc = 0; |
} |
if (need_crc) |
png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); |
/* 'uLong' is defined in zlib.h as unsigned long; this means that on some |
* systems it is a 64 bit value. crc32, however, returns 32 bits so the |
* following cast is safe. 'uInt' may be no more than 16 bits, so it is |
* necessary to perform a loop here. |
*/ |
if (need_crc && length > 0) |
{ |
uLong crc = png_ptr->crc; /* Should never issue a warning */ |
do |
{ |
uInt safe_length = (uInt)length; |
if (safe_length == 0) |
safe_length = (uInt)-1; /* evil, but safe */ |
crc = crc32(crc, ptr, safe_length); |
/* The following should never issue compiler warnings; if they do the |
* target system has characteristics that will probably violate other |
* assumptions within the libpng code. |
*/ |
ptr += safe_length; |
length -= safe_length; |
} |
while (length > 0); |
/* Allocate the memory for an info_struct for the application. We don't |
* really need the png_ptr, but it could potentially be useful in the |
* future. This should be used in favour of malloc(png_sizeof(png_info)) |
* and png_info_init() so that applications that want to use a shared |
* libpng don't have to be recompiled if png_info changes size. |
/* And the following is always safe because the crc is only 32 bits. */ |
png_ptr->crc = (png_uint_32)crc; |
} |
} |
/* Check a user supplied version number, called from both read and write |
* functions that create a png_struct. |
*/ |
int |
png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver) |
{ |
if (user_png_ver) |
{ |
int i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
} |
else |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first and third digits (note that when we reach version |
* 1.10 we will need to check the fourth symbol, namely user_png_ver[3]). |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && (user_png_ver[2] != png_libpng_ver[2] || |
user_png_ver[3] != png_libpng_ver[3])) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#ifdef PNG_WARNINGS_SUPPORTED |
size_t pos = 0; |
char m[128]; |
pos = png_safecat(m, (sizeof m), pos, |
"Application built with libpng-"); |
pos = png_safecat(m, (sizeof m), pos, user_png_ver); |
pos = png_safecat(m, (sizeof m), pos, " but running with "); |
pos = png_safecat(m, (sizeof m), pos, png_libpng_ver); |
png_warning(png_ptr, m); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags = 0; |
#endif |
return 0; |
} |
} |
/* Success return. */ |
return 1; |
} |
/* Generic function to create a png_struct for either read or write - this |
* contains the common initialization. |
*/ |
PNG_FUNCTION(png_structp /* PRIVATE */, |
png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) |
{ |
png_struct create_struct; |
# ifdef PNG_SETJMP_SUPPORTED |
jmp_buf create_jmp_buf; |
# endif |
/* This temporary stack-allocated structure is used to provide a place to |
* build enough context to allow the user provided memory allocator (if any) |
* to be called. |
*/ |
memset(&create_struct, 0, (sizeof create_struct)); |
/* Added at libpng-1.2.6 */ |
# ifdef PNG_USER_LIMITS_SUPPORTED |
create_struct.user_width_max = PNG_USER_WIDTH_MAX; |
create_struct.user_height_max = PNG_USER_HEIGHT_MAX; |
# ifdef PNG_USER_CHUNK_CACHE_MAX |
/* Added at libpng-1.2.43 and 1.4.0 */ |
create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; |
# endif |
# ifdef PNG_USER_CHUNK_MALLOC_MAX |
/* Added at libpng-1.2.43 and 1.4.1, required only for read but exists |
* in png_struct regardless. |
*/ |
create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; |
# endif |
# endif |
/* The following two API calls simply set fields in png_struct, so it is safe |
* to do them now even though error handling is not yet set up. |
*/ |
# ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn); |
# endif |
/* (*error_fn) can return control to the caller after the error_ptr is set, |
* this will result in a memory leak unless the error_fn does something |
* extremely sophisticated. The design lacks merit but is implicit in the |
* API. |
*/ |
png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn); |
# ifdef PNG_SETJMP_SUPPORTED |
if (!setjmp(create_jmp_buf)) |
{ |
/* Temporarily fake out the longjmp information until we have |
* successfully completed this function. This only works if we have |
* setjmp() support compiled in, but it is safe - this stuff should |
* never happen. |
*/ |
create_struct.jmp_buf_ptr = &create_jmp_buf; |
create_struct.jmp_buf_size = 0; /*stack allocation*/ |
create_struct.longjmp_fn = longjmp; |
# else |
{ |
# endif |
/* Call the general version checker (shared with read and write code): |
*/ |
if (png_user_version_check(&create_struct, user_png_ver)) |
{ |
png_structrp png_ptr = png_voidcast(png_structrp, |
png_malloc_warn(&create_struct, (sizeof *png_ptr))); |
if (png_ptr != NULL) |
{ |
/* png_ptr->zstream holds a back-pointer to the png_struct, so |
* this can only be done now: |
*/ |
create_struct.zstream.zalloc = png_zalloc; |
create_struct.zstream.zfree = png_zfree; |
create_struct.zstream.opaque = png_ptr; |
# ifdef PNG_SETJMP_SUPPORTED |
/* Eliminate the local error handling: */ |
create_struct.jmp_buf_ptr = NULL; |
create_struct.jmp_buf_size = 0; |
create_struct.longjmp_fn = 0; |
# endif |
*png_ptr = create_struct; |
/* This is the successful return point */ |
return png_ptr; |
} |
} |
} |
/* A longjmp because of a bug in the application storage allocator or a |
* simple failure to allocate the png_struct. |
*/ |
return NULL; |
} |
/* Allocate the memory for an info_struct for the application. */ |
PNG_FUNCTION(png_infop,PNGAPI |
png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED) |
png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED) |
{ |
png_infop info_ptr; |
png_inforp info_ptr; |
png_debug(1, "in png_create_info_struct"); |
if (png_ptr == NULL) |
return (NULL); |
return NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, |
png_ptr->malloc_fn, png_ptr->mem_ptr); |
#else |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
#endif |
/* Use the internal API that does not (or at least should not) error out, so |
* that this call always returns ok. The application typically sets up the |
* error handling *after* creating the info_struct because this is the way it |
* has always been done in 'example.c'. |
*/ |
info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr, |
(sizeof *info_ptr))); |
if (info_ptr != NULL) |
png_info_init_3(&info_ptr, png_sizeof(png_info)); |
memset(info_ptr, 0, (sizeof *info_ptr)); |
return (info_ptr); |
return info_ptr; |
} |
/* This function frees the memory associated with a single info struct. |
* Normally, one would use either png_destroy_read_struct() or |
* png_destroy_write_struct() to free an info struct, but this may be |
* useful for some applications. |
* useful for some applications. From libpng 1.6.0 this function is also used |
* internally to implement the png_info release part of the 'struct' destroy |
* APIs. This ensures that all possible approaches free the same data (all of |
* it). |
*/ |
void PNGAPI |
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) |
png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr) |
{ |
png_infop info_ptr = NULL; |
png_inforp info_ptr = NULL; |
png_debug(1, "in png_destroy_info_struct"); |
185,27 → 367,34 |
if (info_ptr != NULL) |
{ |
png_info_destroy(png_ptr, info_ptr); |
/* Do this first in case of an error below; if the app implements its own |
* memory management this can lead to png_free calling png_error, which |
* will abort this routine and return control to the app error handler. |
* An infinite loop may result if it then tries to free the same info |
* ptr. |
*/ |
*info_ptr_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, |
png_ptr->mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
memset(info_ptr, 0, (sizeof *info_ptr)); |
png_free(png_ptr, info_ptr); |
} |
} |
/* Initialize the info structure. This is now an internal function (0.89) |
* and applications using it are urged to use png_create_info_struct() |
* instead. |
* instead. Use deprecated in 1.6.0, internal use removed (used internally it |
* is just a memset). |
* |
* NOTE: it is almost inconceivable that this API is used because it bypasses |
* the user-memory mechanism and the user error handling/warning mechanisms in |
* those cases where it does anything other than a memset. |
*/ |
void PNGAPI |
png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) |
PNG_FUNCTION(void,PNGAPI |
png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size), |
PNG_DEPRECATED) |
{ |
png_infop info_ptr = *ptr_ptr; |
png_inforp info_ptr = *ptr_ptr; |
png_debug(1, "in png_info_init_3"); |
212,19 → 401,23 |
if (info_ptr == NULL) |
return; |
if (png_sizeof(png_info) > png_info_struct_size) |
if ((sizeof (png_info)) > png_info_struct_size) |
{ |
png_destroy_struct(info_ptr); |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
*ptr_ptr = NULL; |
/* The following line is why this API should not be used: */ |
free(info_ptr); |
info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL, |
(sizeof *info_ptr))); |
*ptr_ptr = info_ptr; |
} |
/* Set everything to 0 */ |
png_memset(info_ptr, 0, png_sizeof(png_info)); |
memset(info_ptr, 0, (sizeof *info_ptr)); |
} |
/* The following API is not called internally */ |
void PNGAPI |
png_data_freer(png_structp png_ptr, png_infop info_ptr, |
png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr, |
int freer, png_uint_32 mask) |
{ |
png_debug(1, "in png_data_freer"); |
239,12 → 432,11 |
info_ptr->free_me &= ~mask; |
else |
png_warning(png_ptr, |
"Unknown freer parameter in png_data_freer"); |
png_error(png_ptr, "Unknown freer parameter in png_data_freer"); |
} |
void PNGAPI |
png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, |
png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask, |
int num) |
{ |
png_debug(1, "in png_free_data"); |
291,12 → 483,10 |
/* Free any sCAL entry */ |
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) |
{ |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, info_ptr->scal_s_width); |
png_free(png_ptr, info_ptr->scal_s_height); |
info_ptr->scal_s_width = NULL; |
info_ptr->scal_s_height = NULL; |
#endif |
info_ptr->valid &= ~PNG_INFO_sCAL; |
} |
#endif |
311,8 → 501,8 |
info_ptr->pcal_units = NULL; |
if (info_ptr->pcal_params != NULL) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->pcal_nparams; i++) |
unsigned int i; |
for (i = 0; i < info_ptr->pcal_nparams; i++) |
{ |
png_free(png_ptr, info_ptr->pcal_params[i]); |
info_ptr->pcal_params[i] = NULL; |
325,7 → 515,7 |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
/* Free any iCCP entry */ |
/* Free any profile entry */ |
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) |
{ |
png_free(png_ptr, info_ptr->iccp_name); |
356,8 → 546,8 |
if (info_ptr->splt_palettes_num) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); |
for (i = 0; i < info_ptr->splt_palettes_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes = NULL; |
368,13 → 558,7 |
} |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
if (png_ptr->unknown_chunk.data) |
{ |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) |
{ |
if (num != -1) |
393,7 → 577,7 |
if (info_ptr->unknown_chunks_num) |
{ |
for (i = 0; i < info_ptr->unknown_chunks_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); |
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks = NULL; |
416,7 → 600,7 |
/* Free any PLTE entry that was internally allocated */ |
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) |
{ |
png_zfree(png_ptr, info_ptr->palette); |
png_free(png_ptr, info_ptr->palette); |
info_ptr->palette = NULL; |
info_ptr->valid &= ~PNG_INFO_PLTE; |
info_ptr->num_palette = 0; |
428,8 → 612,8 |
{ |
if (info_ptr->row_pointers) |
{ |
int row; |
for (row = 0; row < (int)info_ptr->height; row++) |
png_uint_32 row; |
for (row = 0; row < info_ptr->height; row++) |
{ |
png_free(png_ptr, info_ptr->row_pointers[row]); |
info_ptr->row_pointers[row] = NULL; |
446,29 → 630,6 |
info_ptr->free_me &= ~mask; |
} |
/* This is an internal routine to free any memory that the info struct is |
* pointing to before re-using it or freeing the struct itself. Recall |
* that png_free() checks for NULL pointers for us. |
*/ |
void /* PRIVATE */ |
png_info_destroy(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_info_destroy"); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list = NULL; |
png_ptr->num_chunk_list = 0; |
} |
#endif |
png_info_init_3(&info_ptr, png_sizeof(png_info)); |
} |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
/* This function returns a pointer to the io_ptr associated with the user |
476,7 → 637,7 |
* pointer before png_write_destroy() or png_read_destroy() are called. |
*/ |
png_voidp PNGAPI |
png_get_io_ptr(png_structp png_ptr) |
png_get_io_ptr(png_const_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
489,11 → 650,11 |
/* Initialize the default input/output functions for the PNG file. If you |
* use your own read or write routines, you can call either png_set_read_fn() |
* or png_set_write_fn() instead of png_init_io(). If you have defined |
* PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't |
* necessarily available. |
* PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a |
* function of your own because "FILE *" isn't necessarily available. |
*/ |
void PNGAPI |
png_init_io(png_structp png_ptr, png_FILE_p fp) |
png_init_io(png_structrp png_ptr, png_FILE_p fp) |
{ |
png_debug(1, "in png_init_io"); |
504,50 → 665,102 |
} |
# endif |
#ifdef PNG_SAVE_INT_32_SUPPORTED |
/* The png_save_int_32 function assumes integers are stored in two's |
* complement format. If this isn't the case, then this routine needs to |
* be modified to write data in two's complement format. Note that, |
* the following works correctly even if png_int_32 has more than 32 bits |
* (compare the more complex code required on read for sign extension.) |
*/ |
void PNGAPI |
png_save_int_32(png_bytep buf, png_int_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#endif |
# ifdef PNG_TIME_RFC1123_SUPPORTED |
/* Convert the supplied time into an RFC 1123 string suitable for use in |
* a "Creation Time" or other text-based time string. |
*/ |
png_const_charp PNGAPI |
png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime) |
int PNGAPI |
png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime) |
{ |
static PNG_CONST char short_months[12][4] = |
{"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; |
if (png_ptr == NULL) |
return (NULL); |
if (out == NULL) |
return 0; |
if (png_ptr->time_buffer == NULL) |
if (ptime->year > 9999 /* RFC1123 limitation */ || |
ptime->month == 0 || ptime->month > 12 || |
ptime->day == 0 || ptime->day > 31 || |
ptime->hour > 23 || ptime->minute > 59 || |
ptime->second > 60) |
return 0; |
{ |
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* |
png_sizeof(char))); |
size_t pos = 0; |
char number_buf[5]; /* enough for a four-digit year */ |
# define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string)) |
# define APPEND_NUMBER(format, value)\ |
APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value))) |
# define APPEND(ch) if (pos < 28) out[pos++] = (ch) |
APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day); |
APPEND(' '); |
APPEND_STRING(short_months[(ptime->month - 1)]); |
APPEND(' '); |
APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year); |
APPEND(' '); |
APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour); |
APPEND(':'); |
APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute); |
APPEND(':'); |
APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second); |
APPEND_STRING(" +0000"); /* This reliably terminates the buffer */ |
# undef APPEND |
# undef APPEND_NUMBER |
# undef APPEND_STRING |
} |
# ifdef USE_FAR_KEYWORD |
return 1; |
} |
# if PNG_LIBPNG_VER < 10700 |
/* To do: remove the following from libpng-1.7 */ |
/* Original API that uses a private buffer in png_struct. |
* Deprecated because it causes png_struct to carry a spurious temporary |
* buffer (png_struct::time_buffer), better to have the caller pass this in. |
*/ |
png_const_charp PNGAPI |
png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime) |
{ |
char near_time_buf[29]; |
png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
png_memcpy(png_ptr->time_buffer, near_time_buf, |
29*png_sizeof(char)); |
if (png_ptr != NULL) |
{ |
/* The only failure above if png_ptr != NULL is from an invalid ptime */ |
if (!png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime)) |
png_warning(png_ptr, "Ignoring invalid time value"); |
else |
return png_ptr->time_buffer; |
} |
# else |
png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
return NULL; |
} |
# endif |
return png_ptr->time_buffer; |
} |
# endif /* PNG_TIME_RFC1123_SUPPORTED */ |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
png_const_charp PNGAPI |
png_get_copyright(png_const_structp png_ptr) |
png_get_copyright(png_const_structrp png_ptr) |
{ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
#ifdef PNG_STRING_COPYRIGHT |
555,14 → 768,14 |
#else |
# ifdef __STDC__ |
return PNG_STRING_NEWLINE \ |
"libpng version 1.5.1 - February 3, 2011" PNG_STRING_NEWLINE \ |
"Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ |
"libpng version 1.6.5 - September 14, 2013" PNG_STRING_NEWLINE \ |
"Copyright (c) 1998-2013 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ |
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ |
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ |
PNG_STRING_NEWLINE; |
# else |
return "libpng version 1.5.1 - February 3, 2011\ |
Copyright (c) 1998-2011 Glenn Randers-Pehrson\ |
return "libpng version 1.6.5 - September 14, 2013\ |
Copyright (c) 1998-2013 Glenn Randers-Pehrson\ |
Copyright (c) 1996-1997 Andreas Dilger\ |
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; |
# endif |
578,7 → 791,7 |
* it is guaranteed that png.c uses the correct version of png.h. |
*/ |
png_const_charp PNGAPI |
png_get_libpng_ver(png_const_structp png_ptr) |
png_get_libpng_ver(png_const_structrp png_ptr) |
{ |
/* Version of *.c files used when building libpng */ |
return png_get_header_ver(png_ptr); |
585,7 → 798,7 |
} |
png_const_charp PNGAPI |
png_get_header_ver(png_const_structp png_ptr) |
png_get_header_ver(png_const_structrp png_ptr) |
{ |
/* Version of *.h files used when building libpng */ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
593,7 → 806,7 |
} |
png_const_charp PNGAPI |
png_get_header_version(png_const_structp png_ptr) |
png_get_header_version(png_const_structrp png_ptr) |
{ |
/* Returns longer string containing both version and date */ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
608,34 → 821,61 |
#endif |
} |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
# ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
int PNGAPI |
png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name) |
png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name) |
{ |
/* Check chunk_name and return "keep" value if it's on the list, else 0 */ |
int i; |
png_bytep p; |
if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0) |
return 0; |
png_const_bytep p, p_end; |
p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5; |
for (i = png_ptr->num_chunk_list; i; i--, p -= 5) |
if (!png_memcmp(chunk_name, p, 4)) |
return ((int)*(p + 4)); |
return 0; |
if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0) |
return PNG_HANDLE_CHUNK_AS_DEFAULT; |
p_end = png_ptr->chunk_list; |
p = p_end + png_ptr->num_chunk_list*5; /* beyond end */ |
/* The code is the fifth byte after each four byte string. Historically this |
* code was always searched from the end of the list, this is no longer |
* necessary because the 'set' routine handles duplicate entries correcty. |
*/ |
do /* num_chunk_list > 0, so at least one */ |
{ |
p -= 5; |
if (!memcmp(chunk_name, p, 4)) |
return p[4]; |
} |
# endif |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
while (p > p_end); |
/* This means that known chunks should be processed and unknown chunks should |
* be handled according to the value of png_ptr->unknown_default; this can be |
* confusing because, as a result, there are two levels of defaulting for |
* unknown chunks. |
*/ |
return PNG_HANDLE_CHUNK_AS_DEFAULT; |
} |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int /* PRIVATE */ |
png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name) |
{ |
png_byte chunk_string[5]; |
PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name); |
return png_handle_as_unknown(png_ptr, chunk_string); |
} |
#endif /* HANDLE_AS_UNKNOWN */ |
#endif /* SET_UNKNOWN_CHUNKS */ |
#ifdef PNG_READ_SUPPORTED |
/* This function, added to libpng-1.0.6g, is untested. */ |
int PNGAPI |
png_reset_zstream(png_structp png_ptr) |
png_reset_zstream(png_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return Z_STREAM_ERROR; |
/* WARNING: this resets the window bits to the maximum! */ |
return (inflateReset(&png_ptr->zstream)); |
} |
#endif /* PNG_READ_SUPPORTED */ |
651,98 → 891,1472 |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
# ifdef PNG_SIZE_T |
/* Added at libpng version 1.2.6 */ |
PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); |
png_size_t PNGAPI |
png_convert_size(size_t size) |
/* Ensure that png_ptr->zstream.msg holds some appropriate error message string. |
* If it doesn't 'ret' is used to set it to something appropriate, even in cases |
* like Z_OK or Z_STREAM_END where the error code is apparently a success code. |
*/ |
void /* PRIVATE */ |
png_zstream_error(png_structrp png_ptr, int ret) |
{ |
if (size > (png_size_t)-1) |
PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ |
/* Translate 'ret' into an appropriate error string, priority is given to the |
* one in zstream if set. This always returns a string, even in cases like |
* Z_OK or Z_STREAM_END where the error code is a success code. |
*/ |
if (png_ptr->zstream.msg == NULL) switch (ret) |
{ |
default: |
case Z_OK: |
png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code"); |
break; |
return ((png_size_t)size); |
case Z_STREAM_END: |
/* Normal exit */ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream"); |
break; |
case Z_NEED_DICT: |
/* This means the deflate stream did not have a dictionary; this |
* indicates a bogus PNG. |
*/ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary"); |
break; |
case Z_ERRNO: |
/* gz APIs only: should not happen */ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error"); |
break; |
case Z_STREAM_ERROR: |
/* internal libpng error */ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib"); |
break; |
case Z_DATA_ERROR: |
png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream"); |
break; |
case Z_MEM_ERROR: |
png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory"); |
break; |
case Z_BUF_ERROR: |
/* End of input or output; not a problem if the caller is doing |
* incremental read or write. |
*/ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated"); |
break; |
case Z_VERSION_ERROR: |
png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version"); |
break; |
case PNG_UNEXPECTED_ZLIB_RETURN: |
/* Compile errors here mean that zlib now uses the value co-opted in |
* pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above |
* and change pngpriv.h. Note that this message is "... return", |
* whereas the default/Z_OK one is "... return code". |
*/ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return"); |
break; |
} |
# endif /* PNG_SIZE_T */ |
} |
/* png_convert_size: a PNGAPI but no longer in png.h, so deleted |
* at libpng 1.5.5! |
*/ |
/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ |
# ifdef PNG_CHECK_cHRM_SUPPORTED |
#ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */ |
static int |
png_colorspace_check_gamma(png_const_structrp png_ptr, |
png_colorspacerp colorspace, png_fixed_point gAMA, int from) |
/* This is called to check a new gamma value against an existing one. The |
* routine returns false if the new gamma value should not be written. |
* |
* 'from' says where the new gamma value comes from: |
* |
* 0: the new gamma value is the libpng estimate for an ICC profile |
* 1: the new gamma value comes from a gAMA chunk |
* 2: the new gamma value comes from an sRGB chunk |
*/ |
{ |
png_fixed_point gtest; |
if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && |
(!png_muldiv(>est, colorspace->gamma, PNG_FP_1, gAMA) || |
png_gamma_significant(gtest))) |
{ |
/* Either this is an sRGB image, in which case the calculated gamma |
* approximation should match, or this is an image with a profile and the |
* value libpng calculates for the gamma of the profile does not match the |
* value recorded in the file. The former, sRGB, case is an error, the |
* latter is just a warning. |
*/ |
if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2) |
{ |
png_chunk_report(png_ptr, "gamma value does not match sRGB", |
PNG_CHUNK_ERROR); |
/* Do not overwrite an sRGB value */ |
return from == 2; |
} |
else /* sRGB tag not involved */ |
{ |
png_chunk_report(png_ptr, "gamma value does not match libpng estimate", |
PNG_CHUNK_WARNING); |
return from == 1; |
} |
} |
return 1; |
} |
void /* PRIVATE */ |
png_colorspace_set_gamma(png_const_structrp png_ptr, |
png_colorspacerp colorspace, png_fixed_point gAMA) |
{ |
/* Changed in libpng-1.5.4 to limit the values to ensure overflow can't |
* occur. Since the fixed point representation is assymetrical it is |
* possible for 1/gamma to overflow the limit of 21474 and this means the |
* gamma value must be at least 5/100000 and hence at most 20000.0. For |
* safety the limits here are a little narrower. The values are 0.00016 to |
* 6250.0, which are truly ridiculous gamma values (and will produce |
* displays that are all black or all white.) |
* |
* In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk |
* handling code, which only required the value to be >0. |
*/ |
png_const_charp errmsg; |
if (gAMA < 16 || gAMA > 625000000) |
errmsg = "gamma value out of range"; |
# ifdef PNG_READ_gAMA_SUPPORTED |
/* Allow the application to set the gamma value more than once */ |
else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && |
(colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0) |
errmsg = "duplicate"; |
# endif |
/* Do nothing if the colorspace is already invalid */ |
else if (colorspace->flags & PNG_COLORSPACE_INVALID) |
return; |
else |
{ |
if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/)) |
{ |
/* Store this gamma value. */ |
colorspace->gamma = gAMA; |
colorspace->flags |= |
(PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA); |
} |
/* At present if the check_gamma test fails the gamma of the colorspace is |
* not updated however the colorspace is not invalidated. This |
* corresponds to the case where the existing gamma comes from an sRGB |
* chunk or profile. An error message has already been output. |
*/ |
return; |
} |
/* Error exit - errmsg has been set. */ |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR); |
} |
void /* PRIVATE */ |
png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr) |
{ |
if (info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) |
{ |
/* Everything is invalid */ |
info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB| |
PNG_INFO_iCCP); |
# ifdef PNG_COLORSPACE_SUPPORTED |
/* Clean up the iCCP profile now if it won't be used. */ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/); |
# else |
PNG_UNUSED(png_ptr) |
# endif |
} |
else |
{ |
# ifdef PNG_COLORSPACE_SUPPORTED |
/* Leave the INFO_iCCP flag set if the pngset.c code has already set |
* it; this allows a PNG to contain a profile which matches sRGB and |
* yet still have that profile retrievable by the application. |
*/ |
if (info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) |
info_ptr->valid |= PNG_INFO_sRGB; |
else |
info_ptr->valid &= ~PNG_INFO_sRGB; |
if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) |
info_ptr->valid |= PNG_INFO_cHRM; |
else |
info_ptr->valid &= ~PNG_INFO_cHRM; |
# endif |
if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) |
info_ptr->valid |= PNG_INFO_gAMA; |
else |
info_ptr->valid &= ~PNG_INFO_gAMA; |
} |
} |
#ifdef PNG_READ_SUPPORTED |
void /* PRIVATE */ |
png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr) |
{ |
if (info_ptr == NULL) /* reduce code size; check here not in the caller */ |
return; |
info_ptr->colorspace = png_ptr->colorspace; |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
#endif |
#endif |
#ifdef PNG_COLORSPACE_SUPPORTED |
/* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for |
* cHRM, as opposed to using chromaticities. These internal APIs return |
* non-zero on a parameter error. The X, Y and Z values are required to be |
* positive and less than 1.0. |
*/ |
static int |
png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ) |
{ |
png_int_32 d, dwhite, whiteX, whiteY; |
d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z; |
if (!png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d)) return 1; |
if (!png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d)) return 1; |
dwhite = d; |
whiteX = XYZ->red_X; |
whiteY = XYZ->red_Y; |
d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z; |
if (!png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d)) return 1; |
if (!png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d)) return 1; |
dwhite += d; |
whiteX += XYZ->green_X; |
whiteY += XYZ->green_Y; |
d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z; |
if (!png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d)) return 1; |
if (!png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d)) return 1; |
dwhite += d; |
whiteX += XYZ->blue_X; |
whiteY += XYZ->blue_Y; |
/* The reference white is simply the sum of the end-point (X,Y,Z) vectors, |
* thus: |
*/ |
if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1; |
if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1; |
return 0; |
} |
static int |
png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy) |
{ |
png_fixed_point red_inverse, green_inverse, blue_scale; |
png_fixed_point left, right, denominator; |
/* Check xy and, implicitly, z. Note that wide gamut color spaces typically |
* have end points with 0 tristimulus values (these are impossible end |
* points, but they are used to cover the possible colors.) |
*/ |
if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1; |
if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1; |
if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1; |
if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1; |
if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1; |
if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1; |
if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1; |
if (xy->whitey < 0 || xy->whitey > PNG_FP_1-xy->whitex) return 1; |
/* The reverse calculation is more difficult because the original tristimulus |
* value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8 |
* derived values were recorded in the cHRM chunk; |
* (red,green,blue,white)x(x,y). This loses one degree of freedom and |
* therefore an arbitrary ninth value has to be introduced to undo the |
* original transformations. |
* |
* Think of the original end-points as points in (X,Y,Z) space. The |
* chromaticity values (c) have the property: |
* |
* C |
* c = --------- |
* X + Y + Z |
* |
* For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the |
* three chromaticity values (x,y,z) for each end-point obey the |
* relationship: |
* |
* x + y + z = 1 |
* |
* This describes the plane in (X,Y,Z) space that intersects each axis at the |
* value 1.0; call this the chromaticity plane. Thus the chromaticity |
* calculation has scaled each end-point so that it is on the x+y+z=1 plane |
* and chromaticity is the intersection of the vector from the origin to the |
* (X,Y,Z) value with the chromaticity plane. |
* |
* To fully invert the chromaticity calculation we would need the three |
* end-point scale factors, (red-scale, green-scale, blue-scale), but these |
* were not recorded. Instead we calculated the reference white (X,Y,Z) and |
* recorded the chromaticity of this. The reference white (X,Y,Z) would have |
* given all three of the scale factors since: |
* |
* color-C = color-c * color-scale |
* white-C = red-C + green-C + blue-C |
* = red-c*red-scale + green-c*green-scale + blue-c*blue-scale |
* |
* But cHRM records only white-x and white-y, so we have lost the white scale |
* factor: |
* |
* white-C = white-c*white-scale |
* |
* To handle this the inverse transformation makes an arbitrary assumption |
* about white-scale: |
* |
* Assume: white-Y = 1.0 |
* Hence: white-scale = 1/white-y |
* Or: red-Y + green-Y + blue-Y = 1.0 |
* |
* Notice the last statement of the assumption gives an equation in three of |
* the nine values we want to calculate. 8 more equations come from the |
* above routine as summarised at the top above (the chromaticity |
* calculation): |
* |
* Given: color-x = color-X / (color-X + color-Y + color-Z) |
* Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0 |
* |
* This is 9 simultaneous equations in the 9 variables "color-C" and can be |
* solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix |
* determinants, however this is not as bad as it seems because only 28 of |
* the total of 90 terms in the various matrices are non-zero. Nevertheless |
* Cramer's rule is notoriously numerically unstable because the determinant |
* calculation involves the difference of large, but similar, numbers. It is |
* difficult to be sure that the calculation is stable for real world values |
* and it is certain that it becomes unstable where the end points are close |
* together. |
* |
* So this code uses the perhaps slightly less optimal but more |
* understandable and totally obvious approach of calculating color-scale. |
* |
* This algorithm depends on the precision in white-scale and that is |
* (1/white-y), so we can immediately see that as white-y approaches 0 the |
* accuracy inherent in the cHRM chunk drops off substantially. |
* |
* libpng arithmetic: a simple invertion of the above equations |
* ------------------------------------------------------------ |
* |
* white_scale = 1/white-y |
* white-X = white-x * white-scale |
* white-Y = 1.0 |
* white-Z = (1 - white-x - white-y) * white_scale |
* |
* white-C = red-C + green-C + blue-C |
* = red-c*red-scale + green-c*green-scale + blue-c*blue-scale |
* |
* This gives us three equations in (red-scale,green-scale,blue-scale) where |
* all the coefficients are now known: |
* |
* red-x*red-scale + green-x*green-scale + blue-x*blue-scale |
* = white-x/white-y |
* red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1 |
* red-z*red-scale + green-z*green-scale + blue-z*blue-scale |
* = (1 - white-x - white-y)/white-y |
* |
* In the last equation color-z is (1 - color-x - color-y) so we can add all |
* three equations together to get an alternative third: |
* |
* red-scale + green-scale + blue-scale = 1/white-y = white-scale |
* |
* So now we have a Cramer's rule solution where the determinants are just |
* 3x3 - far more tractible. Unfortunately 3x3 determinants still involve |
* multiplication of three coefficients so we can't guarantee to avoid |
* overflow in the libpng fixed point representation. Using Cramer's rule in |
* floating point is probably a good choice here, but it's not an option for |
* fixed point. Instead proceed to simplify the first two equations by |
* eliminating what is likely to be the largest value, blue-scale: |
* |
* blue-scale = white-scale - red-scale - green-scale |
* |
* Hence: |
* |
* (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale = |
* (white-x - blue-x)*white-scale |
* |
* (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale = |
* 1 - blue-y*white-scale |
* |
* And now we can trivially solve for (red-scale,green-scale): |
* |
* green-scale = |
* (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale |
* ----------------------------------------------------------- |
* green-x - blue-x |
* |
* red-scale = |
* 1 - blue-y*white-scale - (green-y - blue-y) * green-scale |
* --------------------------------------------------------- |
* red-y - blue-y |
* |
* Hence: |
* |
* red-scale = |
* ( (green-x - blue-x) * (white-y - blue-y) - |
* (green-y - blue-y) * (white-x - blue-x) ) / white-y |
* ------------------------------------------------------------------------- |
* (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) |
* |
* green-scale = |
* ( (red-y - blue-y) * (white-x - blue-x) - |
* (red-x - blue-x) * (white-y - blue-y) ) / white-y |
* ------------------------------------------------------------------------- |
* (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) |
* |
* Accuracy: |
* The input values have 5 decimal digits of accuracy. The values are all in |
* the range 0 < value < 1, so simple products are in the same range but may |
* need up to 10 decimal digits to preserve the original precision and avoid |
* underflow. Because we are using a 32-bit signed representation we cannot |
* match this; the best is a little over 9 decimal digits, less than 10. |
* |
* The approach used here is to preserve the maximum precision within the |
* signed representation. Because the red-scale calculation above uses the |
* difference between two products of values that must be in the range -1..+1 |
* it is sufficient to divide the product by 7; ceil(100,000/32767*2). The |
* factor is irrelevant in the calculation because it is applied to both |
* numerator and denominator. |
* |
* Note that the values of the differences of the products of the |
* chromaticities in the above equations tend to be small, for example for |
* the sRGB chromaticities they are: |
* |
* red numerator: -0.04751 |
* green numerator: -0.08788 |
* denominator: -0.2241 (without white-y multiplication) |
* |
* The resultant Y coefficients from the chromaticities of some widely used |
* color space definitions are (to 15 decimal places): |
* |
* sRGB |
* 0.212639005871510 0.715168678767756 0.072192315360734 |
* Kodak ProPhoto |
* 0.288071128229293 0.711843217810102 0.000085653960605 |
* Adobe RGB |
* 0.297344975250536 0.627363566255466 0.075291458493998 |
* Adobe Wide Gamut RGB |
* 0.258728243040113 0.724682314948566 0.016589442011321 |
*/ |
/* By the argument, above overflow should be impossible here. The return |
* value of 2 indicates an internal error to the caller. |
*/ |
if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7)) |
return 2; |
if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7)) |
return 2; |
denominator = left - right; |
/* Now find the red numerator. */ |
if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7)) |
return 2; |
if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7)) |
return 2; |
/* Overflow is possible here and it indicates an extreme set of PNG cHRM |
* chunk values. This calculation actually returns the reciprocal of the |
* scale value because this allows us to delay the multiplication of white-y |
* into the denominator, which tends to produce a small number. |
*/ |
if (!png_muldiv(&red_inverse, xy->whitey, denominator, left-right) || |
red_inverse <= xy->whitey /* r+g+b scales = white scale */) |
return 1; |
/* Similarly for green_inverse: */ |
if (!png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7)) |
return 2; |
if (!png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7)) |
return 2; |
if (!png_muldiv(&green_inverse, xy->whitey, denominator, left-right) || |
green_inverse <= xy->whitey) |
return 1; |
/* And the blue scale, the checks above guarantee this can't overflow but it |
* can still produce 0 for extreme cHRM values. |
*/ |
blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) - |
png_reciprocal(green_inverse); |
if (blue_scale <= 0) return 1; |
/* And fill in the png_XYZ: */ |
if (!png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse)) return 1; |
if (!png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse)) return 1; |
if (!png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1, |
red_inverse)) |
return 1; |
if (!png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse)) |
return 1; |
if (!png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse)) |
return 1; |
if (!png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1, |
green_inverse)) |
return 1; |
if (!png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1)) return 1; |
if (!png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1)) return 1; |
if (!png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale, |
PNG_FP_1)) |
return 1; |
return 0; /*success*/ |
} |
static int |
png_XYZ_normalize(png_XYZ *XYZ) |
{ |
png_int_32 Y; |
if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 || |
XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 || |
XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0) |
return 1; |
/* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1. |
* IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore |
* relying on addition of two positive values producing a negative one is not |
* safe. |
*/ |
Y = XYZ->red_Y; |
if (0x7fffffff - Y < XYZ->green_X) return 1; |
Y += XYZ->green_Y; |
if (0x7fffffff - Y < XYZ->blue_X) return 1; |
Y += XYZ->blue_Y; |
if (Y != PNG_FP_1) |
{ |
if (!png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y)) return 1; |
if (!png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y)) return 1; |
} |
return 0; |
} |
static int |
png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta) |
{ |
/* Allow an error of +/-0.01 (absolute value) on each chromaticity */ |
return !(PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) || |
PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) || |
PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) || |
PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) || |
PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) || |
PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) || |
PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) || |
PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta)); |
} |
/* Added in libpng-1.6.0, a different check for the validity of a set of cHRM |
* chunk chromaticities. Earlier checks used to simply look for the overflow |
* condition (where the determinant of the matrix to solve for XYZ ends up zero |
* because the chromaticity values are not all distinct.) Despite this it is |
* theoretically possible to produce chromaticities that are apparently valid |
* but that rapidly degrade to invalid, potentially crashing, sets because of |
* arithmetic inaccuracies when calculations are performed on them. The new |
* check is to round-trip xy -> XYZ -> xy and then check that the result is |
* within a small percentage of the original. |
*/ |
static int |
png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy) |
{ |
int result; |
png_xy xy_test; |
/* As a side-effect this routine also returns the XYZ endpoints. */ |
result = png_XYZ_from_xy(XYZ, xy); |
if (result) return result; |
result = png_xy_from_XYZ(&xy_test, XYZ); |
if (result) return result; |
if (png_colorspace_endpoints_match(xy, &xy_test, |
5/*actually, the math is pretty accurate*/)) |
return 0; |
/* Too much slip */ |
return 1; |
} |
/* This is the check going the other way. The XYZ is modified to normalize it |
* (another side-effect) and the xy chromaticities are returned. |
*/ |
static int |
png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ) |
{ |
int result; |
png_XYZ XYZtemp; |
result = png_XYZ_normalize(XYZ); |
if (result) return result; |
result = png_xy_from_XYZ(xy, XYZ); |
if (result) return result; |
XYZtemp = *XYZ; |
return png_colorspace_check_xy(&XYZtemp, xy); |
} |
/* Used to check for an endpoint match against sRGB */ |
static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */ |
{ |
/* color x y */ |
/* red */ 64000, 33000, |
/* green */ 30000, 60000, |
/* blue */ 15000, 6000, |
/* white */ 31270, 32900 |
}; |
static int |
png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr, |
png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ, |
int preferred) |
{ |
if (colorspace->flags & PNG_COLORSPACE_INVALID) |
return 0; |
/* The consistency check is performed on the chromaticities; this factors out |
* variations because of the normalization (or not) of the end point Y |
* values. |
*/ |
if (preferred < 2 && (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) |
{ |
/* The end points must be reasonably close to any we already have. The |
* following allows an error of up to +/-.001 |
*/ |
if (!png_colorspace_endpoints_match(xy, &colorspace->end_points_xy, 100)) |
{ |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_benign_error(png_ptr, "inconsistent chromaticities"); |
return 0; /* failed */ |
} |
/* Only overwrite with preferred values */ |
if (!preferred) |
return 1; /* ok, but no change */ |
} |
colorspace->end_points_xy = *xy; |
colorspace->end_points_XYZ = *XYZ; |
colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS; |
/* The end points are normally quoted to two decimal digits, so allow +/-0.01 |
* on this test. |
*/ |
if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000)) |
colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB; |
else |
colorspace->flags &= PNG_COLORSPACE_CANCEL( |
PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB); |
return 2; /* ok and changed */ |
} |
int /* PRIVATE */ |
png_check_cHRM_fixed(png_structp png_ptr, |
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, |
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, |
png_fixed_point blue_x, png_fixed_point blue_y) |
png_colorspace_set_chromaticities(png_const_structrp png_ptr, |
png_colorspacerp colorspace, const png_xy *xy, int preferred) |
{ |
int ret = 1; |
unsigned long xy_hi,xy_lo,yx_hi,yx_lo; |
/* We must check the end points to ensure they are reasonable - in the past |
* color management systems have crashed as a result of getting bogus |
* colorant values, while this isn't the fault of libpng it is the |
* responsibility of libpng because PNG carries the bomb and libpng is in a |
* position to protect against it. |
*/ |
png_XYZ XYZ; |
png_debug(1, "in function png_check_cHRM_fixed"); |
switch (png_colorspace_check_xy(&XYZ, xy)) |
{ |
case 0: /* success */ |
return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ, |
preferred); |
if (png_ptr == NULL) |
case 1: |
/* We can't invert the chromaticities so we can't produce value XYZ |
* values. Likely as not a color management system will fail too. |
*/ |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_benign_error(png_ptr, "invalid chromaticities"); |
break; |
default: |
/* libpng is broken; this should be a warning but if it happens we |
* want error reports so for the moment it is an error. |
*/ |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_error(png_ptr, "internal error checking chromaticities"); |
break; |
} |
return 0; /* failed */ |
} |
int /* PRIVATE */ |
png_colorspace_set_endpoints(png_const_structrp png_ptr, |
png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred) |
{ |
png_XYZ XYZ = *XYZ_in; |
png_xy xy; |
switch (png_colorspace_check_XYZ(&xy, &XYZ)) |
{ |
case 0: |
return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ, |
preferred); |
case 1: |
/* End points are invalid. */ |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_benign_error(png_ptr, "invalid end points"); |
break; |
default: |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
png_error(png_ptr, "internal error checking chromaticities"); |
break; |
} |
return 0; /* failed */ |
} |
#if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED) |
/* Error message generation */ |
static char |
png_icc_tag_char(png_uint_32 byte) |
{ |
byte &= 0xff; |
if (byte >= 32 && byte <= 126) |
return (char)byte; |
else |
return '?'; |
} |
static void |
png_icc_tag_name(char *name, png_uint_32 tag) |
{ |
name[0] = '\''; |
name[1] = png_icc_tag_char(tag >> 24); |
name[2] = png_icc_tag_char(tag >> 16); |
name[3] = png_icc_tag_char(tag >> 8); |
name[4] = png_icc_tag_char(tag ); |
name[5] = '\''; |
} |
static int |
is_ICC_signature_char(png_alloc_size_t it) |
{ |
return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) || |
(it >= 97 && it <= 122); |
} |
static int is_ICC_signature(png_alloc_size_t it) |
{ |
return is_ICC_signature_char(it >> 24) /* checks all the top bits */ && |
is_ICC_signature_char((it >> 16) & 0xff) && |
is_ICC_signature_char((it >> 8) & 0xff) && |
is_ICC_signature_char(it & 0xff); |
} |
static int |
png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace, |
png_const_charp name, png_alloc_size_t value, png_const_charp reason) |
{ |
size_t pos; |
char message[196]; /* see below for calculation */ |
if (colorspace != NULL) |
colorspace->flags |= PNG_COLORSPACE_INVALID; |
pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */ |
pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */ |
pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */ |
if (is_ICC_signature(value)) |
{ |
/* So 'value' is at most 4 bytes and the following cast is safe */ |
png_icc_tag_name(message+pos, (png_uint_32)value); |
pos += 6; /* total +8; less than the else clause */ |
message[pos++] = ':'; |
message[pos++] = ' '; |
} |
# ifdef PNG_WARNINGS_SUPPORTED |
else |
{ |
char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/ |
pos = png_safecat(message, (sizeof message), pos, |
png_format_number(number, number+(sizeof number), |
PNG_NUMBER_FORMAT_x, value)); |
pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/ |
} |
# endif |
/* The 'reason' is an arbitrary message, allow +79 maximum 195 */ |
pos = png_safecat(message, (sizeof message), pos, reason); |
/* This is recoverable, but make it unconditionally an app_error on write to |
* avoid writing invalid ICC profiles into PNG files. (I.e. we handle them |
* on read, with a warning, but on write unless the app turns off |
* application errors the PNG won't be written.) |
*/ |
png_chunk_report(png_ptr, message, |
(colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR); |
return 0; |
} |
#endif /* sRGB || iCCP */ |
if (white_x < 0 || white_y <= 0 || |
red_x < 0 || red_y < 0 || |
green_x < 0 || green_y < 0 || |
blue_x < 0 || blue_y < 0) |
#ifdef PNG_sRGB_SUPPORTED |
int /* PRIVATE */ |
png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace, |
int intent) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set negative chromaticity value"); |
ret = 0; |
/* sRGB sets known gamma, end points and (from the chunk) intent. */ |
/* IMPORTANT: these are not necessarily the values found in an ICC profile |
* because ICC profiles store values adapted to a D50 environment; it is |
* expected that the ICC profile mediaWhitePointTag will be D50, see the |
* checks and code elsewhere to understand this better. |
* |
* These XYZ values, which are accurate to 5dp, produce rgb to gray |
* coefficients of (6968,23435,2366), which are reduced (because they add up |
* to 32769 not 32768) to (6968,23434,2366). These are the values that |
* libpng has traditionally used (and are the best values given the 15bit |
* algorithm used by the rgb to gray code.) |
*/ |
static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */ |
{ |
/* color X Y Z */ |
/* red */ 41239, 21264, 1933, |
/* green */ 35758, 71517, 11919, |
/* blue */ 18048, 7219, 95053 |
}; |
/* Do nothing if the colorspace is already invalidated. */ |
if (colorspace->flags & PNG_COLORSPACE_INVALID) |
return 0; |
/* Check the intent, then check for existing settings. It is valid for the |
* PNG file to have cHRM or gAMA chunks along with sRGB, but the values must |
* be consistent with the correct values. If, however, this function is |
* called below because an iCCP chunk matches sRGB then it is quite |
* conceivable that an older app recorded incorrect gAMA and cHRM because of |
* an incorrect calculation based on the values in the profile - this does |
* *not* invalidate the profile (though it still produces an error, which can |
* be ignored.) |
*/ |
if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST) |
return png_icc_profile_error(png_ptr, colorspace, "sRGB", |
(unsigned)intent, "invalid sRGB rendering intent"); |
if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 && |
colorspace->rendering_intent != intent) |
return png_icc_profile_error(png_ptr, colorspace, "sRGB", |
(unsigned)intent, "inconsistent rendering intents"); |
if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0) |
{ |
png_benign_error(png_ptr, "duplicate sRGB information ignored"); |
return 0; |
} |
if (white_x > (png_fixed_point)PNG_UINT_31_MAX || |
white_y > (png_fixed_point)PNG_UINT_31_MAX || |
red_x > (png_fixed_point)PNG_UINT_31_MAX || |
red_y > (png_fixed_point)PNG_UINT_31_MAX || |
green_x > (png_fixed_point)PNG_UINT_31_MAX || |
green_y > (png_fixed_point)PNG_UINT_31_MAX || |
blue_x > (png_fixed_point)PNG_UINT_31_MAX || |
blue_y > (png_fixed_point)PNG_UINT_31_MAX ) |
/* If the standard sRGB cHRM chunk does not match the one from the PNG file |
* warn but overwrite the value with the correct one. |
*/ |
if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 && |
!png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy, |
100)) |
png_chunk_report(png_ptr, "cHRM chunk does not match sRGB", |
PNG_CHUNK_ERROR); |
/* This check is just done for the error reporting - the routine always |
* returns true when the 'from' argument corresponds to sRGB (2). |
*/ |
(void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE, |
2/*from sRGB*/); |
/* intent: bugs in GCC force 'int' to be used as the parameter type. */ |
colorspace->rendering_intent = (png_uint_16)intent; |
colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT; |
/* endpoints */ |
colorspace->end_points_xy = sRGB_xy; |
colorspace->end_points_XYZ = sRGB_XYZ; |
colorspace->flags |= |
(PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB); |
/* gamma */ |
colorspace->gamma = PNG_GAMMA_sRGB_INVERSE; |
colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA; |
/* Finally record that we have an sRGB profile */ |
colorspace->flags |= |
(PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB); |
return 1; /* set */ |
} |
#endif /* sRGB */ |
#ifdef PNG_iCCP_SUPPORTED |
/* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value |
* is XYZ(0.9642,1.0,0.8249), which scales to: |
* |
* (63189.8112, 65536, 54060.6464) |
*/ |
static const png_byte D50_nCIEXYZ[12] = |
{ 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d }; |
int /* PRIVATE */ |
png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, |
png_const_charp name, png_uint_32 profile_length) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
ret = 0; |
if (profile_length < 132) |
return png_icc_profile_error(png_ptr, colorspace, name, profile_length, |
"too short"); |
if (profile_length & 3) |
return png_icc_profile_error(png_ptr, colorspace, name, profile_length, |
"invalid length"); |
return 1; |
} |
if (white_x > 100000L - white_y) |
int /* PRIVATE */ |
png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace, |
png_const_charp name, png_uint_32 profile_length, |
png_const_bytep profile/* first 132 bytes only */, int color_type) |
{ |
png_warning(png_ptr, "Invalid cHRM white point"); |
ret = 0; |
png_uint_32 temp; |
/* Length check; this cannot be ignored in this code because profile_length |
* is used later to check the tag table, so even if the profile seems over |
* long profile_length from the caller must be correct. The caller can fix |
* this up on read or write by just passing in the profile header length. |
*/ |
temp = png_get_uint_32(profile); |
if (temp != profile_length) |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"length does not match profile"); |
temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */ |
if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */ |
profile_length < 132+12*temp) /* truncated tag table */ |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"tag count too large"); |
/* The 'intent' must be valid or we can't store it, ICC limits the intent to |
* 16 bits. |
*/ |
temp = png_get_uint_32(profile+64); |
if (temp >= 0xffff) /* The ICC limit */ |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"invalid rendering intent"); |
/* This is just a warning because the profile may be valid in future |
* versions. |
*/ |
if (temp >= PNG_sRGB_INTENT_LAST) |
(void)png_icc_profile_error(png_ptr, NULL, name, temp, |
"intent outside defined range"); |
/* At this point the tag table can't be checked because it hasn't necessarily |
* been loaded; however, various header fields can be checked. These checks |
* are for values permitted by the PNG spec in an ICC profile; the PNG spec |
* restricts the profiles that can be passed in an iCCP chunk (they must be |
* appropriate to processing PNG data!) |
*/ |
/* Data checks (could be skipped). These checks must be independent of the |
* version number; however, the version number doesn't accomodate changes in |
* the header fields (just the known tags and the interpretation of the |
* data.) |
*/ |
temp = png_get_uint_32(profile+36); /* signature 'ascp' */ |
if (temp != 0x61637370) |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"invalid signature"); |
/* Currently the PCS illuminant/adopted white point (the computational |
* white point) are required to be D50, |
* however the profile contains a record of the illuminant so perhaps ICC |
* expects to be able to change this in the future (despite the rationale in |
* the introduction for using a fixed PCS adopted white.) Consequently the |
* following is just a warning. |
*/ |
if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0) |
(void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/, |
"PCS illuminant is not D50"); |
/* The PNG spec requires this: |
* "If the iCCP chunk is present, the image samples conform to the colour |
* space represented by the embedded ICC profile as defined by the |
* International Color Consortium [ICC]. The colour space of the ICC profile |
* shall be an RGB colour space for colour images (PNG colour types 2, 3, and |
* 6), or a greyscale colour space for greyscale images (PNG colour types 0 |
* and 4)." |
* |
* This checking code ensures the embedded profile (on either read or write) |
* conforms to the specification requirements. Notice that an ICC 'gray' |
* color-space profile contains the information to transform the monochrome |
* data to XYZ or L*a*b (according to which PCS the profile uses) and this |
* should be used in preference to the standard libpng K channel replication |
* into R, G and B channels. |
* |
* Previously it was suggested that an RGB profile on grayscale data could be |
* handled. However it it is clear that using an RGB profile in this context |
* must be an error - there is no specification of what it means. Thus it is |
* almost certainly more correct to ignore the profile. |
*/ |
temp = png_get_uint_32(profile+16); /* data colour space field */ |
switch (temp) |
{ |
case 0x52474220: /* 'RGB ' */ |
if (!(color_type & PNG_COLOR_MASK_COLOR)) |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"RGB color space not permitted on grayscale PNG"); |
break; |
case 0x47524159: /* 'GRAY' */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"Gray color space not permitted on RGB PNG"); |
break; |
default: |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"invalid ICC profile color space"); |
} |
if (red_x > 100000L - red_y) |
/* It is up to the application to check that the profile class matches the |
* application requirements; the spec provides no guidance, but it's pretty |
* weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer |
* ('prtr') or 'spac' (for generic color spaces). Issue a warning in these |
* cases. Issue an error for device link or abstract profiles - these don't |
* contain the records necessary to transform the color-space to anything |
* other than the target device (and not even that for an abstract profile). |
* Profiles of these classes may not be embedded in images. |
*/ |
temp = png_get_uint_32(profile+12); /* profile/device class */ |
switch (temp) |
{ |
png_warning(png_ptr, "Invalid cHRM red point"); |
ret = 0; |
case 0x73636E72: /* 'scnr' */ |
case 0x6D6E7472: /* 'mntr' */ |
case 0x70727472: /* 'prtr' */ |
case 0x73706163: /* 'spac' */ |
/* All supported */ |
break; |
case 0x61627374: /* 'abst' */ |
/* May not be embedded in an image */ |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"invalid embedded Abstract ICC profile"); |
case 0x6C696E6B: /* 'link' */ |
/* DeviceLink profiles cannnot be interpreted in a non-device specific |
* fashion, if an app uses the AToB0Tag in the profile the results are |
* undefined unless the result is sent to the intended device, |
* therefore a DeviceLink profile should not be found embedded in a |
* PNG. |
*/ |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"unexpected DeviceLink ICC profile class"); |
case 0x6E6D636C: /* 'nmcl' */ |
/* A NamedColor profile is also device specific, however it doesn't |
* contain an AToB0 tag that is open to misintrepretation. Almost |
* certainly it will fail the tests below. |
*/ |
(void)png_icc_profile_error(png_ptr, NULL, name, temp, |
"unexpected NamedColor ICC profile class"); |
break; |
default: |
/* To allow for future enhancements to the profile accept unrecognized |
* profile classes with a warning, these then hit the test below on the |
* tag content to ensure they are backward compatible with one of the |
* understood profiles. |
*/ |
(void)png_icc_profile_error(png_ptr, NULL, name, temp, |
"unrecognized ICC profile class"); |
break; |
} |
if (green_x > 100000L - green_y) |
/* For any profile other than a device link one the PCS must be encoded |
* either in XYZ or Lab. |
*/ |
temp = png_get_uint_32(profile+20); |
switch (temp) |
{ |
png_warning(png_ptr, "Invalid cHRM green point"); |
ret = 0; |
case 0x58595A20: /* 'XYZ ' */ |
case 0x4C616220: /* 'Lab ' */ |
break; |
default: |
return png_icc_profile_error(png_ptr, colorspace, name, temp, |
"unexpected ICC PCS encoding"); |
} |
if (blue_x > 100000L - blue_y) |
return 1; |
} |
int /* PRIVATE */ |
png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace, |
png_const_charp name, png_uint_32 profile_length, |
png_const_bytep profile /* header plus whole tag table */) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point"); |
ret = 0; |
png_uint_32 tag_count = png_get_uint_32(profile+128); |
png_uint_32 itag; |
png_const_bytep tag = profile+132; /* The first tag */ |
/* First scan all the tags in the table and add bits to the icc_info value |
* (temporarily in 'tags'). |
*/ |
for (itag=0; itag < tag_count; ++itag, tag += 12) |
{ |
png_uint_32 tag_id = png_get_uint_32(tag+0); |
png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */ |
png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */ |
/* The ICC specification does not exclude zero length tags, therefore the |
* start might actually be anywhere if there is no data, but this would be |
* a clear abuse of the intent of the standard so the start is checked for |
* being in range. All defined tag types have an 8 byte header - a 4 byte |
* type signature then 0. |
*/ |
if ((tag_start & 3) != 0) |
{ |
/* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is |
* only a warning here because libpng does not care about the |
* alignment. |
*/ |
(void)png_icc_profile_error(png_ptr, NULL, name, tag_id, |
"ICC profile tag start not a multiple of 4"); |
} |
png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo); |
png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo); |
/* This is a hard error; potentially it can cause read outside the |
* profile. |
*/ |
if (tag_start > profile_length || tag_length > profile_length - tag_start) |
return png_icc_profile_error(png_ptr, colorspace, name, tag_id, |
"ICC profile tag outside profile"); |
} |
if (xy_hi == yx_hi && xy_lo == yx_lo) |
return 1; /* success, maybe with warnings */ |
} |
#ifdef PNG_sRGB_SUPPORTED |
/* Information about the known ICC sRGB profiles */ |
static const struct |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set cHRM RGB triangle with zero area"); |
ret = 0; |
png_uint_32 adler, crc, length; |
png_uint_32 md5[4]; |
png_byte have_md5; |
png_byte is_broken; |
png_uint_16 intent; |
# define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0) |
# define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\ |
{ adler, crc, length, md5, broke, intent }, |
} png_sRGB_checks[] = |
{ |
/* This data comes from contrib/tools/checksum-icc run on downloads of |
* all four ICC sRGB profiles from www.color.org. |
*/ |
/* adler32, crc32, MD5[4], intent, date, length, file-name */ |
PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9, |
PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0, |
"2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc") |
/* ICC sRGB v2 perceptual no black-compensation: */ |
PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21, |
PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0, |
"2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc") |
PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae, |
PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0, |
"2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc") |
/* ICC sRGB v4 perceptual */ |
PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812, |
PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0, |
"2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc") |
/* The following profiles have no known MD5 checksum. If there is a match |
* on the (empty) MD5 the other fields are used to attempt a match and |
* a warning is produced. The first two of these profiles have a 'cprt' tag |
* which suggests that they were also made by Hewlett Packard. |
*/ |
PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce, |
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0, |
"2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc") |
/* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not |
* match the D50 PCS illuminant in the header (it is in fact the D65 values, |
* so the white point is recorded as the un-adapted value.) The profiles |
* below only differ in one byte - the intent - and are basically the same as |
* the previous profile except for the mediaWhitePointTag error and a missing |
* chromaticAdaptationTag. |
*/ |
PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552, |
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/, |
"1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual") |
PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d, |
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/, |
"1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative") |
}; |
static int |
png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr, |
png_const_bytep profile, uLong adler) |
{ |
/* The quick check is to verify just the MD5 signature and trust the |
* rest of the data. Because the profile has already been verified for |
* correctness this is safe. png_colorspace_set_sRGB will check the 'intent' |
* field too, so if the profile has been edited with an intent not defined |
* by sRGB (but maybe defined by a later ICC specification) the read of |
* the profile will fail at that point. |
*/ |
png_uint_32 length = 0; |
png_uint_32 intent = 0x10000; /* invalid */ |
#if PNG_sRGB_PROFILE_CHECKS > 1 |
uLong crc = 0; /* the value for 0 length data */ |
#endif |
unsigned int i; |
for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i) |
{ |
if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] && |
png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] && |
png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] && |
png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3]) |
{ |
/* This may be one of the old HP profiles without an MD5, in that |
* case we can only use the length and Adler32 (note that these |
* are not used by default if there is an MD5!) |
*/ |
# if PNG_sRGB_PROFILE_CHECKS == 0 |
if (png_sRGB_checks[i].have_md5) |
return 1+png_sRGB_checks[i].is_broken; |
# endif |
/* Profile is unsigned or more checks have been configured in. */ |
if (length == 0) |
{ |
length = png_get_uint_32(profile); |
intent = png_get_uint_32(profile+64); |
} |
return ret; |
/* Length *and* intent must match */ |
if (length == png_sRGB_checks[i].length && |
intent == png_sRGB_checks[i].intent) |
{ |
/* Now calculate the adler32 if not done already. */ |
if (adler == 0) |
{ |
adler = adler32(0, NULL, 0); |
adler = adler32(adler, profile, length); |
} |
# endif /* PNG_CHECK_cHRM_SUPPORTED */ |
if (adler == png_sRGB_checks[i].adler) |
{ |
/* These basic checks suggest that the data has not been |
* modified, but if the check level is more than 1 perform |
* our own crc32 checksum on the data. |
*/ |
# if PNG_sRGB_PROFILE_CHECKS > 1 |
if (crc == 0) |
{ |
crc = crc32(0, NULL, 0); |
crc = crc32(crc, profile, length); |
} |
/* So this check must pass for the 'return' below to happen. |
*/ |
if (crc == png_sRGB_checks[i].crc) |
# endif |
{ |
if (png_sRGB_checks[i].is_broken) |
{ |
/* These profiles are known to have bad data that may cause |
* problems if they are used, therefore attempt to |
* discourage their use, skip the 'have_md5' warning below, |
* which is made irrelevant by this error. |
*/ |
png_chunk_report(png_ptr, "known incorrect sRGB profile", |
PNG_CHUNK_ERROR); |
} |
/* Warn that this being done; this isn't even an error since |
* the profile is perfectly valid, but it would be nice if |
* people used the up-to-date ones. |
*/ |
else if (!png_sRGB_checks[i].have_md5) |
{ |
png_chunk_report(png_ptr, |
"out-of-date sRGB profile with no signature", |
PNG_CHUNK_WARNING); |
} |
return 1+png_sRGB_checks[i].is_broken; |
} |
} |
} |
# if PNG_sRGB_PROFILE_CHECKS > 0 |
/* The signature matched, but the profile had been changed in some |
* way. This is an apparent violation of the ICC terms of use and, |
* anyway, probably indicates a data error or uninformed hacking. |
*/ |
if (png_sRGB_checks[i].have_md5) |
png_benign_error(png_ptr, |
"copyright violation: edited ICC profile ignored"); |
# endif |
} |
} |
return 0; /* no match */ |
} |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
void /* PRIVATE */ |
png_check_IHDR(png_structp png_ptr, |
png_icc_set_sRGB(png_const_structrp png_ptr, |
png_colorspacerp colorspace, png_const_bytep profile, uLong adler) |
{ |
/* Is this profile one of the known ICC sRGB profiles? If it is, just set |
* the sRGB information. |
*/ |
if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler)) |
(void)png_colorspace_set_sRGB(png_ptr, colorspace, |
(int)/*already checked*/png_get_uint_32(profile+64)); |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
int /* PRIVATE */ |
png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace, |
png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, |
int color_type) |
{ |
if (colorspace->flags & PNG_COLORSPACE_INVALID) |
return 0; |
if (png_icc_check_length(png_ptr, colorspace, name, profile_length) && |
png_icc_check_header(png_ptr, colorspace, name, profile_length, profile, |
color_type) && |
png_icc_check_tag_table(png_ptr, colorspace, name, profile_length, |
profile)) |
{ |
# ifdef PNG_sRGB_SUPPORTED |
/* If no sRGB support, don't try storing sRGB information */ |
png_icc_set_sRGB(png_ptr, colorspace, profile, 0); |
# endif |
return 1; |
} |
/* Failure case */ |
return 0; |
} |
#endif /* iCCP */ |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
void /* PRIVATE */ |
png_colorspace_set_rgb_coefficients(png_structrp png_ptr) |
{ |
/* Set the rgb_to_gray coefficients from the colorspace. */ |
if (!png_ptr->rgb_to_gray_coefficients_set && |
(png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) |
{ |
/* png_set_background has not been called, get the coefficients from the Y |
* values of the colorspace colorants. |
*/ |
png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y; |
png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y; |
png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y; |
png_fixed_point total = r+g+b; |
if (total > 0 && |
r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 && |
g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 && |
b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 && |
r+g+b <= 32769) |
{ |
/* We allow 0 coefficients here. r+g+b may be 32769 if two or |
* all of the coefficients were rounded up. Handle this by |
* reducing the *largest* coefficient by 1; this matches the |
* approach used for the default coefficients in pngrtran.c |
*/ |
int add = 0; |
if (r+g+b > 32768) |
add = -1; |
else if (r+g+b < 32768) |
add = 1; |
if (add != 0) |
{ |
if (g >= r && g >= b) |
g += add; |
else if (r >= g && r >= b) |
r += add; |
else |
b += add; |
} |
/* Check for an internal error. */ |
if (r+g+b != 32768) |
png_error(png_ptr, |
"internal error handling cHRM coefficients"); |
else |
{ |
png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r; |
png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g; |
} |
} |
/* This is a png_error at present even though it could be ignored - |
* it should never happen, but it is important that if it does, the |
* bug is fixed. |
*/ |
else |
png_error(png_ptr, "internal error handling cHRM->XYZ"); |
} |
} |
#endif |
#endif /* COLORSPACE */ |
void /* PRIVATE */ |
png_check_IHDR(png_const_structrp png_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
int filter_type) |
763,7 → 2377,7 |
} |
# ifdef PNG_SET_USER_LIMITS_SUPPORTED |
if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX) |
if (width > png_ptr->user_width_max) |
# else |
if (width > PNG_USER_WIDTH_MAX) |
774,7 → 2388,7 |
} |
# ifdef PNG_SET_USER_LIMITS_SUPPORTED |
if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX) |
if (height > png_ptr->user_height_max) |
# else |
if (height > PNG_USER_HEIGHT_MAX) |
# endif |
889,17 → 2503,10 |
/* Check an ASCII formated floating point value, see the more detailed |
* comments in pngpriv.h |
*/ |
/* The following is used internally to preserve the 'valid' flag */ |
/* The following is used internally to preserve the sticky flags */ |
#define png_fp_add(state, flags) ((state) |= (flags)) |
#define png_fp_set(state, value)\ |
((state) = (value) | ((state) & PNG_FP_WAS_VALID)) |
#define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY)) |
/* Internal type codes: bits above the base state! */ |
#define PNG_FP_SIGN 0 /* [+-] */ |
#define PNG_FP_DOT 4 /* . */ |
#define PNG_FP_DIGIT 8 /* [0123456789] */ |
#define PNG_FP_E 12 /* [Ee] */ |
int /* PRIVATE */ |
png_check_fp_number(png_const_charp string, png_size_t size, int *statep, |
png_size_tp whereami) |
911,55 → 2518,55 |
{ |
int type; |
/* First find the type of the next character */ |
switch (string[i]) |
{ |
char ch = string[i]; |
if (ch >= 48 && ch <= 57) |
type = PNG_FP_DIGIT; |
else switch (ch) |
{ |
case 43: case 45: type = PNG_FP_SIGN; break; |
case 46: type = PNG_FP_DOT; break; |
case 69: case 101: type = PNG_FP_E; break; |
case 43: type = PNG_FP_SAW_SIGN; break; |
case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break; |
case 46: type = PNG_FP_SAW_DOT; break; |
case 48: type = PNG_FP_SAW_DIGIT; break; |
case 49: case 50: case 51: case 52: |
case 53: case 54: case 55: case 56: |
case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break; |
case 69: |
case 101: type = PNG_FP_SAW_E; break; |
default: goto PNG_FP_End; |
} |
} |
/* Now deal with this type according to the current |
* state, the type is arranged to not overlap the |
* bits of the PNG_FP_STATE. |
*/ |
switch ((state & PNG_FP_STATE) + type) |
switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY)) |
{ |
case PNG_FP_INTEGER + PNG_FP_SIGN: |
case PNG_FP_INTEGER + PNG_FP_SAW_SIGN: |
if (state & PNG_FP_SAW_ANY) |
goto PNG_FP_End; /* not a part of the number */ |
png_fp_add(state, PNG_FP_SAW_SIGN); |
png_fp_add(state, type); |
break; |
case PNG_FP_INTEGER + PNG_FP_DOT: |
case PNG_FP_INTEGER + PNG_FP_SAW_DOT: |
/* Ok as trailer, ok as lead of fraction. */ |
if (state & PNG_FP_SAW_DOT) /* two dots */ |
goto PNG_FP_End; |
else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */ |
png_fp_add(state, PNG_FP_SAW_DOT); |
png_fp_add(state, type); |
else |
png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); |
png_fp_set(state, PNG_FP_FRACTION | type); |
break; |
case PNG_FP_INTEGER + PNG_FP_DIGIT: |
case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT: |
if (state & PNG_FP_SAW_DOT) /* delayed fraction */ |
png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
png_fp_add(state, type | PNG_FP_WAS_VALID); |
break; |
case PNG_FP_INTEGER + PNG_FP_E: |
case PNG_FP_INTEGER + PNG_FP_SAW_E: |
if ((state & PNG_FP_SAW_DIGIT) == 0) |
goto PNG_FP_End; |
967,17 → 2574,17 |
break; |
/* case PNG_FP_FRACTION + PNG_FP_SIGN: |
goto PNG_FP_End; ** no sign in exponent */ |
/* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN: |
goto PNG_FP_End; ** no sign in fraction */ |
/* case PNG_FP_FRACTION + PNG_FP_DOT: |
/* case PNG_FP_FRACTION + PNG_FP_SAW_DOT: |
goto PNG_FP_End; ** Because SAW_DOT is always set */ |
case PNG_FP_FRACTION + PNG_FP_DIGIT: |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT: |
png_fp_add(state, type | PNG_FP_WAS_VALID); |
break; |
case PNG_FP_FRACTION + PNG_FP_E: |
case PNG_FP_FRACTION + PNG_FP_SAW_E: |
/* This is correct because the trailing '.' on an |
* integer is handled above - so we can only get here |
* with the sequence ".E" (with no preceding digits). |
989,7 → 2596,7 |
break; |
case PNG_FP_EXPONENT + PNG_FP_SIGN: |
case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN: |
if (state & PNG_FP_SAW_ANY) |
goto PNG_FP_End; /* not a part of the number */ |
997,15 → 2604,15 |
break; |
/* case PNG_FP_EXPONENT + PNG_FP_DOT: |
/* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT: |
goto PNG_FP_End; */ |
case PNG_FP_EXPONENT + PNG_FP_DIGIT: |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT: |
png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID); |
break; |
/* case PNG_FP_EXPONEXT + PNG_FP_E: |
/* case PNG_FP_EXPONEXT + PNG_FP_SAW_E: |
goto PNG_FP_End; */ |
default: goto PNG_FP_End; /* I.e. break 2 */ |
1033,12 → 2640,15 |
int state=0; |
png_size_t char_index=0; |
return png_check_fp_number(string, size, &state, &char_index) && |
(char_index == size || string[char_index] == 0); |
if (png_check_fp_number(string, size, &state, &char_index) && |
(char_index == size || string[char_index] == 0)) |
return state /* must be non-zero - see above */; |
return 0; /* i.e. fail */ |
} |
#endif /* pCAL or sCAL */ |
#ifdef PNG_READ_sCAL_SUPPORTED |
#ifdef PNG_sCAL_SUPPORTED |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
/* Utility used below - a simple accurate power of ten from an integral |
* exponent. |
1081,7 → 2691,7 |
* precision. |
*/ |
void /* PRIVATE */ |
png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size, |
png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size, |
double fp, unsigned int precision) |
{ |
/* We use standard functions from math.h, but not printf because |
1330,19 → 2940,31 |
size -= cdigits; |
*ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision*/ |
/* The following use of an unsigned temporary avoids ambiguities in |
* the signed arithmetic on exp_b10 and permits GCC at least to do |
* better optimization. |
*/ |
{ |
unsigned int uexp_b10; |
if (exp_b10 < 0) |
{ |
*ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */ |
exp_b10 = -exp_b10; |
uexp_b10 = -exp_b10; |
} |
else |
uexp_b10 = exp_b10; |
cdigits = 0; |
while (exp_b10 > 0) |
while (uexp_b10 > 0) |
{ |
exponent[cdigits++] = (char)(48 + exp_b10 % 10); |
exp_b10 /= 10; |
exponent[cdigits++] = (char)(48 + uexp_b10 % 10); |
uexp_b10 /= 10; |
} |
} |
/* Need another size check here for the exponent digits, so |
* this need not be considered above. |
1383,8 → 3005,8 |
/* Function to format a fixed point value in ASCII. |
*/ |
void /* PRIVATE */ |
png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size, |
png_fixed_point fp) |
png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii, |
png_size_t size, png_fixed_point fp) |
{ |
/* Require space for 10 decimal digits, a decimal point, a minus sign and a |
* trailing \0, 13 characters: |
1399,7 → 3021,7 |
else |
num = fp; |
if (num <= 0x80000000U) /* else overflowed */ |
if (num <= 0x80000000) /* else overflowed */ |
{ |
unsigned int ndigits = 0, first = 16/*flag value*/; |
char digits[10]; |
1454,9 → 3076,14 |
#endif /* READ_SCAL */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && \ |
!defined(PNG_FIXED_POINT_MACRO_SUPPORTED) |
!defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \ |
(defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \ |
defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \ |
(defined(PNG_sCAL_SUPPORTED) && \ |
defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)) |
png_fixed_point |
png_fixed(png_structp png_ptr, double fp, png_const_charp text) |
png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text) |
{ |
double r = floor(100000 * fp + .5); |
1468,7 → 3095,7 |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || \ |
defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED) |
defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) |
/* muldiv functions */ |
/* This API takes signed arguments and rounds the result to the nearest |
* integer (or, for a fixed point number - the standard argument - to |
1495,7 → 3122,7 |
r /= divisor; |
r = floor(r+.5); |
/* A png_fixed_point is a 32 bit integer. */ |
/* A png_fixed_point is a 32-bit integer. */ |
if (r <= 2147483647. && r >= -2147483648.) |
{ |
*res = (png_fixed_point)r; |
1540,7 → 3167,7 |
if (s32 < D) /* else overflow */ |
{ |
/* s32.s00 is now the 64 bit product, do a standard |
/* s32.s00 is now the 64-bit product, do a standard |
* division, we know that s32 < D, so the maximum |
* required shift is 31. |
*/ |
1595,7 → 3222,7 |
* result. |
*/ |
png_fixed_point |
png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times, |
png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times, |
png_int_32 divisor) |
{ |
png_fixed_point result; |
1608,7 → 3235,7 |
} |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */ |
#ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */ |
/* Calculate a reciprocal, return 0 on div-by-zero or overflow. */ |
png_fixed_point |
png_reciprocal(png_fixed_point a) |
1628,6 → 3255,18 |
return 0; /* error/overflow */ |
} |
/* This is the shared test on whether a gamma value is 'significant' - whether |
* it is worth doing gamma correction. |
*/ |
int /* PRIVATE */ |
png_gamma_significant(png_fixed_point gamma_val) |
{ |
return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED || |
gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED; |
} |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* A local convenience routine. */ |
static png_fixed_point |
png_product2(png_fixed_point a, png_fixed_point b) |
1678,73 → 3317,28 |
} |
#endif /* READ_GAMMA */ |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
/* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2, |
* 2010: moved from pngset.c) */ |
/* |
* Multiply two 32-bit numbers, V1 and V2, using 32-bit |
* arithmetic, to produce a 64 bit result in the HI/LO words. |
* |
* A B |
* x C D |
* ------ |
* AD || BD |
* AC || CB || 0 |
* |
* where A and B are the high and low 16-bit words of V1, |
* C and D are the 16-bit words of V2, AD is the product of |
* A and D, and X || Y is (X << 16) + Y. |
*/ |
void /* PRIVATE */ |
png_64bit_product (long v1, long v2, unsigned long *hi_product, |
unsigned long *lo_product) |
{ |
int a, b, c, d; |
long lo, hi, x, y; |
a = (v1 >> 16) & 0xffff; |
b = v1 & 0xffff; |
c = (v2 >> 16) & 0xffff; |
d = v2 & 0xffff; |
lo = b * d; /* BD */ |
x = a * d + c * b; /* AD + CB */ |
y = ((lo >> 16) & 0xffff) + x; |
lo = (lo & 0xffff) | ((y & 0xffff) << 16); |
hi = (y >> 16) & 0xffff; |
hi += a * c; /* AC */ |
*hi_product = (unsigned long)hi; |
*lo_product = (unsigned long)lo; |
} |
#endif /* CHECK_cHRM */ |
#ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */ |
#ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED |
/* Fixed point gamma. |
* |
* The code to calculate the tables used below can be found in the shell script |
* contrib/tools/intgamma.sh |
* |
* To calculate gamma this code implements fast log() and exp() calls using only |
* fixed point arithmetic. This code has sufficient precision for either 8 or |
* 16 bit sample values. |
* fixed point arithmetic. This code has sufficient precision for either 8-bit |
* or 16-bit sample values. |
* |
* The tables used here were calculated using simple 'bc' programs, but C double |
* precision floating point arithmetic would work fine. The programs are given |
* at the head of each table. |
* precision floating point arithmetic would work fine. |
* |
* 8 bit log table |
* 8-bit log table |
* This is a table of -log(value/255)/log(2) for 'value' in the range 128 to |
* 255, so it's the base 2 logarithm of a normalized 8 bit floating point |
* mantissa. The numbers are 32 bit fractions. |
* 255, so it's the base 2 logarithm of a normalized 8-bit floating point |
* mantissa. The numbers are 32-bit fractions. |
*/ |
static png_uint_32 |
static const png_uint_32 |
png_8bit_l2[128] = |
{ |
# if PNG_DO_BC |
for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; } |
# endif |
4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U, |
3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U, |
3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U, |
1767,11 → 3361,12 |
324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U, |
172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U, |
24347096U, 0U |
#if 0 |
/* The following are the values for 16 bit tables - these work fine for the 8 |
* bit conversions but produce very slightly larger errors in the 16 bit log |
* (about 1.2 as opposed to 0.7 absolute error in the final value). To use |
* these all the shifts below must be adjusted appropriately. |
/* The following are the values for 16-bit tables - these work fine for the |
* 8-bit conversions but produce very slightly larger errors in the 16-bit |
* log (about 1.2 as opposed to 0.7 absolute error in the final value). To |
* use these all the shifts below must be adjusted appropriately. |
*/ |
65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054, |
57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803, |
1795,11 → 3390,11 |
/* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log, |
* because the log is actually negate that means adding 1. The final |
* returned value thus has the range 0 (for 255 input) to 7.994 (for 1 |
* input), return 7.99998 for the overflow (log 0) case - so the result is |
* input), return -1 for the overflow (log 0) case, - so the result is |
* always at most 19 bits. |
*/ |
if ((x &= 0xff) == 0) |
return 0xffffffff; |
return -1; |
if ((x & 0xf0) == 0) |
lg2 = 4, x <<= 4; |
1814,11 → 3409,11 |
return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16)); |
} |
/* The above gives exact (to 16 binary places) log2 values for 8 bit images, |
* for 16 bit images we use the most significant 8 bits of the 16 bit value to |
/* The above gives exact (to 16 binary places) log2 values for 8-bit images, |
* for 16-bit images we use the most significant 8 bits of the 16-bit value to |
* get an approximation then multiply the approximation by a correction factor |
* determined by the remaining up to 8 bits. This requires an additional step |
* in the 16 bit case. |
* in the 16-bit case. |
* |
* We want log2(value/65535), we have log2(v'/255), where: |
* |
1827,8 → 3422,8 |
* |
* So f is value/v', which is equal to (256+v''/v') since v' is in the range 128 |
* to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less |
* than 258. The final factor also needs to correct for the fact that our 8 bit |
* value is scaled by 255, whereas the 16 bit values must be scaled by 65535. |
* than 258. The final factor also needs to correct for the fact that our 8-bit |
* value is scaled by 255, whereas the 16-bit values must be scaled by 65535. |
* |
* This gives a final formula using a calculated value 'x' which is value/v' and |
* scaling by 65536 to match the above table: |
1838,7 → 3433,7 |
* Since these numbers are so close to '1' we can use simple linear |
* interpolation between the two end values 256/257 (result -368.61) and 258/257 |
* (result 367.179). The values used below are scaled by a further 64 to give |
* 16 bit precision in the interpolation: |
* 16-bit precision in the interpolation: |
* |
* Start (256): -23591 |
* Zero (257): 0 |
1851,7 → 3446,7 |
/* As above, but now the input has 16 bits. */ |
if ((x &= 0xffff) == 0) |
return 0xffffffff; |
return -1; |
if ((x & 0xff00) == 0) |
lg2 = 8, x <<= 8; |
1865,7 → 3460,7 |
if ((x & 0x8000) == 0) |
lg2 += 1, x <<= 1; |
/* Calculate the base logarithm from the top 8 bits as a 28 bit fractional |
/* Calculate the base logarithm from the top 8 bits as a 28-bit fractional |
* value. |
*/ |
lg2 <<= 28; |
1895,27 → 3490,24 |
return (png_int_32)((lg2 + 2048) >> 12); |
} |
/* The 'exp()' case must invert the above, taking a 20 bit fixed point |
* logarithmic value and returning a 16 or 8 bit number as appropriate. In |
/* The 'exp()' case must invert the above, taking a 20-bit fixed point |
* logarithmic value and returning a 16 or 8-bit number as appropriate. In |
* each case only the low 16 bits are relevant - the fraction - since the |
* integer bits (the top 4) simply determine a shift. |
* |
* The worst case is the 16 bit distinction between 65535 and 65534, this |
* The worst case is the 16-bit distinction between 65535 and 65534, this |
* requires perhaps spurious accuracty in the decoding of the logarithm to |
* distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance |
* of getting this accuracy in practice. |
* |
* To deal with this the following exp() function works out the exponent of the |
* frational part of the logarithm by using an accurate 32 bit value from the |
* frational part of the logarithm by using an accurate 32-bit value from the |
* top four fractional bits then multiplying in the remaining bits. |
*/ |
static png_uint_32 |
static const png_uint_32 |
png_32bit_exp[16] = |
{ |
# if PNG_DO_BC |
for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; } |
# endif |
/* NOTE: the first entry is deliberately set to the maximum 32 bit value. */ |
/* NOTE: the first entry is deliberately set to the maximum 32-bit value. */ |
4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U, |
3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U, |
2553802834U, 2445529972U, 2341847524U, 2242560872U |
1922,7 → 3514,7 |
}; |
/* Adjustment table; provided to explain the numbers in the code below. */ |
#if PNG_DO_BC |
#if 0 |
for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"} |
11 44937.64284865548751208448 |
10 45180.98734845585101160448 |
1943,7 → 3535,7 |
{ |
if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */ |
{ |
/* Obtain a 4 bit approximation */ |
/* Obtain a 4-bit approximation */ |
png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf]; |
/* Incorporate the low 12 bits - these decrease the returned value by |
1989,10 → 3581,10 |
static png_byte |
png_exp8bit(png_fixed_point lg2) |
{ |
/* Get a 32 bit value: */ |
/* Get a 32-bit value: */ |
png_uint_32 x = png_exp(lg2); |
/* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the |
/* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the |
* second, rounding, step can't overflow because of the first, subtraction, |
* step. |
*/ |
2003,10 → 3595,10 |
static png_uint_16 |
png_exp16bit(png_fixed_point lg2) |
{ |
/* Get a 32 bit value: */ |
/* Get a 32-bit value: */ |
png_uint_32 x = png_exp(lg2); |
/* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */ |
/* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */ |
x -= x >> 16; |
return (png_uint_16)((x + 32767U) >> 16); |
} |
2059,12 → 3651,12 |
} |
/* This does the right thing based on the bit_depth field of the |
* png_struct, interpreting values as 8 or 16 bit. While the result |
* is nominally a 16 bit value if bit depth is 8 then the result is |
* 8 bit (as are the arguments.) |
* png_struct, interpreting values as 8-bit or 16-bit. While the result |
* is nominally a 16-bit value if bit depth is 8 then the result is |
* 8-bit (as are the arguments.) |
*/ |
png_uint_16 /* PRIVATE */ |
png_gamma_correct(png_structp png_ptr, unsigned int value, |
png_gamma_correct(png_structrp png_ptr, unsigned int value, |
png_fixed_point gamma_val) |
{ |
if (png_ptr->bit_depth == 8) |
2074,17 → 3666,7 |
return png_gamma_16bit_correct(value, gamma_val); |
} |
/* This is the shared test on whether a gamma value is 'significant' - whether |
* it is worth doing gamma correction. |
*/ |
int /* PRIVATE */ |
png_gamma_significant(png_fixed_point gamma_val) |
{ |
return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED || |
gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED; |
} |
/* Internal function to build a single 16 bit table - the table consists of |
/* Internal function to build a single 16-bit table - the table consists of |
* 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount |
* to shift the input values right (or 16-number_of_signifiant_bits). |
* |
2093,7 → 3675,7 |
* should be somewhere that will be cleaned. |
*/ |
static void |
png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable, |
png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable, |
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) |
{ |
/* Various values derived from 'shift': */ |
2103,15 → 3685,15 |
unsigned int i; |
png_uint_16pp table = *ptable = |
(png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); |
(png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p))); |
for (i = 0; i < num; i++) |
{ |
png_uint_16p sub_table = table[i] = |
(png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16)); |
(png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16))); |
/* The 'threshold' test is repeated here because it can arise for one of |
* the 16 bit tables even if the others don't hit it. |
* the 16-bit tables even if the others don't hit it. |
*/ |
if (png_gamma_significant(gamma_val)) |
{ |
2161,7 → 3743,7 |
* required. |
*/ |
static void |
png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable, |
png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable, |
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) |
{ |
PNG_CONST unsigned int num = 1U << (8U - shift); |
2170,37 → 3752,37 |
png_uint_32 last; |
png_uint_16pp table = *ptable = |
(png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); |
(png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p))); |
/* 'num' is the number of tables and also the number of low bits of low |
* bits of the input 16 bit value used to select a table. Each table is |
* bits of the input 16-bit value used to select a table. Each table is |
* itself index by the high 8 bits of the value. |
*/ |
for (i = 0; i < num; i++) |
table[i] = (png_uint_16p)png_malloc(png_ptr, |
256 * png_sizeof(png_uint_16)); |
256 * (sizeof (png_uint_16))); |
/* 'gamma_val' is set to the reciprocal of the value calculated above, so |
* pow(out,g) is an *input* value. 'last' is the last input value set. |
* |
* In the loop 'i' is used to find output values. Since the output is 8 |
* bit there are only 256 possible values. The tables are set up to |
* In the loop 'i' is used to find output values. Since the output is |
* 8-bit there are only 256 possible values. The tables are set up to |
* select the closest possible output value for each input by finding |
* the input value at the boundary between each pair of output values |
* and filling the table up to that boundary with the lower output |
* value. |
* |
* The boundary values are 0.5,1.5..253.5,254.5. Since these are 9 bit |
* values the code below uses a 16 bit value in i; the values start at |
* The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit |
* values the code below uses a 16-bit value in i; the values start at |
* 128.5 (for 0.5) and step by 257, for a total of 254 values (the last |
* entries are filled with 255). Start i at 128 and fill all 'last' |
* table entries <= 'max' |
*/ |
last = 0; |
for (i = 0; i < 255; ++i) /* 8 bit output value */ |
for (i = 0; i < 255; ++i) /* 8-bit output value */ |
{ |
/* Find the corresponding maximum input value */ |
png_uint_16 out = (png_uint_16)(i * 257U); /* 16 bit output value */ |
png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */ |
/* Find the boundary value in 16 bits: */ |
png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val); |
2223,12 → 3805,12 |
} |
} |
/* Build a single 8 bit table: same as the 16 bit case but much simpler (and |
/* Build a single 8-bit table: same as the 16-bit case but much simpler (and |
* typically much faster). Note that libpng currently does no sBIT processing |
* (apparently contrary to the spec) so a 256 entry table is always generated. |
*/ |
static void |
png_build_8bit_table(png_structp png_ptr, png_bytepp ptable, |
png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable, |
PNG_CONST png_fixed_point gamma_val) |
{ |
unsigned int i; |
2241,6 → 3823,60 |
table[i] = (png_byte)i; |
} |
/* Used from png_read_destroy and below to release the memory used by the gamma |
* tables. |
*/ |
void /* PRIVATE */ |
png_destroy_gamma_table(png_structrp png_ptr) |
{ |
png_free(png_ptr, png_ptr->gamma_table); |
png_ptr->gamma_table = NULL; |
if (png_ptr->gamma_16_table != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_table[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_table); |
png_ptr->gamma_16_table = NULL; |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_free(png_ptr, png_ptr->gamma_from_1); |
png_ptr->gamma_from_1 = NULL; |
png_free(png_ptr, png_ptr->gamma_to_1); |
png_ptr->gamma_to_1 = NULL; |
if (png_ptr->gamma_16_from_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_from_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_from_1); |
png_ptr->gamma_16_from_1 = NULL; |
} |
if (png_ptr->gamma_16_to_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_to_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_to_1); |
png_ptr->gamma_16_to_1 = NULL; |
} |
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ |
} |
/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit |
* tables, we don't make a full table if we are reducing to 8-bit in |
* the future. Note also how the gamma_16 tables are segmented so that |
2247,28 → 3883,41 |
* we don't need to allocate > 64K chunks for a full 16-bit table. |
*/ |
void /* PRIVATE */ |
png_build_gamma_table(png_structp png_ptr, int bit_depth) |
png_build_gamma_table(png_structrp png_ptr, int bit_depth) |
{ |
png_debug(1, "in png_build_gamma_table"); |
/* Remove any existing table; this copes with multiple calls to |
* png_read_update_info. The warning is because building the gamma tables |
* multiple times is a performance hit - it's harmless but the ability to call |
* png_read_update_info() multiple times is new in 1.5.6 so it seems sensible |
* to warn if the app introduces such a hit. |
*/ |
if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL) |
{ |
png_warning(png_ptr, "gamma table being rebuilt"); |
png_destroy_gamma_table(png_ptr); |
} |
if (bit_depth <= 8) |
{ |
png_build_8bit_table(png_ptr, &png_ptr->gamma_table, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) |
if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) |
{ |
png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, |
png_reciprocal(png_ptr->gamma)); |
png_reciprocal(png_ptr->colorspace.gamma)); |
png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1, |
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : |
png_ptr->gamma/* Probably doing rgb_to_gray */); |
png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ |
} |
else |
{ |
2287,7 → 3936,7 |
else |
sig_bit = png_ptr->sig_bit.gray; |
/* 16 bit gamma code uses this equation: |
/* 16-bit gamma code uses this equation: |
* |
* ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] |
* |
2302,7 → 3951,7 |
* |
* So the table 'n' corresponds to all those 'iv' of: |
* |
* <all high 8 bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1> |
* <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1> |
* |
*/ |
if (sig_bit > 0 && sig_bit < 16U) |
2311,7 → 3960,7 |
else |
shift = 0; /* keep all 16 bits */ |
if (png_ptr->transformations & PNG_16_TO_8) |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) |
{ |
/* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively |
* the significant bits in the *input* when the output will |
2327,25 → 3976,31 |
png_ptr->gamma_shift = shift; |
#ifdef PNG_16BIT_SUPPORTED |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) |
/* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now |
* PNG_COMPOSE). This effectively smashed the background calculation for |
* 16-bit output because the 8-bit table assumes the result will be reduced |
* to 8 bits. |
*/ |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) |
#endif |
png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, |
png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma, |
png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#ifdef PNG_16BIT_SUPPORTED |
else |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) |
if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) |
{ |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, |
png_reciprocal(png_ptr->gamma)); |
png_reciprocal(png_ptr->colorspace.gamma)); |
/* Notice that the '16 from 1' table should be full precision, however |
* the lookup on this table still uses gamma_shift, so it can't be. |
2353,10 → 4008,291 |
*/ |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift, |
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : |
png_ptr->gamma/* Probably doing rgb_to_gray */); |
png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ |
} |
} |
#endif /* READ_GAMMA */ |
/* HARDWARE OPTION SUPPORT */ |
#ifdef PNG_SET_OPTION_SUPPORTED |
int PNGAPI |
png_set_option(png_structrp png_ptr, int option, int onoff) |
{ |
if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT && |
(option & 1) == 0) |
{ |
int mask = 3 << option; |
int setting = (2 + (onoff != 0)) << option; |
int current = png_ptr->options; |
png_ptr->options = (png_byte)((current & ~mask) | setting); |
return (current & mask) >> option; |
} |
return PNG_OPTION_INVALID; |
} |
#endif |
/* sRGB support */ |
#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ |
defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) |
/* sRGB conversion tables; these are machine generated with the code in |
* contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the |
* specification (see the article at http://en.wikipedia.org/wiki/SRGB) |
* is used, not the gamma=1/2.2 approximation use elsewhere in libpng. |
* The sRGB to linear table is exact (to the nearest 16 bit linear fraction). |
* The inverse (linear to sRGB) table has accuracies as follows: |
* |
* For all possible (255*65535+1) input values: |
* |
* error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact |
* |
* For the input values corresponding to the 65536 16-bit values: |
* |
* error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact |
* |
* In all cases the inexact readings are off by one. |
*/ |
#ifdef PNG_SIMPLIFIED_READ_SUPPORTED |
/* The convert-to-sRGB table is only currently required for read. */ |
const png_uint_16 png_sRGB_table[256] = |
{ |
0,20,40,60,80,99,119,139, |
159,179,199,219,241,264,288,313, |
340,367,396,427,458,491,526,562, |
599,637,677,718,761,805,851,898, |
947,997,1048,1101,1156,1212,1270,1330, |
1391,1453,1517,1583,1651,1720,1790,1863, |
1937,2013,2090,2170,2250,2333,2418,2504, |
2592,2681,2773,2866,2961,3058,3157,3258, |
3360,3464,3570,3678,3788,3900,4014,4129, |
4247,4366,4488,4611,4736,4864,4993,5124, |
5257,5392,5530,5669,5810,5953,6099,6246, |
6395,6547,6700,6856,7014,7174,7335,7500, |
7666,7834,8004,8177,8352,8528,8708,8889, |
9072,9258,9445,9635,9828,10022,10219,10417, |
10619,10822,11028,11235,11446,11658,11873,12090, |
12309,12530,12754,12980,13209,13440,13673,13909, |
14146,14387,14629,14874,15122,15371,15623,15878, |
16135,16394,16656,16920,17187,17456,17727,18001, |
18277,18556,18837,19121,19407,19696,19987,20281, |
20577,20876,21177,21481,21787,22096,22407,22721, |
23038,23357,23678,24002,24329,24658,24990,25325, |
25662,26001,26344,26688,27036,27386,27739,28094, |
28452,28813,29176,29542,29911,30282,30656,31033, |
31412,31794,32179,32567,32957,33350,33745,34143, |
34544,34948,35355,35764,36176,36591,37008,37429, |
37852,38278,38706,39138,39572,40009,40449,40891, |
41337,41785,42236,42690,43147,43606,44069,44534, |
45002,45473,45947,46423,46903,47385,47871,48359, |
48850,49344,49841,50341,50844,51349,51858,52369, |
52884,53401,53921,54445,54971,55500,56032,56567, |
57105,57646,58190,58737,59287,59840,60396,60955, |
61517,62082,62650,63221,63795,64372,64952,65535 |
}; |
#endif /* simplified read only */ |
/* The base/delta tables are required for both read and write (but currently |
* only the simplified versions.) |
*/ |
const png_uint_16 png_sRGB_base[512] = |
{ |
128,1782,3383,4644,5675,6564,7357,8074, |
8732,9346,9921,10463,10977,11466,11935,12384, |
12816,13233,13634,14024,14402,14769,15125,15473, |
15812,16142,16466,16781,17090,17393,17690,17981, |
18266,18546,18822,19093,19359,19621,19879,20133, |
20383,20630,20873,21113,21349,21583,21813,22041, |
22265,22487,22707,22923,23138,23350,23559,23767, |
23972,24175,24376,24575,24772,24967,25160,25352, |
25542,25730,25916,26101,26284,26465,26645,26823, |
27000,27176,27350,27523,27695,27865,28034,28201, |
28368,28533,28697,28860,29021,29182,29341,29500, |
29657,29813,29969,30123,30276,30429,30580,30730, |
30880,31028,31176,31323,31469,31614,31758,31902, |
32045,32186,32327,32468,32607,32746,32884,33021, |
33158,33294,33429,33564,33697,33831,33963,34095, |
34226,34357,34486,34616,34744,34873,35000,35127, |
35253,35379,35504,35629,35753,35876,35999,36122, |
36244,36365,36486,36606,36726,36845,36964,37083, |
37201,37318,37435,37551,37668,37783,37898,38013, |
38127,38241,38354,38467,38580,38692,38803,38915, |
39026,39136,39246,39356,39465,39574,39682,39790, |
39898,40005,40112,40219,40325,40431,40537,40642, |
40747,40851,40955,41059,41163,41266,41369,41471, |
41573,41675,41777,41878,41979,42079,42179,42279, |
42379,42478,42577,42676,42775,42873,42971,43068, |
43165,43262,43359,43456,43552,43648,43743,43839, |
43934,44028,44123,44217,44311,44405,44499,44592, |
44685,44778,44870,44962,45054,45146,45238,45329, |
45420,45511,45601,45692,45782,45872,45961,46051, |
46140,46229,46318,46406,46494,46583,46670,46758, |
46846,46933,47020,47107,47193,47280,47366,47452, |
47538,47623,47709,47794,47879,47964,48048,48133, |
48217,48301,48385,48468,48552,48635,48718,48801, |
48884,48966,49048,49131,49213,49294,49376,49458, |
49539,49620,49701,49782,49862,49943,50023,50103, |
50183,50263,50342,50422,50501,50580,50659,50738, |
50816,50895,50973,51051,51129,51207,51285,51362, |
51439,51517,51594,51671,51747,51824,51900,51977, |
52053,52129,52205,52280,52356,52432,52507,52582, |
52657,52732,52807,52881,52956,53030,53104,53178, |
53252,53326,53400,53473,53546,53620,53693,53766, |
53839,53911,53984,54056,54129,54201,54273,54345, |
54417,54489,54560,54632,54703,54774,54845,54916, |
54987,55058,55129,55199,55269,55340,55410,55480, |
55550,55620,55689,55759,55828,55898,55967,56036, |
56105,56174,56243,56311,56380,56448,56517,56585, |
56653,56721,56789,56857,56924,56992,57059,57127, |
57194,57261,57328,57395,57462,57529,57595,57662, |
57728,57795,57861,57927,57993,58059,58125,58191, |
58256,58322,58387,58453,58518,58583,58648,58713, |
58778,58843,58908,58972,59037,59101,59165,59230, |
59294,59358,59422,59486,59549,59613,59677,59740, |
59804,59867,59930,59993,60056,60119,60182,60245, |
60308,60370,60433,60495,60558,60620,60682,60744, |
60806,60868,60930,60992,61054,61115,61177,61238, |
61300,61361,61422,61483,61544,61605,61666,61727, |
61788,61848,61909,61969,62030,62090,62150,62211, |
62271,62331,62391,62450,62510,62570,62630,62689, |
62749,62808,62867,62927,62986,63045,63104,63163, |
63222,63281,63340,63398,63457,63515,63574,63632, |
63691,63749,63807,63865,63923,63981,64039,64097, |
64155,64212,64270,64328,64385,64443,64500,64557, |
64614,64672,64729,64786,64843,64900,64956,65013, |
65070,65126,65183,65239,65296,65352,65409,65465 |
}; |
const png_byte png_sRGB_delta[512] = |
{ |
207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54, |
52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36, |
35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28, |
28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24, |
23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21, |
21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19, |
19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17, |
17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16, |
16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15, |
15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14, |
14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13, |
13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12, |
12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12, |
12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11, |
11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, |
11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, |
11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, |
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, |
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, |
10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, |
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, |
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, |
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, |
9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7, |
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 |
}; |
#endif /* SIMPLIFIED READ/WRITE sRGB support */ |
/* SIMPLIFIED READ/WRITE SUPPORT */ |
#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ |
defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) |
static int |
png_image_free_function(png_voidp argument) |
{ |
png_imagep image = png_voidcast(png_imagep, argument); |
png_controlp cp = image->opaque; |
png_control c; |
/* Double check that we have a png_ptr - it should be impossible to get here |
* without one. |
*/ |
if (cp->png_ptr == NULL) |
return 0; |
/* First free any data held in the control structure. */ |
# ifdef PNG_STDIO_SUPPORTED |
if (cp->owned_file) |
{ |
FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr); |
cp->owned_file = 0; |
/* Ignore errors here. */ |
if (fp != NULL) |
{ |
cp->png_ptr->io_ptr = NULL; |
(void)fclose(fp); |
} |
} |
# endif |
/* Copy the control structure so that the original, allocated, version can be |
* safely freed. Notice that a png_error here stops the remainder of the |
* cleanup, but this is probably fine because that would indicate bad memory |
* problems anyway. |
*/ |
c = *cp; |
image->opaque = &c; |
png_free(c.png_ptr, cp); |
/* Then the structures, calling the correct API. */ |
if (c.for_write) |
{ |
# ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED |
png_destroy_write_struct(&c.png_ptr, &c.info_ptr); |
# else |
png_error(c.png_ptr, "simplified write not supported"); |
# endif |
} |
else |
{ |
# ifdef PNG_SIMPLIFIED_READ_SUPPORTED |
png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL); |
# else |
png_error(c.png_ptr, "simplified read not supported"); |
# endif |
} |
/* Success. */ |
return 1; |
} |
void PNGAPI |
png_image_free(png_imagep image) |
{ |
/* Safely call the real function, but only if doing so is safe at this point |
* (if not inside an error handling context). Otherwise assume |
* png_safe_execute will call this API after the return. |
*/ |
if (image != NULL && image->opaque != NULL && |
image->opaque->error_buf == NULL) |
{ |
/* Ignore errors here: */ |
(void)png_safe_execute(image, png_image_free_function, image); |
image->opaque = NULL; |
} |
} |
int /* PRIVATE */ |
png_image_error(png_imagep image, png_const_charp error_message) |
{ |
/* Utility to log an error. */ |
png_safecat(image->message, (sizeof image->message), 0, error_message); |
image->warning_or_error |= PNG_IMAGE_ERROR; |
png_image_free(image); |
return 0; |
} |
#endif /* SIMPLIFIED READ/WRITE */ |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
/programs/develop/libraries/libpng/png.h |
---|
1,8 → 1,8 |
/* png.h - header file for PNG reference library |
* |
* libpng version 1.5.1 - February 3, 2011 |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* libpng version 1.6.5 - September 14, 2013 |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
11,7 → 11,7 |
* Authors and maintainers: |
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat |
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger |
* libpng versions 0.97, January 1998, through 1.5.1 - February 3, 2011: Glenn |
* libpng versions 0.97, January 1998, through 1.6.5 - September 14, 2013: Glenn |
* See also "Contributing Authors", below. |
* |
* Note about libpng version numbers: |
147,6 → 147,41 |
* 1.5.1beta01-11 15 10501 15.so.15.1[.0] |
* 1.5.1rc01-02 15 10501 15.so.15.1[.0] |
* 1.5.1 15 10501 15.so.15.1[.0] |
* 1.5.2beta01-03 15 10502 15.so.15.2[.0] |
* 1.5.2rc01-03 15 10502 15.so.15.2[.0] |
* 1.5.2 15 10502 15.so.15.2[.0] |
* 1.5.3beta01-10 15 10503 15.so.15.3[.0] |
* 1.5.3rc01-02 15 10503 15.so.15.3[.0] |
* 1.5.3beta11 15 10503 15.so.15.3[.0] |
* 1.5.3 [omitted] |
* 1.5.4beta01-08 15 10504 15.so.15.4[.0] |
* 1.5.4rc01 15 10504 15.so.15.4[.0] |
* 1.5.4 15 10504 15.so.15.4[.0] |
* 1.5.5beta01-08 15 10505 15.so.15.5[.0] |
* 1.5.5rc01 15 10505 15.so.15.5[.0] |
* 1.5.5 15 10505 15.so.15.5[.0] |
* 1.5.6beta01-07 15 10506 15.so.15.6[.0] |
* 1.5.6rc01-03 15 10506 15.so.15.6[.0] |
* 1.5.6 15 10506 15.so.15.6[.0] |
* 1.5.7beta01-05 15 10507 15.so.15.7[.0] |
* 1.5.7rc01-03 15 10507 15.so.15.7[.0] |
* 1.5.7 15 10507 15.so.15.7[.0] |
* 1.6.0beta01-40 16 10600 16.so.16.0[.0] |
* 1.6.0rc01-08 16 10600 16.so.16.0[.0] |
* 1.6.0 16 10600 16.so.16.0[.0] |
* 1.6.1beta01-09 16 10601 16.so.16.1[.0] |
* 1.6.1rc01 16 10601 16.so.16.1[.0] |
* 1.6.1 16 10601 16.so.16.1[.0] |
* 1.6.2beta01 16 10602 16.so.16.2[.0] |
* 1.6.2rc01-06 16 10602 16.so.16.2[.0] |
* 1.6.2 16 10602 16.so.16.2[.0] |
* 1.6.3beta01-11 16 10603 16.so.16.3[.0] |
* 1.6.3rc01 16 10603 16.so.16.3[.0] |
* 1.6.3 16 10603 16.so.16.3[.0] |
* 1.6.4beta01-02 16 10604 16.so.16.4[.0] |
* 1.6.4rc01 16 10604 16.so.16.4[.0] |
* 1.6.4 16 10604 16.so.16.4[.0] |
* 1.6.5 16 10605 16.so.16.5[.0] |
* |
* Henceforth the source version will match the shared-library major |
* and minor numbers; the shared-library major version number will be |
156,7 → 191,7 |
* to the source version x.y.z (leading zeros in y and z). Beta versions |
* were given the previous public release number plus a letter, until |
* version 1.0.6j; from then on they were given the upcoming public |
* release number plus "betaNN" or "rcN". |
* release number plus "betaNN" or "rcNN". |
* |
* Binary incompatibility exists only when applications make direct access |
* to the info_ptr or png_ptr members through png.h, and the compiled |
178,8 → 213,8 |
* |
* This code is released under the libpng license. |
* |
* libpng versions 1.2.6, August 15, 2004, through 1.5.1, February 3, 2011, are |
* Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are |
* libpng versions 1.2.6, August 15, 2004, through 1.6.5, September 14, 2013, are |
* Copyright (c) 2004, 2006-2013 Glenn Randers-Pehrson, and are |
* distributed according to the same disclaimer and license as libpng-1.2.5 |
* with the following individual added to the list of Contributing Authors: |
* |
290,29 → 325,30 |
* Y2K compliance in libpng: |
* ========================= |
* |
* February 3, 2011 |
* September 14, 2013 |
* |
* Since the PNG Development group is an ad-hoc body, we can't make |
* an official declaration. |
* |
* This is your unofficial assurance that libpng from version 0.71 and |
* upward through 1.5.1 are Y2K compliant. It is my belief that |
* upward through 1.6.5 are Y2K compliant. It is my belief that |
* earlier versions were also Y2K compliant. |
* |
* Libpng only has three year fields. One is a 2-byte unsigned integer |
* that will hold years up to 65535. The other two hold the date in text |
* format, and will hold years up to 9999. |
* Libpng only has two year fields. One is a 2-byte unsigned integer |
* that will hold years up to 65535. The other, which is deprecated, |
* holds the date in text format, and will hold years up to 9999. |
* |
* The integer is |
* "png_uint_16 year" in png_time_struct. |
* |
* The strings are |
* "png_charp time_buffer" in png_struct and |
* "near_time_buffer", which is a local character string in png.c. |
* The string is |
* "char time_buffer[29]" in png_struct. This is no longer used |
* in libpng-1.6.x and will be removed from libpng-1.7.0. |
* |
* There are seven time-related functions: |
* png.c: png_convert_to_rfc_1123() in png.c |
* (formerly png_convert_to_rfc_1152() in error) |
* png.c: png_convert_to_rfc_1123_buffer() in png.c |
* (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and |
* png_convert_to_rfc_1152() in error prior to libpng-0.98) |
* png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c |
* png_convert_from_time_t() in pngwrite.c |
* png_get_tIME() in pngget.c |
323,8 → 359,8 |
* All handle dates properly in a Y2K environment. The |
* png_convert_from_time_t() function calls gmtime() to convert from system |
* clock time, which returns (year - 1900), which we properly convert to |
* the full 4-digit year. There is a possibility that applications using |
* libpng are not passing 4-digit years into the png_convert_to_rfc_1123() |
* the full 4-digit year. There is a possibility that libpng applications |
* are not passing 4-digit years into the png_convert_to_rfc_1123_buffer() |
* function, or that they are incorrectly passing only a 2-digit year |
* instead of "year - 1900" into the png_convert_from_struct_tm() function, |
* but this is not under our control. The libpng documentation has always |
349,20 → 385,24 |
* describes how to use libpng, and the file example.c summarizes it |
* with some code on which to build. This file is useful for looking |
* at the actual function definitions and structure components. |
* |
* If you just need to read a PNG file and don't want to read the documentation |
* skip to the end of this file and read the section entitled 'simplified API'. |
*/ |
/* Version information for png.h - this should match the version in png.c */ |
#define PNG_LIBPNG_VER_STRING "1.5.1" |
#define PNG_LIBPNG_VER_STRING "1.6.5" |
#define PNG_HEADER_VERSION_STRING \ |
" libpng version 1.5.1 - February 3, 2011\n" |
" libpng version 1.6.5 - September 14, 2013\n" |
#define PNG_LIBPNG_VER_SONUM 15 |
#define PNG_LIBPNG_VER_DLLNUM 15 |
#define PNG_LIBPNG_VER_SONUM 16 |
#define PNG_LIBPNG_VER_DLLNUM 16 |
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ |
#define PNG_LIBPNG_VER_MAJOR 1 |
#define PNG_LIBPNG_VER_MINOR 5 |
#define PNG_LIBPNG_VER_RELEASE 1 |
#define PNG_LIBPNG_VER_MINOR 6 |
#define PNG_LIBPNG_VER_RELEASE 5 |
/* This should match the numeric part of the final component of |
* PNG_LIBPNG_VER_STRING, omitting any leading zero: |
*/ |
384,7 → 424,7 |
#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with |
PNG_LIBPNG_BUILD_PRIVATE */ |
#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA |
#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE |
/* Careful here. At one time, Guy wanted to use 082, but that would be octal. |
* We must not include leading zeros. |
392,7 → 432,7 |
* version 1.0.0 was mis-numbered 100 instead of 10000). From |
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release |
*/ |
#define PNG_LIBPNG_VER 10501 /* 1.5.1 */ |
#define PNG_LIBPNG_VER 10605 /* 1.6.5 */ |
/* Library configuration: these options cannot be changed after |
* the library has been built. |
405,19 → 445,6 |
#endif |
#ifndef PNG_VERSION_INFO_ONLY |
/* Standard header files (not needed for the version info) */ |
# ifdef PNG_SETJMP_SUPPORTED |
# include <setjmp.h> |
# endif |
/* Need the time information for converting tIME chunks, it |
* defines struct tm: |
*/ |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* "time.h" functions are not supported on all operating systems */ |
# include <time.h> |
#endif |
/* Machine specific configuration. */ |
# include "pngconf.h" |
#endif |
467,6 → 494,7 |
* 2. Type definitions (base types are defined in pngconf.h), structure |
* definitions. |
* 3. Exported library functions. |
* 4. Simplified API. |
* |
* The library source code has additional files (principally pngpriv.h) that |
* allow configuration of the library. |
509,8 → 537,49 |
/* This triggers a compiler error in png.c, if png.c and png.h |
* do not agree upon the version number. |
*/ |
typedef char* png_libpng_version_1_5_1; |
typedef char* png_libpng_version_1_6_5; |
/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info. |
* |
* png_struct is the cache of information used while reading or writing a single |
* PNG file. One of these is always required, although the simplified API |
* (below) hides the creation and destruction of it. |
*/ |
typedef struct png_struct_def png_struct; |
typedef const png_struct * png_const_structp; |
typedef png_struct * png_structp; |
typedef png_struct * * png_structpp; |
/* png_info contains information read from or to be written to a PNG file. One |
* or more of these must exist while reading or creating a PNG file. The |
* information is not used by libpng during read but is used to control what |
* gets written when a PNG file is created. "png_get_" function calls read |
* information during read and "png_set_" functions calls write information |
* when creating a PNG. |
* been moved into a separate header file that is not accessible to |
* applications. Read libpng-manual.txt or libpng.3 for more info. |
*/ |
typedef struct png_info_def png_info; |
typedef png_info * png_infop; |
typedef const png_info * png_const_infop; |
typedef png_info * * png_infopp; |
/* Types with names ending 'p' are pointer types. The corresponding types with |
* names ending 'rp' are identical pointer types except that the pointer is |
* marked 'restrict', which means that it is the only pointer to the object |
* passed to the function. Applications should not use the 'restrict' types; |
* it is always valid to pass 'p' to a pointer with a function argument of the |
* corresponding 'rp' type. Different compilers have different rules with |
* regard to type matching in the presence of 'restrict'. For backward |
* compatibility libpng callbacks never have 'restrict' in their parameters and, |
* consequentially, writing portable application code is extremely difficult if |
* an attempt is made to use 'restrict'. |
*/ |
typedef png_struct * PNG_RESTRICT png_structrp; |
typedef const png_struct * PNG_RESTRICT png_const_structrp; |
typedef png_info * PNG_RESTRICT png_inforp; |
typedef const png_info * PNG_RESTRICT png_const_inforp; |
/* Three color definitions. The order of the red, green, and blue, (and the |
* exact size) is not important, although the size of the fields need to |
* be png_byte or png_uint_16 (as defined below). |
521,9 → 590,9 |
png_byte green; |
png_byte blue; |
} png_color; |
typedef png_color FAR * png_colorp; |
typedef PNG_CONST png_color FAR * png_const_colorp; |
typedef png_color FAR * FAR * png_colorpp; |
typedef png_color * png_colorp; |
typedef const png_color * png_const_colorp; |
typedef png_color * * png_colorpp; |
typedef struct png_color_16_struct |
{ |
533,9 → 602,9 |
png_uint_16 blue; |
png_uint_16 gray; /* for use in grayscale files */ |
} png_color_16; |
typedef png_color_16 FAR * png_color_16p; |
typedef PNG_CONST png_color_16 FAR * png_const_color_16p; |
typedef png_color_16 FAR * FAR * png_color_16pp; |
typedef png_color_16 * png_color_16p; |
typedef const png_color_16 * png_const_color_16p; |
typedef png_color_16 * * png_color_16pp; |
typedef struct png_color_8_struct |
{ |
545,9 → 614,9 |
png_byte gray; /* for use in grayscale files */ |
png_byte alpha; /* for alpha channel files */ |
} png_color_8; |
typedef png_color_8 FAR * png_color_8p; |
typedef PNG_CONST png_color_8 FAR * png_const_color_8p; |
typedef png_color_8 FAR * FAR * png_color_8pp; |
typedef png_color_8 * png_color_8p; |
typedef const png_color_8 * png_const_color_8p; |
typedef png_color_8 * * png_color_8pp; |
/* |
* The following two structures are used for the in-core representation |
561,9 → 630,9 |
png_uint_16 alpha; |
png_uint_16 frequency; |
} png_sPLT_entry; |
typedef png_sPLT_entry FAR * png_sPLT_entryp; |
typedef PNG_CONST png_sPLT_entry FAR * png_const_sPLT_entryp; |
typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; |
typedef png_sPLT_entry * png_sPLT_entryp; |
typedef const png_sPLT_entry * png_const_sPLT_entryp; |
typedef png_sPLT_entry * * png_sPLT_entrypp; |
/* When the depth of the sPLT palette is 8 bits, the color and alpha samples |
* occupy the LSB of their respective members, and the MSB of each member |
577,18 → 646,27 |
png_sPLT_entryp entries; /* palette entries */ |
png_int_32 nentries; /* number of palette entries */ |
} png_sPLT_t; |
typedef png_sPLT_t FAR * png_sPLT_tp; |
typedef PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp; |
typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; |
typedef png_sPLT_t * png_sPLT_tp; |
typedef const png_sPLT_t * png_const_sPLT_tp; |
typedef png_sPLT_t * * png_sPLT_tpp; |
#ifdef PNG_TEXT_SUPPORTED |
/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, |
* and whether that contents is compressed or not. The "key" field |
* points to a regular zero-terminated C string. The "text", "lang", and |
* "lang_key" fields can be regular C strings, empty strings, or NULL pointers. |
* However, the * structure returned by png_get_text() will always contain |
* regular zero-terminated C strings (possibly empty), never NULL pointers, |
* so they can be safely used in printf() and other string-handling functions. |
* points to a regular zero-terminated C string. The "text" fields can be a |
* regular C string, an empty string, or a NULL pointer. |
* However, the structure returned by png_get_text() will always contain |
* the "text" field as a regular zero-terminated C string (possibly |
* empty), never a NULL pointer, so it can be safely used in printf() and |
* other string-handling functions. Note that the "itxt_length", "lang", and |
* "lang_key" members of the structure only exist when the library is built |
* with iTXt chunk support. Prior to libpng-1.4.0 the library was built by |
* default without iTXt support. Also note that when iTXt *is* supported, |
* the "lang" and "lang_key" fields contain NULL pointers when the |
* "compression" field contains * PNG_TEXT_COMPRESSION_NONE or |
* PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the |
* same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag" |
* which is always 0 or 1, or its "compression method" which is always 0. |
*/ |
typedef struct png_text_struct |
{ |
607,9 → 685,9 |
png_charp lang_key; /* keyword translated UTF-8 string, 0 or more |
chars or a NULL pointer */ |
} png_text; |
typedef png_text FAR * png_textp; |
typedef PNG_CONST png_text FAR * png_const_textp; |
typedef png_text FAR * FAR * png_textpp; |
typedef png_text * png_textp; |
typedef const png_text * png_const_textp; |
typedef png_text * * png_textpp; |
#endif |
/* Supported compression types for text in PNG files (tEXt, and zTXt). |
637,36 → 715,43 |
png_byte minute; /* minute of hour, 0 - 59 */ |
png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ |
} png_time; |
typedef png_time FAR * png_timep; |
typedef PNG_CONST png_time FAR * png_const_timep; |
typedef png_time FAR * FAR * png_timepp; |
typedef png_time * png_timep; |
typedef const png_time * png_const_timep; |
typedef png_time * * png_timepp; |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
/* png_unknown_chunk is a structure to hold queued chunks for which there is |
* no specific support. The idea is that we can use this to queue |
* up private chunks for output even though the library doesn't actually |
* know about their semantics. |
* |
* The data in the structure is set by libpng on read and used on write. |
*/ |
typedef struct png_unknown_chunk_t |
{ |
png_byte name[5]; |
png_byte *data; |
png_byte name[5]; /* Textual chunk name with '\0' terminator */ |
png_byte *data; /* Data, should not be modified on read! */ |
png_size_t size; |
/* libpng-using applications should NOT directly modify this byte. */ |
/* On write 'location' must be set using the flag values listed below. |
* Notice that on read it is set by libpng however the values stored have |
* more bits set than are listed below. Always treat the value as a |
* bitmask. On write set only one bit - setting multiple bits may cause the |
* chunk to be written in multiple places. |
*/ |
png_byte location; /* mode of operation at read time */ |
} |
png_unknown_chunk; |
typedef png_unknown_chunk FAR * png_unknown_chunkp; |
typedef PNG_CONST png_unknown_chunk FAR * png_const_unknown_chunkp; |
typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; |
typedef png_unknown_chunk * png_unknown_chunkp; |
typedef const png_unknown_chunk * png_const_unknown_chunkp; |
typedef png_unknown_chunk * * png_unknown_chunkpp; |
#endif |
typedef struct png_info_def png_info; |
typedef png_info FAR * png_infop; |
typedef PNG_CONST png_info FAR * png_const_infop; |
typedef png_info FAR * FAR * png_infopp; |
/* Flag values for the unknown chunk location byte. */ |
#define PNG_HAVE_IHDR 0x01 |
#define PNG_HAVE_PLTE 0x02 |
#define PNG_AFTER_IDAT 0x08 |
/* Maximum positive integer used in PNG is (2^31)-1 */ |
#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) |
678,6 → 763,8 |
*/ |
#define PNG_FP_1 100000 |
#define PNG_FP_HALF 50000 |
#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) |
#define PNG_FP_MIN (-PNG_FP_MAX) |
/* These describe the color_type field in png_info. */ |
/* color type masks */ |
765,7 → 852,7 |
#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ |
#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ |
#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ |
/* This is used for the transformation routines, as some of them |
* change these values for the row. It also should enable using |
781,8 → 868,8 |
png_byte pixel_depth; /* bits per pixel (depth * channels) */ |
} png_row_info; |
typedef png_row_info FAR * png_row_infop; |
typedef png_row_info FAR * FAR * png_row_infopp; |
typedef png_row_info * png_row_infop; |
typedef png_row_info * * png_row_infopp; |
/* These are the function types for the I/O functions and for the functions |
* that allow the user to override the default I/O functions with his or her |
792,61 → 879,60 |
* modify the buffer it is passed. The 'read' function, on the other hand, is |
* expected to return the read data in the buffer. |
*/ |
typedef struct png_struct_def png_struct; |
typedef PNG_CONST png_struct FAR * png_const_structp; |
typedef png_struct FAR * png_structp; |
typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp), ); |
typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t), ); |
typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp), ); |
typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); |
typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); |
typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); |
typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, |
int), ); |
int)); |
typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, |
int), ); |
int)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
typedef PNG_CALLBACK(void, *png_progressive_info_ptr, |
(png_structp, png_infop), ); |
typedef PNG_CALLBACK(void, *png_progressive_end_ptr, |
(png_structp, png_infop), ); |
typedef PNG_CALLBACK(void, *png_progressive_row_ptr, |
(png_structp, png_bytep, png_uint_32, int), ); |
typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); |
typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); |
/* The following callback receives png_uint_32 row_number, int pass for the |
* png_bytep data of the row. When transforming an interlaced image the |
* row number is the row number within the sub-image of the interlace pass, so |
* the value will increase to the height of the sub-image (not the full image) |
* then reset to 0 for the next pass. |
* |
* Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to |
* find the output pixel (x,y) given an interlaced sub-image pixel |
* (row,col,pass). (See below for these macros.) |
*/ |
typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, |
png_uint_32, int)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
typedef PNG_CALLBACK(void, *png_user_transform_ptr, |
(png_structp, png_row_infop, png_bytep), ); |
typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, |
png_bytep)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, |
png_unknown_chunkp), ); |
png_unknown_chunkp)); |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp), ); |
/* not used anywhere */ |
/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */ |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* This must match the function definition in <setjmp.h>, and the |
* application must include this before png.h to obtain the definition |
* of jmp_buf. The function is required to be PNG_NORETURN. (Note that |
* PNG_PTR_NORETURN is used here because current versions of the Microsoft |
* C compiler do not support the PNG_NORETURN attribute on a pointer.) |
/* This must match the function definition in <setjmp.h>, and the application |
* must include this before png.h to obtain the definition of jmp_buf. The |
* function is required to be PNG_NORETURN, but this is not checked. If the |
* function does return the application will crash via an abort() or similar |
* system level call. |
* |
* If you get a type warning from the compiler when linking against this line |
* then your compiler has 'longjmp' that does not match the requirements of the |
* compiler that built libpng. You will have to write a wrapper function for |
* your compiler's longjmp and call png_set_longjmp_fn directly (not via the |
* png_jmpbuf macro.) |
* |
* If you get a warning here while building the library you will need to make |
* If you get a warning here while building the library you may need to make |
* changes to ensure that pnglibconf.h records the calling convention used by |
* your compiler. This may be very difficult - try using a different compiler |
* to build the library! |
*/ |
typedef PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), |
PNG_PTR_NORETURN); |
PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); |
#endif |
/* Transform masks for the high-level interface */ |
868,6 → 954,9 |
#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ |
/* Added to libpng-1.4.0 */ |
#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ |
/* Added to libpng-1.5.4 */ |
#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ |
#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ |
/* Flags for MNG supported features */ |
#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 |
881,11 → 970,9 |
* following. |
*/ |
typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, |
png_alloc_size_t), ); |
typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp), ); |
png_alloc_size_t)); |
typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); |
typedef png_struct FAR * FAR * png_structpp; |
/* Section 3: exported functions |
* Here are the function definitions most commonly used. This is not |
* the place to find out how to use libpng. See libpng-manual.txt for the |
921,7 → 1008,7 |
/* Tell lib we have already handled the first <num_bytes> magic bytes. |
* Handling more than 8 bytes from the beginning of the file is an error. |
*/ |
PNG_EXPORT(2, void, png_set_sig_bytes, (png_structp png_ptr, int num_bytes)); |
PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes)); |
/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a |
* PNG file. Returns zero if the supplied bytes match the 8-byte PNG |
949,9 → 1036,9 |
PNG_ALLOCATED); |
PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr, |
PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr, |
png_size_t size)); |
/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp |
965,10 → 1052,10 |
* allocated by the library - the call will return NULL on a mismatch |
* indicating an ABI mismatch. |
*/ |
PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr, |
PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr, |
png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); |
# define png_jmpbuf(png_ptr) \ |
(*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) |
(*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf)))) |
#else |
# define png_jmpbuf(png_ptr) \ |
(LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) |
978,12 → 1065,12 |
* will use it; otherwise it will call PNG_ABORT(). This function was |
* added in libpng-1.5.0. |
*/ |
PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val), |
PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val), |
PNG_NORETURN); |
#ifdef PNG_READ_SUPPORTED |
/* Reset the compression stream */ |
PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr)); |
PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED); |
#endif |
/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ |
1001,45 → 1088,57 |
#endif |
/* Write the PNG file signature. */ |
PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr)); |
PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr)); |
/* Write a PNG chunk - size, type, (optional) data, CRC. */ |
PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep |
PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep |
chunk_name, png_const_bytep data, png_size_t length)); |
/* Write the start of a PNG chunk - length and chunk name. */ |
PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr, |
PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr, |
png_const_bytep chunk_name, png_uint_32 length)); |
/* Write the data of a PNG chunk started with png_write_chunk_start(). */ |
PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr, |
PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr, |
png_const_bytep data, png_size_t length)); |
/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ |
PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr)); |
PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr)); |
/* Allocate and initialize the info structure */ |
PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr), |
PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr), |
PNG_ALLOCATED); |
PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr, |
png_size_t png_info_struct_size)); |
/* DEPRECATED: this function allowed init structures to be created using the |
* default allocation method (typically malloc). Use is deprecated in 1.6.0 and |
* the API will be removed in the future. |
*/ |
PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr, |
png_size_t png_info_struct_size), PNG_DEPRECATED); |
/* Writes all the PNG information before the image. */ |
PNG_EXPORT(20, void, png_write_info_before_PLTE, |
(png_structp png_ptr, png_infop info_ptr)); |
(png_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(21, void, png_write_info, |
(png_structp png_ptr, png_infop info_ptr)); |
(png_structrp png_ptr, png_const_inforp info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the information before the actual image data. */ |
PNG_EXPORT(22, void, png_read_info, |
(png_structp png_ptr, png_infop info_ptr)); |
(png_structrp png_ptr, png_inforp info_ptr)); |
#endif |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123, |
(png_structp png_ptr, |
/* Convert to a US string format: there is no localization support in this |
* routine. The original implementation used a 29 character buffer in |
* png_struct, this will be removed in future versions. |
*/ |
#if PNG_LIBPNG_VER < 10700 |
/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */ |
PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr, |
png_const_timep ptime),PNG_DEPRECATED); |
#endif |
PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29], |
png_const_timep ptime)); |
#endif |
1046,91 → 1145,312 |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* Convert from a struct tm to png_time */ |
PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, |
PNG_CONST struct tm FAR * ttime)); |
const struct tm * ttime)); |
/* Convert from time_t to png_time. Uses gmtime() */ |
PNG_EXPORT(25, void, png_convert_from_time_t, |
(png_timep ptime, time_t ttime)); |
PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime)); |
#endif /* PNG_CONVERT_tIME_SUPPORTED */ |
#ifdef PNG_READ_EXPAND_SUPPORTED |
/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ |
PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr)); |
PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr)); |
PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr)); |
PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr)); |
PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr)); |
PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr)); |
PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr)); |
PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion |
* of a tRNS chunk if present. |
*/ |
PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* Use blue, green, red order for pixels. */ |
PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr)); |
PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* Expand the grayscale to 24-bit RGB if necessary. */ |
PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr)); |
PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* Reduce RGB to grayscale. */ |
PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr, |
int error_action, double red, double green)); |
PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr, |
int error_action, png_fixed_point red, png_fixed_point green)); |
#define PNG_ERROR_ACTION_NONE 1 |
#define PNG_ERROR_ACTION_WARN 2 |
#define PNG_ERROR_ACTION_ERROR 3 |
#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ |
PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp |
PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr, |
int error_action, double red, double green)) |
PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr, |
int error_action, png_fixed_point red, png_fixed_point green)) |
PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp |
png_ptr)); |
#endif |
#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED |
PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, |
png_colorp palette)); |
#endif |
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
/* How the alpha channel is interpreted - this affects how the color channels of |
* a PNG file are returned when an alpha channel, or tRNS chunk in a palette |
* file, is present. |
* |
* This has no effect on the way pixels are written into a PNG output |
* datastream. The color samples in a PNG datastream are never premultiplied |
* with the alpha samples. |
* |
* The default is to return data according to the PNG specification: the alpha |
* channel is a linear measure of the contribution of the pixel to the |
* corresponding composited pixel. The gamma encoded color channels must be |
* scaled according to the contribution and to do this it is necessary to undo |
* the encoding, scale the color values, perform the composition and reencode |
* the values. This is the 'PNG' mode. |
* |
* The alternative is to 'associate' the alpha with the color information by |
* storing color channel values that have been scaled by the alpha. The |
* advantage is that the color channels can be resampled (the image can be |
* scaled) in this form. The disadvantage is that normal practice is to store |
* linear, not (gamma) encoded, values and this requires 16-bit channels for |
* still images rather than the 8-bit channels that are just about sufficient if |
* gamma encoding is used. In addition all non-transparent pixel values, |
* including completely opaque ones, must be gamma encoded to produce the final |
* image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the |
* latter being the two common names for associated alpha color channels.) |
* |
* Since it is not necessary to perform arithmetic on opaque color values so |
* long as they are not to be resampled and are in the final color space it is |
* possible to optimize the handling of alpha by storing the opaque pixels in |
* the PNG format (adjusted for the output color space) while storing partially |
* opaque pixels in the standard, linear, format. The accuracy required for |
* standard alpha composition is relatively low, because the pixels are |
* isolated, therefore typically the accuracy loss in storing 8-bit linear |
* values is acceptable. (This is not true if the alpha channel is used to |
* simulate transparency over large areas - use 16 bits or the PNG mode in |
* this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is |
* treated as opaque only if the alpha value is equal to the maximum value. |
* |
* The final choice is to gamma encode the alpha channel as well. This is |
* broken because, in practice, no implementation that uses this choice |
* correctly undoes the encoding before handling alpha composition. Use this |
* choice only if other serious errors in the software or hardware you use |
* mandate it; the typical serious error is for dark halos to appear around |
* opaque areas of the composited PNG image because of arithmetic overflow. |
* |
* The API function png_set_alpha_mode specifies which of these choices to use |
* with an enumerated 'mode' value and the gamma of the required output: |
*/ |
#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ |
#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ |
#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ |
#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ |
#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ |
#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ |
PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode, |
double output_gamma)) |
PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr, |
int mode, png_fixed_point output_gamma)) |
#endif |
#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
/* The output_gamma value is a screen gamma in libpng terminology: it expresses |
* how to decode the output values, not how they are encoded. The values used |
* correspond to the normal numbers used to describe the overall gamma of a |
* computer display system; for example 2.2 for an sRGB conformant system. The |
* values are scaled by 100000 in the _fixed version of the API (so 220000 for |
* sRGB.) |
* |
* The inverse of the value is always used to provide a default for the PNG file |
* encoding if it has no gAMA chunk and if png_set_gamma() has not been called |
* to override the PNG gamma information. |
* |
* When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode |
* opaque pixels however pixels with lower alpha values are not encoded, |
* regardless of the output gamma setting. |
* |
* When the standard Porter Duff handling is requested with mode 1 the output |
* encoding is set to be linear and the output_gamma value is only relevant |
* as a default for input data that has no gamma information. The linear output |
* encoding will be overridden if png_set_gamma() is called - the results may be |
* highly unexpected! |
* |
* The following numbers are derived from the sRGB standard and the research |
* behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of |
* 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing |
* correction required to take account of any differences in the color |
* environment of the original scene and the intended display environment; the |
* value expresses how to *decode* the image for display, not how the original |
* data was *encoded*. |
* |
* sRGB provides a peg for the PNG standard by defining a viewing environment. |
* sRGB itself, and earlier TV standards, actually use a more complex transform |
* (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is |
* limited to simple power laws.) By saying that an image for direct display on |
* an sRGB conformant system should be stored with a gAMA chunk value of 45455 |
* (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification |
* makes it possible to derive values for other display systems and |
* environments. |
* |
* The Mac value is deduced from the sRGB based on an assumption that the actual |
* extra viewing correction used in early Mac display systems was implemented as |
* a power 1.45 lookup table. |
* |
* Any system where a programmable lookup table is used or where the behavior of |
* the final display device characteristics can be changed requires system |
* specific code to obtain the current characteristic. However this can be |
* difficult and most PNG gamma correction only requires an approximate value. |
* |
* By default, if png_set_alpha_mode() is not called, libpng assumes that all |
* values are unencoded, linear, values and that the output device also has a |
* linear characteristic. This is only very rarely correct - it is invariably |
* better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the |
* default if you don't know what the right answer is! |
* |
* The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS |
* 10.6) which used a correction table to implement a somewhat lower gamma on an |
* otherwise sRGB system. |
* |
* Both these values are reserved (not simple gamma values) in order to allow |
* more precise correction internally in the future. |
* |
* NOTE: the following values can be passed to either the fixed or floating |
* point APIs, but the floating point API will also accept floating point |
* values. |
*/ |
#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ |
#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ |
#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ |
#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ |
#endif |
/* The following are examples of calls to png_set_alpha_mode to achieve the |
* required overall gamma correction and, where necessary, alpha |
* premultiplication. |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); |
* This is the default libpng handling of the alpha channel - it is not |
* pre-multiplied into the color components. In addition the call states |
* that the output is for a sRGB system and causes all PNG files without gAMA |
* chunks to be assumed to be encoded using sRGB. |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); |
* In this case the output is assumed to be something like an sRGB conformant |
* display preceeded by a power-law lookup table of power 1.45. This is how |
* early Mac systems behaved. |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); |
* This is the classic Jim Blinn approach and will work in academic |
* environments where everything is done by the book. It has the shortcoming |
* of assuming that input PNG data with no gamma information is linear - this |
* is unlikely to be correct unless the PNG files where generated locally. |
* Most of the time the output precision will be so low as to show |
* significant banding in dark areas of the image. |
* |
* png_set_expand_16(pp); |
* png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); |
* This is a somewhat more realistic Jim Blinn inspired approach. PNG files |
* are assumed to have the sRGB encoding if not marked with a gamma value and |
* the output is always 16 bits per component. This permits accurate scaling |
* and processing of the data. If you know that your input PNG files were |
* generated locally you might need to replace PNG_DEFAULT_sRGB with the |
* correct value for your system. |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); |
* If you just need to composite the PNG image onto an existing background |
* and if you control the code that does this you can use the optimization |
* setting. In this case you just copy completely opaque pixels to the |
* output. For pixels that are not completely transparent (you just skip |
* those) you do the composition math using png_composite or png_composite_16 |
* below then encode the resultant 8-bit or 16-bit values to match the output |
* encoding. |
* |
* Other cases |
* If neither the PNG nor the standard linear encoding work for you because |
* of the software or hardware you use then you have a big problem. The PNG |
* case will probably result in halos around the image. The linear encoding |
* will probably result in a washed out, too bright, image (it's actually too |
* contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably |
* substantially reduce the halos. Alternatively try: |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); |
* This option will also reduce the halos, but there will be slight dark |
* halos round the opaque parts of the image where the background is light. |
* In the OPTIMIZED mode the halos will be light halos where the background |
* is dark. Take your pick - the halos are unavoidable unless you can get |
* your hardware/software fixed! (The OPTIMIZED approach is slightly |
* faster.) |
* |
* When the default gamma of PNG files doesn't match the output gamma. |
* If you have PNG files with no gamma information png_set_alpha_mode allows |
* you to provide a default gamma, but it also sets the ouput gamma to the |
* matching value. If you know your PNG files have a gamma that doesn't |
* match the output you can take advantage of the fact that |
* png_set_alpha_mode always sets the output gamma but only sets the PNG |
* default if it is not already set: |
* |
* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); |
* png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); |
* The first call sets both the default and the output gamma values, the |
* second call overrides the output gamma without changing the default. This |
* is easier than achieving the same effect with png_set_gamma. You must use |
* PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will |
* fire if more than one call to png_set_alpha_mode and png_set_background is |
* made in the same read operation, however multiple calls with PNG_ALPHA_PNG |
* are ignored. |
*/ |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr)); |
PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr)); |
PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr)); |
PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ |
PNG_EXPORT(39, void, png_set_filler, (png_structp png_ptr, png_uint_32 filler, |
PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler, |
int flags)); |
/* The values of the PNG_FILLER_ defines should NOT be changed */ |
# define PNG_FILLER_BEFORE 0 |
# define PNG_FILLER_AFTER 1 |
/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ |
PNG_EXPORT(40, void, png_set_add_alpha, |
(png_structp png_ptr, png_uint_32 filler, |
int flags)); |
PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr, |
png_uint_32 filler, int flags)); |
#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* Swap bytes in 16-bit depth files. */ |
PNG_EXPORT(41, void, png_set_swap, (png_structp png_ptr)); |
PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ |
PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr)); |
PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ |
defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* Swap packing order of pixels in bytes. */ |
PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr)); |
PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Converts files to legal bit depths. */ |
PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_color_8p |
PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p |
true_bits)); |
#endif |
1142,22 → 1462,26 |
* necessary to call png_read_row or png_read_rows png_get_image_height |
* times for each pass. |
*/ |
PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr)); |
PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
/* Invert monochrome files */ |
PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr)); |
PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* Handle alpha and tRNS by replacing with a background color. */ |
PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr, |
/* Handle alpha and tRNS by replacing with a background color. Prior to |
* libpng-1.5.4 this API must not be called before the PNG file header has been |
* read. Doing so will result in unexpected behavior and possible warnings or |
* errors if the PNG file contains a bKGD chunk. |
*/ |
PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma)); |
PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr, |
int need_expand, double background_gamma)) |
PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, png_fixed_point background_gamma)); |
int need_expand, png_fixed_point background_gamma)) |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 |
1166,9 → 1490,15 |
# define PNG_BACKGROUND_GAMMA_UNIQUE 3 |
#endif |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
/* Scale a 16-bit depth file down to 8-bit, accurately. */ |
PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ |
/* Strip the second byte of information from a 16-bit depth file. */ |
PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr)); |
PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
1175,10 → 1505,9 |
/* Turn on quantizing, and reduce the palette to the number of colors |
* available. |
*/ |
PNG_EXPORT(49, void, png_set_quantize, |
(png_structp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_const_uint_16p histogram, |
int full_quantize)); |
PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr, |
png_colorp palette, int num_palette, int maximum_colors, |
png_const_uint_16p histogram, int full_quantize)); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
1187,48 → 1516,57 |
*/ |
#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) |
/* Handle gamma correction. Screen_gamma=(display_exponent) */ |
PNG_FP_EXPORT(50, void, png_set_gamma, |
(png_structp png_ptr, double screen_gamma, |
double default_file_gamma)); |
PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr, |
png_fixed_point screen_gamma, png_fixed_point default_file_gamma)); |
/* Handle gamma correction. Screen_gamma=(display_exponent). |
* NOTE: this API simply sets the screen and file gamma values. It will |
* therefore override the value for gamma in a PNG file if it is called after |
* the file header has been read - use with care - call before reading the PNG |
* file for best results! |
* |
* These routines accept the same gamma values as png_set_alpha_mode (described |
* above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either |
* API (floating point or fixed.) Notice, however, that the 'file_gamma' value |
* is the inverse of a 'screen gamma' value. |
*/ |
PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr, |
double screen_gamma, double override_file_gamma)) |
PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr, |
png_fixed_point screen_gamma, png_fixed_point override_file_gamma)) |
#endif |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
/* Set how many lines between output flushes - 0 for no flushing */ |
PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows)); |
PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows)); |
/* Flush the current PNG output buffer */ |
PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr)); |
PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr)); |
#endif |
/* Optional update palette with requested transformations */ |
PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr)); |
PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr)); |
/* Optional call to update the users info structure */ |
PNG_EXPORT(54, void, png_read_update_info, |
(png_structp png_ptr, png_infop info_ptr)); |
PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr, |
png_inforp info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read one or more rows of image data. */ |
PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row, |
PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row, |
png_bytepp display_row, png_uint_32 num_rows)); |
#endif |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read a row of data. */ |
PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row, |
PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row, |
png_bytep display_row)); |
#endif |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the whole image into memory at once. */ |
PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image)); |
PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image)); |
#endif |
/* Write a row of image data */ |
PNG_EXPORT(58, void, png_write_row, |
(png_structp png_ptr, png_const_bytep row)); |
PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr, |
png_const_bytep row)); |
/* Write a few rows of image data: (*row) is not written; however, the type |
* is declared as writeable to maintain compatibility with previous versions |
1235,24 → 1573,23 |
* of libpng and to allow the 'display_row' array from read_rows to be passed |
* unchanged to write_rows. |
*/ |
PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row, |
PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row, |
png_uint_32 num_rows)); |
/* Write the image data */ |
PNG_EXPORT(60, void, png_write_image, |
(png_structp png_ptr, png_bytepp image)); |
PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image)); |
/* Write the end of the PNG file. */ |
PNG_EXPORT(61, void, png_write_end, |
(png_structp png_ptr, png_infop info_ptr)); |
PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr, |
png_inforp info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the end of the PNG file. */ |
PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr)); |
PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr)); |
#endif |
/* Free any memory associated with the png_info_struct */ |
PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr, |
PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr, |
png_infopp info_ptr_ptr)); |
/* Free any memory associated with the png_struct and the png_info_structs */ |
1264,8 → 1601,8 |
png_infopp info_ptr_ptr)); |
/* Set the libpng method of handling chunk CRC errors */ |
PNG_EXPORT(66, void, png_set_crc_action, |
(png_structp png_ptr, int crit_action, int ancil_action)); |
PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action, |
int ancil_action)); |
/* Values for png_set_crc_action() say how to handle CRC errors in |
* ancillary and critical chunks, and whether to use the data contained |
1294,8 → 1631,8 |
/* Set the filtering method(s) used by libpng. Currently, the only valid |
* value for "method" is 0. |
*/ |
PNG_EXPORT(67, void, png_set_filter, |
(png_structp png_ptr, int method, int filters)); |
PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method, |
int filters)); |
/* Flags for png_set_filter() to say which filters to use. The flags |
* are chosen so that they don't conflict with real filter types |
1350,13 → 1687,13 |
* the weights and costs are set to 1.0, this degenerates the WEIGHTED method |
* to the UNWEIGHTED method, but with added encoding time/computation. |
*/ |
PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr, |
PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr, |
int heuristic_method, int num_weights, png_const_doublep filter_weights, |
png_const_doublep filter_costs)); |
png_const_doublep filter_costs)) |
PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, |
(png_structp png_ptr, |
int heuristic_method, int num_weights, png_const_fixed_point_p |
filter_weights, png_const_fixed_point_p filter_costs)); |
(png_structrp png_ptr, int heuristic_method, int num_weights, |
png_const_fixed_point_p filter_weights, |
png_const_fixed_point_p filter_costs)) |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
/* Heuristic used for row filter selection. These defines should NOT be |
1367,6 → 1704,7 |
#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ |
#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ |
#ifdef PNG_WRITE_SUPPORTED |
/* Set the library compression level. Currently, valid values range from |
* 0 - 9, corresponding directly to the zlib compression levels 0 - 9 |
* (0 - no compression, 9 - "maximal" compression). Note that tests have |
1374,21 → 1712,46 |
* for PNG images, and do considerably fewer caclulations. In the future, |
* these values may not correspond directly to the zlib compression levels. |
*/ |
PNG_EXPORT(69, void, png_set_compression_level, |
(png_structp png_ptr, int level)); |
PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr, |
int level)); |
PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr, |
PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr, |
int mem_level)); |
PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr, |
PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr, |
int strategy)); |
PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr, |
/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a |
* smaller value of window_bits if it can do so safely. |
*/ |
PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr, |
int window_bits)); |
PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr, |
PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr, |
int method)); |
#endif |
#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED |
/* Also set zlib parameters for compressing non-IDAT chunks */ |
PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr, |
int level)); |
PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr, |
int mem_level)); |
PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr, |
int strategy)); |
/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a |
* smaller value of window_bits if it can do so safely. |
*/ |
PNG_EXPORT(225, void, png_set_text_compression_window_bits, |
(png_structrp png_ptr, int window_bits)); |
PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, |
int method)); |
#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ |
/* These next functions are called for input/output, memory, and error |
* handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, |
* and call standard C I/O routines such as fread(), fwrite(), and |
1400,7 → 1763,7 |
#ifdef PNG_STDIO_SUPPORTED |
/* Initialize the input/output for the PNG file to the default functions. */ |
PNG_EXPORT(74, void, png_init_io, (png_structp png_ptr, png_FILE_p fp)); |
PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp)); |
#endif |
/* Replace the (error and abort), and warning functions with user |
1411,12 → 1774,11 |
* default function will be used. |
*/ |
PNG_EXPORT(75, void, png_set_error_fn, |
(png_structp png_ptr, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warning_fn)); |
PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr, |
png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); |
/* Return the user pointer associated with the error functions */ |
PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structp png_ptr)); |
PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr)); |
/* Replace the default data output functions with a user supplied one(s). |
* If buffered output is not used, then output_flush_fn can be set to NULL. |
1428,47 → 1790,47 |
* default flush function, which uses the standard *FILE structure, will |
* be used. |
*/ |
PNG_EXPORT(77, void, png_set_write_fn, (png_structp png_ptr, png_voidp io_ptr, |
PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr, |
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); |
/* Replace the default data input function with a user supplied one. */ |
PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr, |
PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn)); |
/* Return the user pointer associated with the I/O functions */ |
PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr)); |
PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr)); |
PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr, |
PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr, |
png_read_status_ptr read_row_fn)); |
PNG_EXPORT(81, void, png_set_write_status_fn, (png_structp png_ptr, |
PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr, |
png_write_status_ptr write_row_fn)); |
#ifdef PNG_USER_MEM_SUPPORTED |
/* Replace the default memory allocation functions with user supplied one(s). */ |
PNG_EXPORT(82, void, png_set_mem_fn, (png_structp png_ptr, png_voidp mem_ptr, |
PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
/* Return the user pointer associated with the memory functions */ |
PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr)); |
PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr)); |
#endif |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr, |
PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr, |
png_user_transform_ptr read_user_transform_fn)); |
#endif |
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED |
PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr, |
PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr, |
png_user_transform_ptr write_user_transform_fn)); |
#endif |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
PNG_EXPORT(86, void, png_set_user_transform_info, (png_structp png_ptr, |
PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr, |
png_voidp user_transform_ptr, int user_transform_depth, |
int user_transform_channels)); |
/* Return the user pointer associated with the user transform functions */ |
PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
#endif |
#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED |
1475,35 → 1837,61 |
/* Return information about the row currently being processed. Note that these |
* APIs do not fail but will return unexpected results if called outside a user |
* transform callback. Also note that when transforming an interlaced image the |
* row number is still the row in the final, de-interlaced, image but the row |
* only contains the data of the current pass - consult png_row_info for the |
* actual width of the row! |
* row number is the row number within the sub-image of the interlace pass, so |
* the value will increase to the height of the sub-image (not the full image) |
* then reset to 0 for the next pass. |
* |
* Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to |
* find the output pixel (x,y) given an interlaced sub-image pixel |
* (row,col,pass). (See below for these macros.) |
*/ |
PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp)); |
PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp)); |
PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp)); |
PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr, |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
/* This callback is called only for *unknown* chunks. If |
* PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known |
* chunks to be treated as unknown, however in this case the callback must do |
* any processing required by the chunk (e.g. by calling the appropriate |
* png_set_ APIs.) |
* |
* There is no write support - on write, by default, all the chunks in the |
* 'unknown' list are written in the specified position. |
* |
* The integer return from the callback function is interpreted thus: |
* |
* negative: An error occured, png_chunk_error will be called. |
* zero: The chunk was not handled, the chunk will be saved. A critical |
* chunk will cause an error at this point unless it is to be saved. |
* positive: The chunk was handled, libpng will ignore/discard it. |
* |
* See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about |
* how this behavior will change in libpng 1.7 |
*/ |
PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr, |
png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); |
PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structp png_ptr)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr)); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
/* Sets the function callbacks for the push reader, and a pointer to a |
* user-defined structure available to the callback functions. |
*/ |
PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structp png_ptr, |
PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr, |
png_voidp progressive_ptr, png_progressive_info_ptr info_fn, |
png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); |
/* Returns the user pointer associated with the push read functions */ |
PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr)); |
PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, |
(png_const_structrp png_ptr)); |
/* Function to be called when data becomes available */ |
PNG_EXPORT(92, void, png_process_data, |
(png_structp png_ptr, png_infop info_ptr, |
png_bytep buffer, png_size_t buffer_size)); |
PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr, |
png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size)); |
/* A function which may be called *only* within png_process_data to stop the |
* processing of any more data. The function returns the number of bytes |
1512,7 → 1900,7 |
* 'save' is set to true the routine will first save all the pending data and |
* will always return 0. |
*/ |
PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save)); |
PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save)); |
/* A function which may be called *only* outside (after) a call to |
* png_process_data. It returns the number of bytes of data to skip in the |
1520,40 → 1908,45 |
* application must skip than number of bytes of input data and pass the |
* following data to the next call to png_process_data. |
*/ |
PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp)); |
PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp)); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Function that combines rows. 'new_row' is a flag that should come from |
* the callback and be non-NULL if anything needs to be done; the library |
* stores its own version of the new data internally and ignores the passed |
* in value. |
*/ |
PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr, |
PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr, |
png_bytep old_row, png_const_bytep new_row)); |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
PNG_EXPORTA(94, png_voidp, png_malloc, |
(png_structp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED); |
PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
/* Added at libpng version 1.4.0 */ |
PNG_EXPORTA(95, png_voidp, png_calloc, |
(png_structp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED); |
PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
/* Added at libpng version 1.2.4 */ |
PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr, |
PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
/* Frees a pointer allocated by png_malloc() */ |
PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr)); |
PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr)); |
/* Free data that was allocated internally */ |
PNG_EXPORT(98, void, png_free_data, |
(png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num)); |
PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_uint_32 free_me, int num)); |
/* Reassign responsibility for freeing existing data, whether allocated |
* by libpng or by the application */ |
PNG_EXPORT(99, void, png_data_freer, |
(png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)); |
* by libpng or by the application; this works on the png_info structure passed |
* in, it does not change the state for other png_info structures. |
* |
* It is unlikely that this function works correctly as of 1.6.0 and using it |
* may result either in memory leaks or double free of allocated data. |
*/ |
PNG_EXPORTA(99, void, png_data_freer, (png_const_structrp png_ptr, |
png_inforp info_ptr, int freer, png_uint_32 mask), PNG_DEPRECATED); |
/* Assignments for png_data_freer */ |
#define PNG_DESTROY_WILL_FREE_DATA 1 |
1566,8 → 1959,10 |
#define PNG_FREE_ROWS 0x0040 |
#define PNG_FREE_PCAL 0x0080 |
#define PNG_FREE_SCAL 0x0100 |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_FREE_UNKN 0x0200 |
#define PNG_FREE_LIST 0x0400 |
#endif |
/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */ |
#define PNG_FREE_PLTE 0x1000 |
#define PNG_FREE_TRNS 0x2000 |
#define PNG_FREE_TEXT 0x4000 |
1575,48 → 1970,50 |
#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ |
#ifdef PNG_USER_MEM_SUPPORTED |
PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr)); |
PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED); |
PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr, |
png_voidp ptr), PNG_DEPRECATED); |
#endif |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
/* Fatal error in PNG image of libpng - can't continue */ |
PNG_EXPORTA(102, void, png_error, |
(png_structp png_ptr, png_const_charp error_message), |
PNG_NORETURN); |
PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr, |
png_const_charp error_message), PNG_NORETURN); |
/* The same, but the chunk name is prepended to the error string. */ |
PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr, |
PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr, |
png_const_charp error_message), PNG_NORETURN); |
#else |
/* Fatal error in PNG image of libpng - can't continue */ |
PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN); |
PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN); |
#endif |
#ifdef PNG_WARNINGS_SUPPORTED |
/* Non-fatal error in libpng. Can continue, but may have a problem. */ |
PNG_EXPORT(105, void, png_warning, (png_structp png_ptr, |
PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr, |
png_const_charp warning_message)); |
/* Non-fatal error in libpng, chunk name is prepended to message. */ |
PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr, |
PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr, |
png_const_charp warning_message)); |
#endif |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
/* Benign error in libpng. Can continue, but may have a problem. |
* User can choose whether to handle as a fatal error or as a warning. */ |
# undef png_benign_error |
PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr, |
PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr, |
png_const_charp warning_message)); |
/* Same, chunk name is prepended to message. */ |
# undef png_chunk_benign_error |
PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr, |
#ifdef PNG_READ_SUPPORTED |
/* Same, chunk name is prepended to message (only during read) */ |
PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr, |
png_const_charp warning_message)); |
#endif |
PNG_EXPORT(109, void, png_set_benign_errors, |
(png_structp png_ptr, int allowed)); |
(png_structrp png_ptr, int allowed)); |
#else |
# ifdef PNG_ALLOW_BENIGN_ERRORS |
# define png_benign_error png_warning |
1640,268 → 2037,274 |
* png_info_struct. |
*/ |
/* Returns "flag" if chunk data is valid in info_ptr. */ |
PNG_EXPORT(110, png_uint_32, png_get_valid, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 flag)); |
PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, png_uint_32 flag)); |
/* Returns number of bytes needed to hold a transformed row. */ |
PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
/* Returns row_pointers, which is an array of pointers to scanlines that was |
* returned from png_read_png(). |
*/ |
PNG_EXPORT(112, png_bytepp, png_get_rows, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Set row_pointers, which is an array of pointers to scanlines for use |
* by png_write_png(). |
*/ |
PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr, |
png_infop info_ptr, png_bytepp row_pointers)); |
PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_bytepp row_pointers)); |
#endif |
/* Returns number of color channels in image. */ |
PNG_EXPORT(114, png_byte, png_get_channels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* Returns image width in pixels. */ |
PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image height in pixels. */ |
PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image bit_depth. */ |
PNG_EXPORT(117, png_byte, png_get_bit_depth, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image color_type. */ |
PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image filter_type. */ |
PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image interlace_type. */ |
PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image compression_type. */ |
PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
/* Returns image resolution in pixels per meter, from pHYs chunk data. */ |
PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
/* Returns pixel aspect ratio, computed from pHYs chunk data. */ |
PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)) |
PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)) |
/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ |
PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
#ifdef PNG_READ_SUPPORTED |
/* Returns pointer to signature string read from PNG header */ |
PNG_EXPORT(130, png_const_bytep, png_get_signature, |
(png_const_structp png_ptr, png_infop info_ptr)); |
PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)); |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
PNG_EXPORT(131, png_uint_32, png_get_bKGD, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_color_16p *background)); |
PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_color_16p *background)); |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr, |
png_const_color_16p background)); |
PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_color_16p background)); |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr, |
png_const_infop info_ptr, double *white_x, double *white_y, double *red_x, |
PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, |
double *red_y, double *green_x, double *green_y, double *blue_x, |
double *blue_y)); |
#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */ |
double *blue_y)) |
PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, |
double *green_X, double *green_Y, double *green_Z, double *blue_X, |
double *blue_Y, double *blue_Z)) |
PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, |
(png_const_structp png_ptr, |
png_const_infop info_ptr, png_fixed_point *int_white_x, |
png_fixed_point *int_white_y, png_fixed_point *int_red_x, |
png_fixed_point *int_red_y, png_fixed_point *int_green_x, |
png_fixed_point *int_green_y, png_fixed_point *int_blue_x, |
png_fixed_point *int_blue_y)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *int_white_x, png_fixed_point *int_white_y, |
png_fixed_point *int_red_x, png_fixed_point *int_red_y, |
png_fixed_point *int_green_x, png_fixed_point *int_green_y, |
png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)) |
PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, |
(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *int_red_X, png_fixed_point *int_red_Y, |
png_fixed_point *int_red_Z, png_fixed_point *int_green_X, |
png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, |
png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, |
png_fixed_point *int_blue_Z)) |
#endif |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
PNG_FP_EXPORT(135, void, png_set_cHRM, |
(png_structp png_ptr, png_infop info_ptr, |
PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr, |
png_inforp info_ptr, |
double white_x, double white_y, double red_x, double red_y, double green_x, |
double green_y, double blue_x, double blue_y)); |
PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_white_x, |
double green_y, double blue_x, double blue_y)) |
PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr, |
png_inforp info_ptr, double red_X, double red_Y, double red_Z, |
double green_X, double green_Y, double green_Z, double blue_X, |
double blue_Y, double blue_Z)) |
PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_fixed_point int_white_x, |
png_fixed_point int_white_y, png_fixed_point int_red_x, |
png_fixed_point int_red_y, png_fixed_point int_green_x, |
png_fixed_point int_green_y, png_fixed_point int_blue_x, |
png_fixed_point int_blue_y)); |
png_fixed_point int_blue_y)) |
PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, |
png_fixed_point int_red_Z, png_fixed_point int_green_X, |
png_fixed_point int_green_Y, png_fixed_point int_green_Z, |
png_fixed_point int_blue_X, png_fixed_point int_blue_Y, |
png_fixed_point int_blue_Z)) |
#endif |
#ifdef PNG_gAMA_SUPPORTED |
PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
double *file_gamma)); |
PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, double *file_gamma)) |
PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_fixed_point *int_file_gamma)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *int_file_gamma)) |
#endif |
#ifdef PNG_gAMA_SUPPORTED |
PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr, |
png_infop info_ptr, double file_gamma)); |
PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_file_gamma)); |
PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr, |
png_inforp info_ptr, double file_gamma)) |
PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_fixed_point int_file_gamma)) |
#endif |
#ifdef PNG_hIST_SUPPORTED |
PNG_EXPORT(141, png_uint_32, png_get_hIST, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_16p *hist)); |
PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_uint_16p *hist)); |
#endif |
#ifdef PNG_hIST_SUPPORTED |
PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr, |
png_infop info_ptr, png_const_uint_16p hist)); |
PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_uint_16p hist)); |
#endif |
PNG_EXPORT(143, png_uint_32, png_get_IHDR, |
(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, |
int *interlace_method, int *compression_method, int *filter_method)); |
PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, |
int *bit_depth, int *color_type, int *interlace_method, |
int *compression_method, int *filter_method)); |
PNG_EXPORT(144, void, png_set_IHDR, |
(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, |
int interlace_method, int compression_method, int filter_method)); |
PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_method, int compression_method, |
int filter_method)); |
#ifdef PNG_oFFs_SUPPORTED |
PNG_EXPORT(145, png_uint_32, png_get_oFFs, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)); |
PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, |
int *unit_type)); |
#endif |
#ifdef PNG_oFFs_SUPPORTED |
PNG_EXPORT(146, void, png_set_oFFs, |
(png_structp png_ptr, png_infop info_ptr, |
png_int_32 offset_x, png_int_32 offset_y, int unit_type)); |
PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, |
int unit_type)); |
#endif |
#ifdef PNG_pCAL_SUPPORTED |
PNG_EXPORT(147, png_uint_32, png_get_pCAL, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, |
int *nparams, |
png_charp *units, png_charpp *params)); |
PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, |
png_int_32 *X1, int *type, int *nparams, png_charp *units, |
png_charpp *params)); |
#endif |
#ifdef PNG_pCAL_SUPPORTED |
PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr, |
png_infop info_ptr, |
png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, |
int nparams, png_const_charp units, png_charpp params)); |
PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, |
int type, int nparams, png_const_charp units, png_charpp params)); |
#endif |
#ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(149, png_uint_32, png_get_pHYs, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, |
int *unit_type)); |
#endif |
#ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(150, void, png_set_pHYs, |
(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
#endif |
PNG_EXPORT(151, png_uint_32, png_get_PLTE, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_colorp *palette, int *num_palette)); |
PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_colorp *palette, int *num_palette)); |
PNG_EXPORT(152, void, png_set_PLTE, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_colorp palette, int num_palette)); |
PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr, |
png_inforp info_ptr, png_const_colorp palette, int num_palette)); |
#ifdef PNG_sBIT_SUPPORTED |
PNG_EXPORT(153, png_uint_32, png_get_sBIT, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_color_8p *sig_bit)); |
PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_color_8p *sig_bit)); |
#endif |
#ifdef PNG_sBIT_SUPPORTED |
PNG_EXPORT(154, void, png_set_sBIT, |
(png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit)); |
PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_color_8p sig_bit)); |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr, |
png_const_infop info_ptr, int *file_srgb_intent)); |
PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, int *file_srgb_intent)); |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
PNG_EXPORT(156, void, png_set_sRGB, |
(png_structp png_ptr, png_infop info_ptr, int srgb_intent)); |
PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr, |
png_infop info_ptr, int srgb_intent)); |
PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr, |
png_inforp info_ptr, int srgb_intent)); |
PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr, |
png_inforp info_ptr, int srgb_intent)); |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
PNG_EXPORT(158, png_uint_32, png_get_iCCP, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_charpp name, int *compression_type, png_bytepp profile, |
png_uint_32 *proflen)); |
PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_charpp name, int *compression_type, |
png_bytepp profile, png_uint_32 *proflen)); |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
PNG_EXPORT(159, void, png_set_iCCP, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_charp name, int compression_type, png_const_bytep profile, |
png_uint_32 proflen)); |
PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_charp name, int compression_type, |
png_const_bytep profile, png_uint_32 proflen)); |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
PNG_EXPORT(160, png_uint_32, png_get_sPLT, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_sPLT_tpp entries)); |
PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_sPLT_tpp entries)); |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
PNG_EXPORT(161, void, png_set_sPLT, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_sPLT_tp entries, int nentries)); |
PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)); |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
/* png_get_text also returns the number of text chunks in *num_text */ |
PNG_EXPORT(162, png_uint_32, png_get_text, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_textp *text_ptr, int *num_text)); |
PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_textp *text_ptr, int *num_text)); |
#endif |
/* Note while png_set_text() will accept a structure whose text, |
1912,39 → 2315,37 |
*/ |
#ifdef PNG_TEXT_SUPPORTED |
PNG_EXPORT(163, void, png_set_text, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_textp text_ptr, int num_text)); |
PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_textp text_ptr, int num_text)); |
#endif |
#ifdef PNG_tIME_SUPPORTED |
PNG_EXPORT(164, png_uint_32, png_get_tIME, |
(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)); |
PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_timep *mod_time)); |
#endif |
#ifdef PNG_tIME_SUPPORTED |
PNG_EXPORT(165, void, png_set_tIME, |
(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)); |
PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_timep mod_time)); |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
PNG_EXPORT(166, png_uint_32, png_get_tRNS, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)); |
PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, |
png_color_16p *trans_color)); |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
PNG_EXPORT(167, void, png_set_tRNS, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_bytep trans_alpha, int num_trans, |
PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr, |
png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, |
png_const_color_16p trans_color)); |
#endif |
#ifdef PNG_sCAL_SUPPORTED |
PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
int *unit, double *width, double *height)); |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, int *unit, double *width, double *height)) |
#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
/* NOTE: this API is currently implemented using floating point arithmetic, |
* consequently it can only be used on systems with floating point support. |
* In any case the range of values supported by png_fixed_point is small and it |
1951,49 → 2352,151 |
* is highly recommended that png_get_sCAL_s be used instead. |
*/ |
PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, |
(png_structp png_ptr, png_const_infop info_ptr, int *unit, |
png_fixed_point *width, |
png_fixed_point *height)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, |
png_fixed_point *width, png_fixed_point *height)) |
#endif |
PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
int *unit, png_charpp swidth, png_charpp sheight)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, |
png_charpp swidth, png_charpp sheight)); |
PNG_FP_EXPORT(170, void, png_set_sCAL, |
(png_structp png_ptr, png_infop info_ptr, |
int unit, double width, double height)); |
PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr, |
png_infop info_ptr, int unit, png_fixed_point width, |
png_fixed_point height)); |
PNG_EXPORT(171, void, png_set_sCAL_s, |
(png_structp png_ptr, png_infop info_ptr, |
int unit, png_const_charp swidth, png_const_charp sheight)); |
PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr, |
png_inforp info_ptr, int unit, double width, double height)) |
PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr, |
png_inforp info_ptr, int unit, png_fixed_point width, |
png_fixed_point height)) |
PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr, |
png_inforp info_ptr, int unit, |
png_const_charp swidth, png_const_charp sheight)); |
#endif /* PNG_sCAL_SUPPORTED */ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
/* Provide a list of chunks and how they are to be handled, if the built-in |
handling or default unknown chunk handling is not desired. Any chunks not |
listed will be handled in the default manner. The IHDR and IEND chunks |
must not be listed. |
keep = 0: follow default behaviour |
= 1: do not keep |
= 2: keep only if safe-to-copy |
= 3: keep even if unsafe-to-copy |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
/* Provide the default handling for all unknown chunks or, optionally, for |
* specific unknown chunks. |
* |
* NOTE: prior to 1.6.0 the handling specified for particular chunks on read was |
* ignored and the default was used, the per-chunk setting only had an effect on |
* write. If you wish to have chunk-specific handling on read in code that must |
* work on earlier versions you must use a user chunk callback to specify the |
* desired handling (keep or discard.) |
* |
* The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The |
* parameter is interpreted as follows: |
* |
* READ: |
* PNG_HANDLE_CHUNK_AS_DEFAULT: |
* Known chunks: do normal libpng processing, do not keep the chunk (but |
* see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
* Unknown chunks: for a specific chunk use the global default, when used |
* as the default discard the chunk data. |
* PNG_HANDLE_CHUNK_NEVER: |
* Discard the chunk data. |
* PNG_HANDLE_CHUNK_IF_SAFE: |
* Keep the chunk data if the chunk is not critical else raise a chunk |
* error. |
* PNG_HANDLE_CHUNK_ALWAYS: |
* Keep the chunk data. |
* |
* If the chunk data is saved it can be retrieved using png_get_unknown_chunks, |
* below. Notice that specifying "AS_DEFAULT" as a global default is equivalent |
* to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks |
* it simply resets the behavior to the libpng default. |
* |
* INTERACTION WTIH USER CHUNK CALLBACKS: |
* The per-chunk handling is always used when there is a png_user_chunk_ptr |
* callback and the callback returns 0; the chunk is then always stored *unless* |
* it is critical and the per-chunk setting is other than ALWAYS. Notice that |
* the global default is *not* used in this case. (In effect the per-chunk |
* value is incremented to at least IF_SAFE.) |
* |
* IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and |
* per-chunk defaults will be honored. If you want to preserve the current |
* behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE |
* as the default - if you don't do this libpng 1.6 will issue a warning. |
* |
* If you want unhandled unknown chunks to be discarded in libpng 1.6 and |
* earlier simply return '1' (handled). |
* |
* PNG_HANDLE_AS_UNKNOWN_SUPPORTED: |
* If this is *not* set known chunks will always be handled by libpng and |
* will never be stored in the unknown chunk list. Known chunks listed to |
* png_set_keep_unknown_chunks will have no effect. If it is set then known |
* chunks listed with a keep other than AS_DEFAULT will *never* be processed |
* by libpng, in addition critical chunks must either be processed by the |
* callback or saved. |
* |
* The IHDR and IEND chunks must not be listed. Because this turns off the |
* default handling for chunks that would otherwise be recognized the |
* behavior of libpng transformations may well become incorrect! |
* |
* WRITE: |
* When writing chunks the options only apply to the chunks specified by |
* png_set_unknown_chunks (below), libpng will *always* write known chunks |
* required by png_set_ calls and will always write the core critical chunks |
* (as required for PLTE). |
* |
* Each chunk in the png_set_unknown_chunks list is looked up in the |
* png_set_keep_unknown_chunks list to find the keep setting, this is then |
* interpreted as follows: |
* |
* PNG_HANDLE_CHUNK_AS_DEFAULT: |
* Write safe-to-copy chunks and write other chunks if the global |
* default is set to _ALWAYS, otherwise don't write this chunk. |
* PNG_HANDLE_CHUNK_NEVER: |
* Do not write the chunk. |
* PNG_HANDLE_CHUNK_IF_SAFE: |
* Write the chunk if it is safe-to-copy, otherwise do not write it. |
* PNG_HANDLE_CHUNK_ALWAYS: |
* Write the chunk. |
* |
* Note that the default behavior is effectively the opposite of the read case - |
* in read unknown chunks are not stored by default, in write they are written |
* by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different |
* - on write the safe-to-copy bit is checked, on read the critical bit is |
* checked and on read if the chunk is critical an error will be raised. |
* |
* num_chunks: |
* =========== |
* If num_chunks is positive, then the "keep" parameter specifies the manner |
* for handling only those chunks appearing in the chunk_list array, |
* otherwise the chunk list array is ignored. |
* |
* If num_chunks is 0 the "keep" parameter specifies the default behavior for |
* unknown chunks, as described above. |
* |
* If num_chunks is negative, then the "keep" parameter specifies the manner |
* for handling all unknown chunks plus all chunks recognized by libpng |
* except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to |
* be processed by libpng. |
*/ |
PNG_EXPORT(172, void, png_set_keep_unknown_chunks, |
(png_structp png_ptr, int keep, |
png_const_bytep chunk_list, int num_chunks)); |
PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr, |
PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, |
int keep, png_const_bytep chunk_list, int num_chunks)); |
/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned; |
* the result is therefore true (non-zero) if special handling is required, |
* false for the default handling. |
*/ |
PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr, |
png_const_bytep chunk_name)); |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr, |
png_infop info_ptr, png_const_unknown_chunkp unknowns, |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_unknown_chunkp unknowns, |
int num_unknowns)); |
/* NOTE: prior to 1.6.0 this routine set the 'location' field of the added |
* unknowns to the location currently stored in the png_struct. This is |
* invariably the wrong value on write. To fix this call the following API |
* for each chunk in the list with the correct location. If you know your |
* code won't be compiled on earlier versions you can rely on |
* png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing |
* the correct thing. |
*/ |
PNG_EXPORT(175, void, png_set_unknown_chunk_location, |
(png_structp png_ptr, png_infop info_ptr, int chunk, int location)); |
PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr, |
png_const_infop info_ptr, png_unknown_chunkpp entries)); |
(png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)); |
PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr, |
png_inforp info_ptr, png_unknown_chunkpp entries)); |
#endif |
/* Png_free_data() will turn off the "valid" flag for anything it frees. |
2000,28 → 2503,28 |
* If you need to turn it off for a chunk that your application has freed, |
* you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); |
*/ |
PNG_EXPORT(177, void, png_set_invalid, |
(png_structp png_ptr, png_infop info_ptr, int mask)); |
PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr, |
png_inforp info_ptr, int mask)); |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
/* The "params" pointer is currently not used and is for future expansion. */ |
PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr, |
PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr, |
int transforms, png_voidp params)); |
PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr, |
PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr, |
int transforms, png_voidp params)); |
#endif |
PNG_EXPORT(180, png_const_charp, png_get_copyright, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
PNG_EXPORT(181, png_const_charp, png_get_header_ver, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
PNG_EXPORT(182, png_const_charp, png_get_header_version, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr, |
PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr, |
png_uint_32 mng_features_permitted)); |
#endif |
2030,63 → 2533,63 |
#define PNG_HANDLE_CHUNK_NEVER 1 |
#define PNG_HANDLE_CHUNK_IF_SAFE 2 |
#define PNG_HANDLE_CHUNK_ALWAYS 3 |
#define PNG_HANDLE_CHUNK_LAST 4 |
/* Strip the prepended error numbers ("#nnn ") from error and warning |
* messages before passing them to the error or warning handler. |
*/ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
PNG_EXPORT(185, void, png_set_strip_error_numbers, |
(png_structp png_ptr, |
PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr, |
png_uint_32 strip_mode)); |
#endif |
/* Added in libpng-1.2.6 */ |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr, |
PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr, |
png_uint_32 user_width_max, png_uint_32 user_height_max)); |
PNG_EXPORT(187, png_uint_32, png_get_user_width_max, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
PNG_EXPORT(188, png_uint_32, png_get_user_height_max, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
/* Added in libpng-1.4.0 */ |
PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr, |
PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr, |
png_uint_32 user_chunk_cache_max)); |
PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
/* Added in libpng-1.4.1 */ |
PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr, |
PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr, |
png_alloc_size_t user_chunk_cache_max)); |
PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
#endif |
#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) |
PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)); |
PNG_FP_EXPORT(196, float, png_get_x_offset_inches, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)) |
#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ |
PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, |
(png_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)) |
#endif |
PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr, |
png_const_inforp info_ptr)) |
#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ |
PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, |
(png_structp png_ptr, png_const_infop info_ptr)); |
(png_const_structrp png_ptr, png_const_inforp info_ptr)) |
#endif |
# ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr, |
png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, |
PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr, |
png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, |
int *unit_type)); |
# endif /* PNG_pHYs_SUPPORTED */ |
#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ |
2093,12 → 2596,14 |
/* Added in libpng-1.4.0 */ |
#ifdef PNG_IO_STATE_SUPPORTED |
PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr)); |
PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr)); |
PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name, |
(png_structp png_ptr), PNG_DEPRECATED); |
/* Removed from libpng 1.6; use png_get_io_chunk_type. */ |
PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr), |
PNG_DEPRECATED) |
PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, |
(png_const_structp png_ptr)); |
(png_const_structrp png_ptr)); |
/* The flags returned by png_get_io_state() are the following: */ |
# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ |
2122,9 → 2627,17 |
* full, image which appears in a given pass. 'pass' is in the range 0 |
* to 6 and the result is in the range 0 to 7. |
*/ |
#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7) |
#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7) |
#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) |
#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) |
/* A macro to return the offset between pixels in the output row for a pair of |
* pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that |
* follows. Note that ROW_OFFSET is the offset from one row to the next whereas |
* COL_OFFSET is from one column to the next, within a row. |
*/ |
#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) |
#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) |
/* Two macros to help evaluate the number of rows or columns in each |
* pass. This is expressed as a shift - effectively log2 of the number or |
* rows or columns in each 8x8 tile of the original image. |
2142,13 → 2655,14 |
#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\ |
-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass)) |
/* For the progressive reader it is necessary to find the row in the output |
* image given a row in an interlaced image, so two more macros: |
/* For the reader row callbacks (both progressive and sequential) it is |
* necessary to find the row in the output image given a row in an interlaced |
* image, so two more macros: |
*/ |
#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \ |
(((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass)) |
#define PNG_COL_FROM_PASS_COL(xIn, pass) \ |
(((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass)) |
#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \ |
(((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass)) |
#define PNG_COL_FROM_PASS_COL(x_in, pass) \ |
(((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass)) |
/* Two macros which return a boolean (0 or 1) saying whether the given row |
* or column is in a particular pass. These use a common utility macro that |
2157,8 → 2671,8 |
* the tile. |
*/ |
#define PNG_PASS_MASK(pass,off) ( \ |
((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \ |
((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U)) |
((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \ |
((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) |
#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ |
((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) |
2184,14 → 2698,14 |
{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ |
* (png_uint_16)(alpha) \ |
+ (png_uint_16)(bg)*(png_uint_16)(255 \ |
- (png_uint_16)(alpha)) + (png_uint_16)128); \ |
- (png_uint_16)(alpha)) + 128); \ |
(composite) = (png_byte)((temp + (temp >> 8)) >> 8); } |
# define png_composite_16(composite, fg, alpha, bg) \ |
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ |
* (png_uint_32)(alpha) \ |
+ (png_uint_32)(bg)*(png_uint_32)(65535L \ |
- (png_uint_32)(alpha)) + (png_uint_32)32768L); \ |
+ (png_uint_32)(bg)*(65535 \ |
- (png_uint_32)(alpha)) + 32768); \ |
(composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } |
#else /* Standard method using integer division */ |
2199,12 → 2713,12 |
# define png_composite(composite, fg, alpha, bg) \ |
(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ |
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ |
(png_uint_16)127) / 255) |
127) / 255) |
# define png_composite_16(composite, fg, alpha, bg) \ |
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ |
(png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ |
(png_uint_32)32767) / (png_uint_32)65535L) |
(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ |
32767) / 65535) |
#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ |
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED |
2213,7 → 2727,7 |
PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); |
#endif |
PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr, |
PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr, |
png_const_bytep buf)); |
/* No png_get_int_16 -- may be added if there's a real need for it. */ |
2239,7 → 2753,7 |
* The png_get_int_32() routine assumes we are using two's complement |
* format for negative values, which is almost certainly true. |
*/ |
# define png_get_uint_32(buf) \ |
# define PNG_get_uint_32(buf) \ |
(((png_uint_32)(*(buf)) << 24) + \ |
((png_uint_32)(*((buf) + 1)) << 16) + \ |
((png_uint_32)(*((buf) + 2)) << 8) + \ |
2248,19 → 2762,539 |
/* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the |
* function) incorrectly returned a value of type png_uint_32. |
*/ |
# define png_get_uint_16(buf) \ |
# define PNG_get_uint_16(buf) \ |
((png_uint_16) \ |
(((unsigned int)(*(buf)) << 8) + \ |
((unsigned int)(*((buf) + 1))))) |
# define png_get_int_32(buf) \ |
# define PNG_get_int_32(buf) \ |
((png_int_32)((*(buf) & 0x80) \ |
? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ |
: (png_int_32)png_get_uint_32(buf))) |
/* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h, |
* but defining a macro name prefixed with PNG_PREFIX. |
*/ |
# ifndef PNG_PREFIX |
# define png_get_uint_32(buf) PNG_get_uint_32(buf) |
# define png_get_uint_16(buf) PNG_get_uint_16(buf) |
# define png_get_int_32(buf) PNG_get_int_32(buf) |
#endif |
#else |
# ifdef PNG_PREFIX |
/* No macros; revert to the (redefined) function */ |
# define PNG_get_uint_32 (png_get_uint_32) |
# define PNG_get_uint_16 (png_get_uint_16) |
# define PNG_get_int_32 (png_get_int_32) |
# endif |
#endif |
/******************************************************************************* |
* SIMPLIFIED API |
******************************************************************************* |
* |
* Please read the documentation in libpng-manual.txt (TODO: write said |
* documentation) if you don't understand what follows. |
* |
* The simplified API hides the details of both libpng and the PNG file format |
* itself. It allows PNG files to be read into a very limited number of |
* in-memory bitmap formats or to be written from the same formats. If these |
* formats do not accomodate your needs then you can, and should, use the more |
* sophisticated APIs above - these support a wide variety of in-memory formats |
* and a wide variety of sophisticated transformations to those formats as well |
* as a wide variety of APIs to manipulate ancillary information. |
* |
* To read a PNG file using the simplified API: |
* |
* 1) Declare a 'png_image' structure (see below) on the stack and set the |
* version field to PNG_IMAGE_VERSION. |
* 2) Call the appropriate png_image_begin_read... function. |
* 3) Set the png_image 'format' member to the required sample format. |
* 4) Allocate a buffer for the image and, if required, the color-map. |
* 5) Call png_image_finish_read to read the image and, if required, the |
* color-map into your buffers. |
* |
* There are no restrictions on the format of the PNG input itself; all valid |
* color types, bit depths, and interlace methods are acceptable, and the |
* input image is transformed as necessary to the requested in-memory format |
* during the png_image_finish_read() step. The only caveat is that if you |
* request a color-mapped image from a PNG that is full-color or makes |
* complex use of an alpha channel the transformation is extremely lossy and the |
* result may look terrible. |
* |
* To write a PNG file using the simplified API: |
* |
* 1) Declare a 'png_image' structure on the stack and memset() it to all zero. |
* 2) Initialize the members of the structure that describe the image, setting |
* the 'format' member to the format of the image samples. |
* 3) Call the appropriate png_image_write... function with a pointer to the |
* image and, if necessary, the color-map to write the PNG data. |
* |
* png_image is a structure that describes the in-memory format of an image |
* when it is being read or defines the in-memory format of an image that you |
* need to write: |
*/ |
#define PNG_IMAGE_VERSION 1 |
typedef struct png_control *png_controlp; |
typedef struct |
{ |
png_controlp opaque; /* Initialize to NULL, free with png_image_free */ |
png_uint_32 version; /* Set to PNG_IMAGE_VERSION */ |
png_uint_32 width; /* Image width in pixels (columns) */ |
png_uint_32 height; /* Image height in pixels (rows) */ |
png_uint_32 format; /* Image format as defined below */ |
png_uint_32 flags; /* A bit mask containing informational flags */ |
png_uint_32 colormap_entries; |
/* Number of entries in the color-map */ |
/* In the event of an error or warning the following field will be set to a |
* non-zero value and the 'message' field will contain a '\0' terminated |
* string with the libpng error or warning message. If both warnings and |
* an error were encountered, only the error is recorded. If there |
* are multiple warnings, only the first one is recorded. |
* |
* The upper 30 bits of this value are reserved, the low two bits contain |
* a value as follows: |
*/ |
# define PNG_IMAGE_WARNING 1 |
# define PNG_IMAGE_ERROR 2 |
/* |
* The result is a two bit code such that a value more than 1 indicates |
* a failure in the API just called: |
* |
* 0 - no warning or error |
* 1 - warning |
* 2 - error |
* 3 - error preceded by warning |
*/ |
# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1) |
png_uint_32 warning_or_error; |
char message[64]; |
} png_image, *png_imagep; |
/* The samples of the image have one to four channels whose components have |
* original values in the range 0 to 1.0: |
* |
* 1: A single gray or luminance channel (G). |
* 2: A gray/luminance channel and an alpha channel (GA). |
* 3: Three red, green, blue color channels (RGB). |
* 4: Three color channels and an alpha channel (RGBA). |
* |
* The components are encoded in one of two ways: |
* |
* a) As a small integer, value 0..255, contained in a single byte. For the |
* alpha channel the original value is simply value/255. For the color or |
* luminance channels the value is encoded according to the sRGB specification |
* and matches the 8-bit format expected by typical display devices. |
* |
* The color/gray channels are not scaled (pre-multiplied) by the alpha |
* channel and are suitable for passing to color management software. |
* |
* b) As a value in the range 0..65535, contained in a 2-byte integer. All |
* channels can be converted to the original value by dividing by 65535; all |
* channels are linear. Color channels use the RGB encoding (RGB end-points) of |
* the sRGB specification. This encoding is identified by the |
* PNG_FORMAT_FLAG_LINEAR flag below. |
* |
* When the simplified API needs to convert between sRGB and linear colorspaces, |
* the actual sRGB transfer curve defined in the sRGB specification (see the |
* article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2 |
* approximation used elsewhere in libpng. |
* |
* When an alpha channel is present it is expected to denote pixel coverage |
* of the color or luminance channels and is returned as an associated alpha |
* channel: the color/gray channels are scaled (pre-multiplied) by the alpha |
* value. |
* |
* The samples are either contained directly in the image data, between 1 and 8 |
* bytes per pixel according to the encoding, or are held in a color-map indexed |
* by bytes in the image data. In the case of a color-map the color-map entries |
* are individual samples, encoded as above, and the image data has one byte per |
* pixel to select the relevant sample from the color-map. |
*/ |
/* PNG_FORMAT_* |
* |
* #defines to be used in png_image::format. Each #define identifies a |
* particular layout of sample data and, if present, alpha values. There are |
* separate defines for each of the two component encodings. |
* |
* A format is built up using single bit flag values. All combinations are |
* valid. Formats can be built up from the flag values or you can use one of |
* the predefined values below. When testing formats always use the FORMAT_FLAG |
* macros to test for individual features - future versions of the library may |
* add new flags. |
* |
* When reading or writing color-mapped images the format should be set to the |
* format of the entries in the color-map then png_image_{read,write}_colormap |
* called to read or write the color-map and set the format correctly for the |
* image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly! |
* |
* NOTE: libpng can be built with particular features disabled, if you see |
* compiler errors because the definition of one of the following flags has been |
* compiled out it is because libpng does not have the required support. It is |
* possible, however, for the libpng configuration to enable the format on just |
* read or just write; in that case you may see an error at run time. You can |
* guard against this by checking for the definition of the appropriate |
* "_SUPPORTED" macro, one of: |
* |
* PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED |
*/ |
#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */ |
#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */ |
#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */ |
#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */ |
#ifdef PNG_FORMAT_BGR_SUPPORTED |
# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */ |
#endif |
#ifdef PNG_FORMAT_AFIRST_SUPPORTED |
# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */ |
#endif |
/* Commonly used formats have predefined macros. |
* |
* First the single byte (sRGB) formats: |
*/ |
#define PNG_FORMAT_GRAY 0 |
#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA |
#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST) |
#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR |
#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR) |
#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA) |
#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST) |
#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA) |
#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST) |
/* Then the linear 2-byte formats. When naming these "Y" is used to |
* indicate a luminance (gray) channel. |
*/ |
#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR |
#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA) |
#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR) |
#define PNG_FORMAT_LINEAR_RGB_ALPHA \ |
(PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA) |
/* With color-mapped formats the image data is one byte for each pixel, the byte |
* is an index into the color-map which is formatted as above. To obtain a |
* color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP |
* to one of the above definitions, or you can use one of the definitions below. |
*/ |
#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP) |
#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP) |
#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP) |
#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP) |
#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP) |
#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP) |
/* PNG_IMAGE macros |
* |
* These are convenience macros to derive information from a png_image |
* structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the |
* actual image sample values - either the entries in the color-map or the |
* pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values |
* for the pixels and will always return 1 for color-mapped formats. The |
* remaining macros return information about the rows in the image and the |
* complete image. |
* |
* NOTE: All the macros that take a png_image::format parameter are compile time |
* constants if the format parameter is, itself, a constant. Therefore these |
* macros can be used in array declarations and case labels where required. |
* Similarly the macros are also pre-processor constants (sizeof is not used) so |
* they can be used in #if tests. |
* |
* First the information about the samples. |
*/ |
#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\ |
(((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1) |
/* Return the total number of channels in a given format: 1..4 */ |
#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\ |
((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1) |
/* Return the size in bytes of a single component of a pixel or color-map |
* entry (as appropriate) in the image: 1 or 2. |
*/ |
#define PNG_IMAGE_SAMPLE_SIZE(fmt)\ |
(PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)) |
/* This is the size of the sample data for one sample. If the image is |
* color-mapped it is the size of one color-map entry (and image pixels are |
* one byte in size), otherwise it is the size of one image pixel. |
*/ |
#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\ |
(PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256) |
/* The maximum size of the color-map required by the format expressed in a |
* count of components. This can be used to compile-time allocate a |
* color-map: |
* |
* png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)]; |
* |
* png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)]; |
* |
* Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the |
* information from one of the png_image_begin_read_ APIs and dynamically |
* allocate the required memory. |
*/ |
/* Corresponding information about the pixels */ |
#define PNG_IMAGE_PIXEL_(test,fmt)\ |
(((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)) |
#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\ |
PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt) |
/* The number of separate channels (components) in a pixel; 1 for a |
* color-mapped image. |
*/ |
#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\ |
PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt) |
/* The size, in bytes, of each component in a pixel; 1 for a color-mapped |
* image. |
*/ |
#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt) |
/* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */ |
/* Information about the whole row, or whole image */ |
#define PNG_IMAGE_ROW_STRIDE(image)\ |
(PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width) |
/* Return the total number of components in a single row of the image; this |
* is the minimum 'row stride', the minimum count of components between each |
* row. For a color-mapped image this is the minimum number of bytes in a |
* row. |
*/ |
#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\ |
(PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride)) |
/* Return the size, in bytes, of an image buffer given a png_image and a row |
* stride - the number of components to leave space for in each row. |
*/ |
#define PNG_IMAGE_SIZE(image)\ |
PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image)) |
/* Return the size, in bytes, of the image in memory given just a png_image; |
* the row stride is the minimum stride required for the image. |
*/ |
#define PNG_IMAGE_COLORMAP_SIZE(image)\ |
(PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries) |
/* Return the size, in bytes, of the color-map of this image. If the image |
* format is not a color-map format this will return a size sufficient for |
* 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if |
* you don't want to allocate a color-map in this case. |
*/ |
/* PNG_IMAGE_FLAG_* |
* |
* Flags containing additional information about the image are held in the |
* 'flags' field of png_image. |
*/ |
#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01 |
/* This indicates the the RGB values of the in-memory bitmap do not |
* correspond to the red, green and blue end-points defined by sRGB. |
*/ |
#define PNG_IMAGE_FLAG_FAST 0x02 |
/* On write emphasise speed over compression; the resultant PNG file will be |
* larger but will be produced significantly faster, particular for large |
* images. Do not use this option for images which will be distributed, only |
* used it when producing intermediate files that will be read back in |
* repeatedly. For a typical 24-bit image the option will double the read |
* speed at the cost of increasing the image size by 25%, however for many |
* more compressible images the PNG file can be 10 times larger with only a |
* slight speed gain. |
*/ |
#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04 |
/* On read if the image is a 16-bit per component image and there is no gAMA |
* or sRGB chunk assume that the components are sRGB encoded. Notice that |
* images output by the simplified API always have gamma information; setting |
* this flag only affects the interpretation of 16-bit images from an |
* external source. It is recommended that the application expose this flag |
* to the user; the user can normally easily recognize the difference between |
* linear and sRGB encoding. This flag has no effect on write - the data |
* passed to the write APIs must have the correct encoding (as defined |
* above.) |
* |
* If the flag is not set (the default) input 16-bit per component data is |
* assumed to be linear. |
* |
* NOTE: the flag can only be set after the png_image_begin_read_ call, |
* because that call initializes the 'flags' field. |
*/ |
#ifdef PNG_SIMPLIFIED_READ_SUPPORTED |
/* READ APIs |
* --------- |
* |
* The png_image passed to the read APIs must have been initialized by setting |
* the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.) |
*/ |
#ifdef PNG_STDIO_SUPPORTED |
PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image, |
const char *file_name)); |
/* The named file is opened for read and the image header is filled in |
* from the PNG header in the file. |
*/ |
PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image, |
FILE* file)); |
/* The PNG header is read from the stdio FILE object. */ |
#endif /* PNG_STDIO_SUPPORTED */ |
PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image, |
png_const_voidp memory, png_size_t size)); |
/* The PNG header is read from the given memory buffer. */ |
PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image, |
png_const_colorp background, void *buffer, png_int_32 row_stride, |
void *colormap)); |
/* Finish reading the image into the supplied buffer and clean up the |
* png_image structure. |
* |
* row_stride is the step, in byte or 2-byte units as appropriate, |
* between adjacent rows. A positive stride indicates that the top-most row |
* is first in the buffer - the normal top-down arrangement. A negative |
* stride indicates that the bottom-most row is first in the buffer. |
* |
* background need only be supplied if an alpha channel must be removed from |
* a png_byte format and the removal is to be done by compositing on a solid |
* color; otherwise it may be NULL and any composition will be done directly |
* onto the buffer. The value is an sRGB color to use for the background, |
* for grayscale output the green channel is used. |
* |
* background must be supplied when an alpha channel must be removed from a |
* single byte color-mapped output format, in other words if: |
* |
* 1) The original format from png_image_begin_read_from_* had |
* PNG_FORMAT_FLAG_ALPHA set. |
* 2) The format set by the application does not. |
* 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and |
* PNG_FORMAT_FLAG_LINEAR *not* set. |
* |
* For linear output removing the alpha channel is always done by compositing |
* on black and background is ignored. |
* |
* colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must |
* be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE. |
* image->colormap_entries will be updated to the actual number of entries |
* written to the colormap; this may be less than the original value. |
*/ |
PNG_EXPORT(238, void, png_image_free, (png_imagep image)); |
/* Free any data allocated by libpng in image->opaque, setting the pointer to |
* NULL. May be called at any time after the structure is initialized. |
*/ |
#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ |
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED |
#ifdef PNG_STDIO_SUPPORTED |
/* WRITE APIS |
* ---------- |
* For write you must initialize a png_image structure to describe the image to |
* be written. To do this use memset to set the whole structure to 0 then |
* initialize fields describing your image. |
* |
* version: must be set to PNG_IMAGE_VERSION |
* opaque: must be initialized to NULL |
* width: image width in pixels |
* height: image height in rows |
* format: the format of the data (image and color-map) you wish to write |
* flags: set to 0 unless one of the defined flags applies; set |
* PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB |
* values do not correspond to the colors in sRGB. |
* colormap_entries: set to the number of entries in the color-map (0 to 256) |
*/ |
PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image, |
const char *file, int convert_to_8bit, const void *buffer, |
png_int_32 row_stride, const void *colormap)); |
/* Write the image to the named file. */ |
PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file, |
int convert_to_8_bit, const void *buffer, png_int_32 row_stride, |
const void *colormap)); |
/* Write the image to the given (FILE*). */ |
/* With both write APIs if image is in one of the linear formats with 16-bit |
* data then setting convert_to_8_bit will cause the output to be an 8-bit PNG |
* gamma encoded according to the sRGB specification, otherwise a 16-bit linear |
* encoded PNG file is written. |
* |
* With color-mapped data formats the colormap parameter point to a color-map |
* with at least image->colormap_entries encoded in the specified format. If |
* the format is linear the written PNG color-map will be converted to sRGB |
* regardless of the convert_to_8_bit flag. |
* |
* With all APIs row_stride is handled as in the read APIs - it is the spacing |
* from one row to the next in component sized units (1 or 2 bytes) and if |
* negative indicates a bottom-up row layout in the buffer. |
* |
* Note that the write API does not support interlacing or sub-8-bit pixels. |
*/ |
#endif /* PNG_STDIO_SUPPORTED */ |
#endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */ |
/******************************************************************************* |
* END OF SIMPLIFIED API |
******************************************************************************/ |
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
PNG_EXPORT(242, void, png_set_check_for_invalid_index, |
(png_structrp png_ptr, int allowed)); |
# ifdef PNG_GET_PALETTE_MAX_SUPPORTED |
PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
# endif |
#endif /* CHECK_FOR_INVALID_INDEX */ |
/******************************************************************************* |
* IMPLEMENTATION OPTIONS |
******************************************************************************* |
* |
* Support for arbitrary implementation-specific optimizations. The API allows |
* particular options to be turned on or off. 'Option' is the number of the |
* option and 'onoff' is 0 (off) or non-0 (on). The value returned is given |
* by the PNG_OPTION_ defines below. |
* |
* HARDWARE: normally hardware capabilites, such as the Intel SSE instructions, |
* are detected at run time, however sometimes it may be impossible |
* to do this in user mode, in which case it is necessary to discover |
* the capabilities in an OS specific way. Such capabilities are |
* listed here when libpng has support for them and must be turned |
* ON by the application if present. |
* |
* SOFTWARE: sometimes software optimizations actually result in performance |
* decrease on some architectures or systems, or with some sets of |
* PNG images. 'Software' options allow such optimizations to be |
* selected at run time. |
*/ |
#ifdef PNG_SET_OPTION_SUPPORTED |
#ifdef PNG_ARM_NEON_API_SUPPORTED |
# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */ |
#endif |
#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */ |
#define PNG_OPTION_NEXT 4 /* Next option - numbers must be even */ |
/* Return values: NOTE: there are four values and 'off' is *not* zero */ |
#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */ |
#define PNG_OPTION_INVALID 1 /* Option number out of range */ |
#define PNG_OPTION_OFF 2 |
#define PNG_OPTION_ON 3 |
PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, |
int onoff)); |
#endif |
/******************************************************************************* |
* END OF HARDWARE OPTIONS |
******************************************************************************/ |
/* Maintainer: Put new public prototypes here ^, in libpng.3, and project |
* defs |
* defs, scripts/pnglibconf.h, and scripts/pnglibconf.h.prebuilt |
*/ |
/* The last ordinal number (this is the *last* one already used; the next |
2268,7 → 3302,7 |
* scripts/symbols.def as well. |
*/ |
#ifdef PNG_EXPORT_LAST_ORDINAL |
PNG_EXPORT_LAST_ORDINAL(220); |
PNG_EXPORT_LAST_ORDINAL(244); |
#endif |
#ifdef __cplusplus |
/programs/develop/libraries/libpng/pngconf.h |
---|
1,9 → 1,9 |
/* pngconf.h - machine configurable file for libpng |
* |
* libpng version 1.5.1 - February 3, 2011 |
* libpng version 1.6.5 - September 14, 2013 |
* |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
22,35 → 22,73 |
#ifndef PNGCONF_H |
#define PNGCONF_H |
/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C |
* definition file for machine specific limits, this may impact the |
* correctness of the definitons below (see uses of INT_MAX). |
/* To do: Do all of this in scripts/pnglibconf.dfa */ |
#ifdef PNG_SAFE_LIMITS_SUPPORTED |
# ifdef PNG_USER_WIDTH_MAX |
# undef PNG_USER_WIDTH_MAX |
# define PNG_USER_WIDTH_MAX 1000000L |
# endif |
# ifdef PNG_USER_HEIGHT_MAX |
# undef PNG_USER_HEIGHT_MAX |
# define PNG_USER_HEIGHT_MAX 1000000L |
# endif |
# ifdef PNG_USER_CHUNK_MALLOC_MAX |
# undef PNG_USER_CHUNK_MALLOC_MAX |
# define PNG_USER_CHUNK_MALLOC_MAX 4000000L |
# endif |
# ifdef PNG_USER_CHUNK_CACHE_MAX |
# undef PNG_USER_CHUNK_CACHE_MAX |
# define PNG_USER_CHUNK_CACHE_MAX 128 |
# endif |
#endif |
#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */ |
/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C |
* compiler for correct compilation. The following header files are required by |
* the standard. If your compiler doesn't provide these header files, or they |
* do not match the standard, you will need to provide/improve them. |
*/ |
#ifndef PNG_NO_LIMITS_H |
# include <limits.h> |
#endif |
#include <stddef.h> |
/* For the memory copy APIs (i.e. the standard definitions of these), |
* because this file defines png_memcpy and so on the base APIs must |
* be defined here. |
/* Library header files. These header files are all defined by ISOC90; libpng |
* expects conformant implementations, however, an ISOC90 conformant system need |
* not provide these header files if the functionality cannot be implemented. |
* In this case it will be necessary to disable the relevant parts of libpng in |
* the build of pnglibconf.h. |
* |
* Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not |
* include this unnecessary header file. |
*/ |
#ifdef BSD |
# include <strings.h> |
#else |
# include <string.h> |
#endif |
/* For png_FILE_p - this provides the standard definition of a |
* FILE |
*/ |
#ifdef PNG_STDIO_SUPPORTED |
/* Required for the definition of FILE: */ |
# include <stdio.h> |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Required for the definition of jmp_buf and the declaration of longjmp: */ |
# include <setjmp.h> |
#endif |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* Required for struct tm: */ |
# include <time.h> |
#endif |
#endif /* PNG_BUILDING_SYMBOL_TABLE */ |
/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using |
* PNG_NO_CONST; this is no longer supported except for data declarations which |
* apparently still cause problems in 2011 on some compilers. |
*/ |
#define PNG_CONST const /* backward compatibility only */ |
/* This controls optimization of the reading of 16 and 32 bit values |
* from PNG files. It can be set on a per-app-file basis - it |
* just changes whether a macro is used to the function is called. |
* The library builder sets the default, if read functions are not |
* just changes whether a macro is used when the function is called. |
* The library builder sets the default; if read functions are not |
* built into the library the macro implementation is forced on. |
*/ |
#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED |
70,29 → 108,14 |
* may be changed on a per-file basis when compiling against libpng. |
*/ |
/* The PNGARG macro protects us against machines that don't have function |
* prototypes (ie K&R style headers). If your compiler does not handle |
* function prototypes, define this macro and use the included ansi2knr. |
* I've always been able to use _NO_PROTO as the indicator, but you may |
* need to drag the empty declaration out in front of here, or change the |
* ifdef to suit your own needs. |
/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect |
* against legacy (pre ISOC90) compilers that did not understand function |
* prototypes. It is not required for modern C compilers. |
*/ |
#ifndef PNGARG |
# ifdef OF /* zlib prototype munger */ |
# define PNGARG(arglist) OF(arglist) |
# else |
# ifdef _NO_PROTO |
# define PNGARG(arglist) () |
# else |
# define PNGARG(arglist) arglist |
# endif /* _NO_PROTO */ |
#endif |
# endif /* OF */ |
#endif /* PNGARG */ |
/* Function calling conventions. |
* ============================= |
* Normally it is not necessary to specify to the compiler how to call |
162,7 → 185,9 |
* 'type', compiler specific. |
* |
* PNG_DLL_EXPORT Set to the magic to use during a libpng build to |
* make a symbol exported from the DLL. |
* make a symbol exported from the DLL. Not used in the |
* public header files; see pngpriv.h for how it is used |
* in the libpng build. |
* |
* PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come |
* from a DLL - used to define PNG_IMPEXP when |
173,18 → 198,16 |
* ========================== |
* This code is used at build time to find PNG_IMPEXP, the API settings |
* and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL |
* import processing is possible. On Windows/x86 systems it also sets |
* import processing is possible. On Windows systems it also sets |
* compiler-specific macros to the values required to change the calling |
* conventions of the various functions. |
*/ |
#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ |
defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\ |
( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\ |
defined(_M_X64) || defined(_M_IA64) ) |
/* Windows system (DOS doesn't support DLLs) running on x86/x64. Includes |
* builds under Cygwin or MinGW. Also includes Watcom builds but these need |
* special treatment because they are not compatible with GCC or Visual C |
* because of different calling conventions. |
#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ |
defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) |
/* Windows system (DOS doesn't support DLLs). Includes builds under Cygwin or |
* MinGW on any architecture currently supported by Windows. Also includes |
* Watcom builds but these need special treatment because they are not |
* compatible with GCC or Visual C because of different calling conventions. |
*/ |
# if PNG_API_RULE == 2 |
/* If this line results in an error, either because __watcall is not |
198,6 → 221,9 |
# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) |
# define PNGCAPI __cdecl |
# if PNG_API_RULE == 1 |
/* If this line results in an error __stdcall is not understood and |
* PNG_API_RULE should not have been set to '1'. |
*/ |
# define PNGAPI __stdcall |
# endif |
# else |
212,10 → 238,11 |
# define PNGAPI _stdcall |
# endif |
# endif /* compiler/api */ |
/* NOTE: PNGCBAPI always defaults to PNGCAPI. */ |
# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) |
ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed |
# error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed" |
# endif |
# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ |
235,7 → 262,7 |
# endif |
# endif /* compiler */ |
#else /* !Windows/x86 */ |
#else /* !Windows */ |
# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) |
# define PNGAPI _System |
# else /* !Windows/x86 && !OS/2 */ |
256,26 → 283,15 |
# define PNGAPI PNGCAPI |
#endif |
/* The default for PNG_IMPEXP depends on whether the library is |
* being built or used. |
/* PNG_IMPEXP may be set on the compilation system command line or (if not set) |
* then in an internal header file when building the library, otherwise (when |
* using the library) it is set here. |
*/ |
#ifndef PNG_IMPEXP |
# ifdef PNGLIB_BUILD |
/* Building the library */ |
# if (defined(DLL_EXPORT)/*from libtool*/ ||\ |
defined(_WINDLL) || defined(_DLL) || defined(__DLL__) ||\ |
defined(_USRDLL) ||\ |
defined(PNG_BUILD_DLL)) && defined(PNG_DLL_EXPORT) |
/* Building a DLL. */ |
# define PNG_IMPEXP PNG_DLL_EXPORT |
# endif /* DLL */ |
# else |
/* Using the library */ |
# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) |
/* This forces use of a DLL, disallowing static linking */ |
# define PNG_IMPEXP PNG_DLL_IMPORT |
# endif |
# endif |
# ifndef PNG_IMPEXP |
# define PNG_IMPEXP |
282,24 → 298,16 |
# endif |
#endif |
/* THe following complexity is concerned with getting the 'attributes' of the |
* declared function in the correct place. This potentially requires a separate |
* PNG_EXPORT function for every compiler. |
/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat |
* 'attributes' as a storage class - the attributes go at the start of the |
* function definition, and attributes are always appended regardless of the |
* compiler. This considerably simplifies these macros but may cause problems |
* if any compilers both need function attributes and fail to handle them as |
* a storage class (this is unlikely.) |
*/ |
#ifndef PNG_FUNCTION |
# ifdef __GNUC__ |
# define PNG_FUNCTION(type, name, args, attributes)\ |
attributes type name args |
# else /* !GNUC */ |
# ifdef _MSC_VER |
# define PNG_FUNCTION(type, name, args, attributes)\ |
attributes type name args |
# else /* !MSC */ |
# define PNG_FUNCTION(type, name, args, attributes)\ |
type name args |
# define PNG_FUNCTION(type, name, args, attributes) attributes type name args |
# endif |
# endif |
#endif |
#ifndef PNG_EXPORT_TYPE |
# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type |
310,13 → 318,19 |
* scripts directory. |
*/ |
#ifndef PNG_EXPORTA |
# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ |
extern PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args),\ |
attributes) |
PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ |
extern attributes) |
#endif |
/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, |
* so make something non-empty to satisfy the requirement: |
*/ |
#define PNG_EMPTY /*empty list*/ |
#define PNG_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORTA(ordinal, type, name, args, ) |
PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) |
/* Use PNG_REMOVED to comment out a removed interface. */ |
#ifndef PNG_REMOVED |
324,8 → 338,7 |
#endif |
#ifndef PNG_CALLBACK |
# define PNG_CALLBACK(type, name, args, attributes)\ |
type (PNGCBAPI name) PNGARG(args) attributes |
# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) |
#endif |
/* Support for compiler specific function attributes. These are used |
343,11 → 356,12 |
#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED |
/* Support for compiler specific function attributes. These are used |
* so that where compiler support is available incorrect use of API |
* so that where compiler support is available, incorrect use of API |
* functions in png.h will generate compiler warnings. Added at libpng |
* version 1.2.41. |
* version 1.2.41. Disabling these removes the warnings but may also produce |
* less efficient code. |
*/ |
# ifdef __GNUC__ |
# if defined(__GNUC__) |
# ifndef PNG_USE_RESULT |
# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) |
# endif |
354,24 → 368,13 |
# ifndef PNG_NORETURN |
# define PNG_NORETURN __attribute__((__noreturn__)) |
# endif |
# ifndef PNG_PTR_NORETURN |
# define PNG_PTR_NORETURN __attribute__((__noreturn__)) |
# endif |
# if __GNUC__ >= 3 |
# ifndef PNG_ALLOCATED |
# define PNG_ALLOCATED __attribute__((__malloc__)) |
# endif |
/* This specifically protects structure members that should only be |
* accessed from within the library, therefore should be empty during |
* a library build. |
*/ |
# ifndef PNGLIB_BUILD |
# ifndef PNG_DEPRECATED |
# define PNG_DEPRECATED __attribute__((__deprecated__)) |
# endif |
# ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT __attribute__((__deprecated__)) |
# endif |
# ifndef PNG_PRIVATE |
# if 0 /* Doesn't work so we use deprecated instead*/ |
# define PNG_PRIVATE \ |
380,10 → 383,15 |
# define PNG_PRIVATE \ |
__attribute__((__deprecated__)) |
# endif |
# endif /* PNG_PRIVATE */ |
# endif /* PNGLIB_BUILD */ |
# endif /* __GNUC__ */ |
# ifdef _MSC_VER /* may need to check value */ |
# endif |
# if ((__GNUC__ != 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1)) |
# ifndef PNG_RESTRICT |
# define PNG_RESTRICT __restrict |
# endif |
# endif /* __GNUC__ == 3.0 */ |
# endif /* __GNUC__ >= 3 */ |
# elif defined(_MSC_VER) && (_MSC_VER >= 1300) |
# ifndef PNG_USE_RESULT |
# define PNG_USE_RESULT /*not supported*/ |
# endif |
390,29 → 398,28 |
# ifndef PNG_NORETURN |
# define PNG_NORETURN __declspec(noreturn) |
# endif |
# ifndef PNG_PTR_NORETURN |
# define PNG_PTR_NORETURN /*not supported*/ |
# endif |
# ifndef PNG_ALLOCATED |
# if (_MSC_VER >= 1400) |
# define PNG_ALLOCATED __declspec(restrict) |
# endif |
/* This specifically protects structure members that should only be |
* accessed from within the library, therefore should be empty during |
* a library build. |
*/ |
# ifndef PNGLIB_BUILD |
# endif |
# ifndef PNG_DEPRECATED |
# define PNG_DEPRECATED __declspec(deprecated) |
# endif |
# ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT __declspec(deprecated) |
# endif |
# ifndef PNG_PRIVATE |
# define PNG_PRIVATE __declspec(deprecated) |
# endif /* PNG_PRIVATE */ |
# endif /* PNGLIB_BUILD */ |
# endif /* __GNUC__ */ |
# endif |
# ifndef PNG_RESTRICT |
# if (_MSC_VER >= 1400) |
# define PNG_RESTRICT __restrict |
# endif |
# endif |
# elif defined(__WATCOMC__) |
# ifndef PNG_RESTRICT |
# define PNG_RESTRICT __restrict |
# endif |
# endif /* _MSC_VER */ |
#endif /* PNG_PEDANTIC_WARNINGS */ |
#ifndef PNG_DEPRECATED |
427,16 → 434,16 |
#ifndef PNG_ALLOCATED |
# define PNG_ALLOCATED /* The result of the function is new memory */ |
#endif |
#ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT /* Access to this struct member is deprecated */ |
#endif |
#ifndef PNG_PRIVATE |
# define PNG_PRIVATE /* This is a private libpng function */ |
#endif |
#ifndef PNG_RESTRICT |
# define PNG_RESTRICT /* The C99 "restrict" feature */ |
#endif |
#ifndef PNG_FP_EXPORT /* A floating point API. */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
# define PNG_FP_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORT(ordinal, type, name, args) |
PNG_EXPORT(ordinal, type, name, args); |
# else /* No floating point APIs */ |
# define PNG_FP_EXPORT(ordinal, type, name, args) |
# endif |
444,137 → 451,141 |
#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ |
# ifdef PNG_FIXED_POINT_SUPPORTED |
# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORT(ordinal, type, name, args) |
PNG_EXPORT(ordinal, type, name, args); |
# else /* No fixed point APIs */ |
# define PNG_FIXED_EXPORT(ordinal, type, name, args) |
# endif |
#endif |
/* The following uses const char * instead of char * for error |
* and warning message functions, so some compilers won't complain. |
* If you do not want to use const, define PNG_NO_CONST here. |
#ifndef PNG_BUILDING_SYMBOL_TABLE |
/* Some typedefs to get us started. These should be safe on most of the common |
* platforms. |
* |
* This should not change how the APIs are called, so it can be done |
* on a per-file basis in the application. |
* png_uint_32 and png_int_32 may, currently, be larger than required to hold a |
* 32-bit value however this is not normally advisable. |
* |
* png_uint_16 and png_int_16 should always be two bytes in size - this is |
* verified at library build time. |
* |
* png_byte must always be one byte in size. |
* |
* The checks below use constants from limits.h, as defined by the ISOC90 |
* standard. |
*/ |
#ifndef PNG_CONST |
# ifndef PNG_NO_CONST |
# define PNG_CONST const |
#if CHAR_BIT == 8 && UCHAR_MAX == 255 |
typedef unsigned char png_byte; |
# else |
# define PNG_CONST |
# error "libpng requires 8 bit bytes" |
# endif |
#if INT_MIN == -32768 && INT_MAX == 32767 |
typedef int png_int_16; |
#elif SHRT_MIN == -32768 && SHRT_MAX == 32767 |
typedef short png_int_16; |
#else |
# error "libpng requires a signed 16 bit type" |
#endif |
/* Some typedefs to get us started. These should be safe on most of the |
* common platforms. The typedefs should be at least as large as the |
* numbers suggest (a png_uint_32 must be at least 32 bits long), but they |
* don't have to be exactly that size. Some compilers dislike passing |
* unsigned shorts as function parameters, so you may be better off using |
* unsigned int for png_uint_16. |
*/ |
#if UINT_MAX == 65535 |
typedef unsigned int png_uint_16; |
#elif USHRT_MAX == 65535 |
typedef unsigned short png_uint_16; |
#else |
# error "libpng requires an unsigned 16 bit type" |
#endif |
#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL) |
typedef unsigned int png_uint_32; |
#if INT_MIN < -2147483646 && INT_MAX > 2147483646 |
typedef int png_int_32; |
#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646 |
typedef long int png_int_32; |
#else |
typedef unsigned long png_uint_32; |
typedef long png_int_32; |
# error "libpng requires a signed 32 bit (or more) type" |
#endif |
typedef unsigned short png_uint_16; |
typedef short png_int_16; |
typedef unsigned char png_byte; |
#ifdef PNG_NO_SIZE_T |
typedef unsigned int png_size_t; |
#if UINT_MAX > 4294967294 |
typedef unsigned int png_uint_32; |
#elif ULONG_MAX > 4294967294 |
typedef unsigned long int png_uint_32; |
#else |
typedef size_t png_size_t; |
# error "libpng requires an unsigned 32 bit (or more) type" |
#endif |
#define png_sizeof(x) (sizeof (x)) |
/* The following is needed for medium model support. It cannot be in the |
* pngpriv.h header. Needs modification for other compilers besides |
* MSC. Model independent support declares all arrays and pointers to be |
* large using the far keyword. The zlib version used must also support |
* model independent data. As of version zlib 1.0.4, the necessary changes |
* have been made in zlib. The USE_FAR_KEYWORD define triggers other |
* changes that are needed. (Tim Wegner) |
/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however, |
* requires an ISOC90 compiler and relies on consistent behavior of sizeof. |
*/ |
typedef size_t png_size_t; |
typedef ptrdiff_t png_ptrdiff_t; |
/* Separate compiler dependencies (problem here is that zlib.h always |
* defines FAR. (SJT) |
/* libpng needs to know the maximum value of 'size_t' and this controls the |
* definition of png_alloc_size_t, below. This maximum value of size_t limits |
* but does not control the maximum allocations the library makes - there is |
* direct application control of this through png_set_user_limits(). |
*/ |
#ifdef __BORLANDC__ |
# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) |
# define LDATA 1 |
# else |
# define LDATA 0 |
#ifndef PNG_SMALL_SIZE_T |
/* Compiler specific tests for systems where size_t is known to be less than |
* 32 bits (some of these systems may no longer work because of the lack of |
* 'far' support; see above.) |
*/ |
# if (defined(__TURBOC__) && !defined(__FLAT__)) ||\ |
(defined(_MSC_VER) && defined(MAXSEG_64K)) |
# define PNG_SMALL_SIZE_T |
# endif |
/* GRR: why is Cygwin in here? Cygwin is not Borland C... */ |
# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) |
# define PNG_MAX_MALLOC_64K /* only used in build */ |
# if (LDATA != 1) |
# ifndef FAR |
# define FAR __far |
# endif |
# define USE_FAR_KEYWORD |
# endif /* LDATA != 1 */ |
/* Possibly useful for moving data out of default segment. |
* Uncomment it if you want. Could also define FARDATA as |
* const if your compiler supports it. (SJT) |
# define FARDATA FAR |
*/ |
# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ |
#endif /* __BORLANDC__ */ |
/* Suggest testing for specific compiler first before testing for |
* FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, |
* making reliance oncertain keywords suspect. (SJT) |
/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no |
* smaller than png_uint_32. Casts from png_size_t or png_uint_32 to |
* png_alloc_size_t are not necessary; in fact, it is recommended not to use |
* them at all so that the compiler can complain when something turns out to be |
* problematic. |
* |
* Casts in the other direction (from png_alloc_size_t to png_size_t or |
* png_uint_32) should be explicitly applied; however, we do not expect to |
* encounter practical situations that require such conversions. |
* |
* PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than |
* 4294967295 - i.e. less than the maximum value of png_uint_32. |
*/ |
/* MSC Medium model */ |
#ifdef FAR |
# ifdef M_I86MM |
# define USE_FAR_KEYWORD |
# define FARDATA FAR |
# include <dos.h> |
#ifdef PNG_SMALL_SIZE_T |
typedef png_uint_32 png_alloc_size_t; |
#else |
typedef png_size_t png_alloc_size_t; |
# endif |
#endif |
/* SJT: default case */ |
#ifndef FAR |
# define FAR |
#endif |
/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler |
* implementations of Intel CPU specific support of user-mode segmented address |
* spaces, where 16-bit pointers address more than 65536 bytes of memory using |
* separate 'segment' registers. The implementation requires two different |
* types of pointer (only one of which includes the segment value.) |
* |
* If required this support is available in version 1.2 of libpng and may be |
* available in versions through 1.5, although the correctness of the code has |
* not been verified recently. |
*/ |
/* At this point FAR is always defined */ |
#ifndef FARDATA |
# define FARDATA |
#endif |
/* Typedef for floating-point numbers that are converted |
* to fixed-point with a multiple of 100,000, e.g., gamma |
/* Typedef for floating-point numbers that are converted to fixed-point with a |
* multiple of 100,000, e.g., gamma |
*/ |
typedef png_int_32 png_fixed_point; |
/* Add typedefs for pointers */ |
typedef void FAR * png_voidp; |
typedef PNG_CONST void FAR * png_const_voidp; |
typedef png_byte FAR * png_bytep; |
typedef PNG_CONST png_byte FAR * png_const_bytep; |
typedef png_uint_32 FAR * png_uint_32p; |
typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p; |
typedef png_int_32 FAR * png_int_32p; |
typedef PNG_CONST png_int_32 FAR * png_const_int_32p; |
typedef png_uint_16 FAR * png_uint_16p; |
typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p; |
typedef png_int_16 FAR * png_int_16p; |
typedef PNG_CONST png_int_16 FAR * png_const_int_16p; |
typedef char FAR * png_charp; |
typedef PNG_CONST char FAR * png_const_charp; |
typedef png_fixed_point FAR * png_fixed_point_p; |
typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p; |
typedef png_size_t FAR * png_size_tp; |
typedef PNG_CONST png_size_t FAR * png_const_size_tp; |
typedef void * png_voidp; |
typedef const void * png_const_voidp; |
typedef png_byte * png_bytep; |
typedef const png_byte * png_const_bytep; |
typedef png_uint_32 * png_uint_32p; |
typedef const png_uint_32 * png_const_uint_32p; |
typedef png_int_32 * png_int_32p; |
typedef const png_int_32 * png_const_int_32p; |
typedef png_uint_16 * png_uint_16p; |
typedef const png_uint_16 * png_const_uint_16p; |
typedef png_int_16 * png_int_16p; |
typedef const png_int_16 * png_const_int_16p; |
typedef char * png_charp; |
typedef const char * png_const_charp; |
typedef png_fixed_point * png_fixed_point_p; |
typedef const png_fixed_point * png_const_fixed_point_p; |
typedef png_size_t * png_size_tp; |
typedef const png_size_t * png_const_size_tp; |
#ifdef PNG_STDIO_SUPPORTED |
typedef FILE * png_FILE_p; |
581,52 → 592,26 |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * png_doublep; |
typedef PNG_CONST double FAR * png_const_doublep; |
typedef double * png_doublep; |
typedef const double * png_const_doublep; |
#endif |
/* Pointers to pointers; i.e. arrays */ |
typedef png_byte FAR * FAR * png_bytepp; |
typedef png_uint_32 FAR * FAR * png_uint_32pp; |
typedef png_int_32 FAR * FAR * png_int_32pp; |
typedef png_uint_16 FAR * FAR * png_uint_16pp; |
typedef png_int_16 FAR * FAR * png_int_16pp; |
typedef PNG_CONST char FAR * FAR * png_const_charpp; |
typedef char FAR * FAR * png_charpp; |
typedef png_fixed_point FAR * FAR * png_fixed_point_pp; |
typedef png_byte * * png_bytepp; |
typedef png_uint_32 * * png_uint_32pp; |
typedef png_int_32 * * png_int_32pp; |
typedef png_uint_16 * * png_uint_16pp; |
typedef png_int_16 * * png_int_16pp; |
typedef const char * * png_const_charpp; |
typedef char * * png_charpp; |
typedef png_fixed_point * * png_fixed_point_pp; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * FAR * png_doublepp; |
typedef double * * png_doublepp; |
#endif |
/* Pointers to pointers to pointers; i.e., pointer to array */ |
typedef char FAR * FAR * FAR * png_charppp; |
typedef char * * * png_charppp; |
/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, |
* and no smaller than png_uint_32. Casts from png_size_t or png_uint_32 |
* to png_alloc_size_t are not necessary; in fact, it is recommended |
* not to use them at all so that the compiler can complain when something |
* turns out to be problematic. |
* Casts in the other direction (from png_alloc_size_t to png_size_t or |
* png_uint_32) should be explicitly applied; however, we do not expect |
* to encounter practical situations that require such conversions. |
*/ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
typedef unsigned long png_alloc_size_t; |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
typedef unsigned long png_alloc_size_t; |
# else |
/* This is an attempt to detect an old Windows system where (int) is |
* actually 16 bits, in that case png_malloc must have an argument with a |
* bigger size to accomodate the requirements of the library. |
*/ |
# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \ |
(!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL) |
typedef DWORD png_alloc_size_t; |
# else |
typedef png_size_t png_alloc_size_t; |
# endif |
# endif |
#endif |
#endif /* PNG_BUILDING_SYMBOL_TABLE */ |
#endif /* PNGCONF_H */ |
/programs/develop/libraries/libpng/pngerror.c |
---|
1,8 → 1,8 |
/* pngerror.c - stub functions for i/o and memory allocation |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.1 [March 28, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
20,12 → 20,12 |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr, |
static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr, |
png_const_charp error_message)),PNG_NORETURN); |
#ifdef PNG_WARNINGS_SUPPORTED |
static void /* PRIVATE */ |
png_default_warning PNGARG((png_structp png_ptr, |
png_default_warning PNGARG((png_const_structrp png_ptr, |
png_const_charp warning_message)); |
#endif /* PNG_WARNINGS_SUPPORTED */ |
36,7 → 36,8 |
*/ |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
PNG_FUNCTION(void,PNGAPI |
png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN) |
png_error,(png_const_structrp png_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
char msg[16]; |
79,7 → 80,8 |
} |
#endif |
if (png_ptr != NULL && png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, error_message); |
(*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), |
error_message); |
/* If the custom handler doesn't exist, or if it returns, |
use the default handler, which will not return. */ |
87,17 → 89,123 |
} |
#else |
PNG_FUNCTION(void,PNGAPI |
png_err,(png_structp png_ptr),PNG_NORETURN) |
png_err,(png_const_structrp png_ptr),PNG_NORETURN) |
{ |
/* Prior to 1.5.2 the error_fn received a NULL pointer, expressed |
* erroneously as '\0', instead of the empty string "". This was |
* apparently an error, introduced in libpng-1.2.20, and png_default_error |
* will crash in this case. |
*/ |
if (png_ptr != NULL && png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, '\0'); |
(*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), ""); |
/* If the custom handler doesn't exist, or if it returns, |
use the default handler, which will not return. */ |
png_default_error(png_ptr, '\0'); |
png_default_error(png_ptr, ""); |
} |
#endif /* PNG_ERROR_TEXT_SUPPORTED */ |
/* Utility to safely appends strings to a buffer. This never errors out so |
* error checking is not required in the caller. |
*/ |
size_t |
png_safecat(png_charp buffer, size_t bufsize, size_t pos, |
png_const_charp string) |
{ |
if (buffer != NULL && pos < bufsize) |
{ |
if (string != NULL) |
while (*string != '\0' && pos < bufsize-1) |
buffer[pos++] = *string++; |
buffer[pos] = '\0'; |
} |
return pos; |
} |
#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) |
/* Utility to dump an unsigned value into a buffer, given a start pointer and |
* and end pointer (which should point just *beyond* the end of the buffer!) |
* Returns the pointer to the start of the formatted string. |
*/ |
png_charp |
png_format_number(png_const_charp start, png_charp end, int format, |
png_alloc_size_t number) |
{ |
int count = 0; /* number of digits output */ |
int mincount = 1; /* minimum number required */ |
int output = 0; /* digit output (for the fixed point format) */ |
*--end = '\0'; |
/* This is written so that the loop always runs at least once, even with |
* number zero. |
*/ |
while (end > start && (number != 0 || count < mincount)) |
{ |
static const char digits[] = "0123456789ABCDEF"; |
switch (format) |
{ |
case PNG_NUMBER_FORMAT_fixed: |
/* Needs five digits (the fraction) */ |
mincount = 5; |
if (output || number % 10 != 0) |
{ |
*--end = digits[number % 10]; |
output = 1; |
} |
number /= 10; |
break; |
case PNG_NUMBER_FORMAT_02u: |
/* Expects at least 2 digits. */ |
mincount = 2; |
/* FALL THROUGH */ |
case PNG_NUMBER_FORMAT_u: |
*--end = digits[number % 10]; |
number /= 10; |
break; |
case PNG_NUMBER_FORMAT_02x: |
/* This format expects at least two digits */ |
mincount = 2; |
/* FALL THROUGH */ |
case PNG_NUMBER_FORMAT_x: |
*--end = digits[number & 0xf]; |
number >>= 4; |
break; |
default: /* an error */ |
number = 0; |
break; |
} |
/* Keep track of the number of digits added */ |
++count; |
/* Float a fixed number here: */ |
if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start) |
{ |
/* End of the fraction, but maybe nothing was output? In that case |
* drop the decimal point. If the number is a true zero handle that |
* here. |
*/ |
if (output) |
*--end = '.'; |
else if (number == 0) /* and !output */ |
*--end = '0'; |
} |
} |
return end; |
} |
#endif |
#ifdef PNG_WARNINGS_SUPPORTED |
/* This function is called whenever there is a non-fatal error. This function |
* should not be changed. If there is a need to handle warnings differently, |
105,7 → 213,7 |
* png_set_error_fn() to replace the warning function at run-time. |
*/ |
void PNGAPI |
png_warning(png_structp png_ptr, png_const_charp warning_message) |
png_warning(png_const_structrp png_ptr, png_const_charp warning_message) |
{ |
int offset = 0; |
if (png_ptr != NULL) |
124,23 → 232,177 |
} |
} |
if (png_ptr != NULL && png_ptr->warning_fn != NULL) |
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset); |
(*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr), |
warning_message + offset); |
else |
png_default_warning(png_ptr, warning_message + offset); |
} |
/* These functions support 'formatted' warning messages with up to |
* PNG_WARNING_PARAMETER_COUNT parameters. In the format string the parameter |
* is introduced by @<number>, where 'number' starts at 1. This follows the |
* standard established by X/Open for internationalizable error messages. |
*/ |
void |
png_warning_parameter(png_warning_parameters p, int number, |
png_const_charp string) |
{ |
if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT) |
(void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string); |
} |
void |
png_warning_parameter_unsigned(png_warning_parameters p, int number, int format, |
png_alloc_size_t value) |
{ |
char buffer[PNG_NUMBER_BUFFER_SIZE]; |
png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value)); |
} |
void |
png_warning_parameter_signed(png_warning_parameters p, int number, int format, |
png_int_32 value) |
{ |
png_alloc_size_t u; |
png_charp str; |
char buffer[PNG_NUMBER_BUFFER_SIZE]; |
/* Avoid overflow by doing the negate in a png_alloc_size_t: */ |
u = (png_alloc_size_t)value; |
if (value < 0) |
u = ~u + 1; |
str = PNG_FORMAT_NUMBER(buffer, format, u); |
if (value < 0 && str > buffer) |
*--str = '-'; |
png_warning_parameter(p, number, str); |
} |
void |
png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p, |
png_const_charp message) |
{ |
/* The internal buffer is just 192 bytes - enough for all our messages, |
* overflow doesn't happen because this code checks! If someone figures |
* out how to send us a message longer than 192 bytes, all that will |
* happen is that the message will be truncated appropriately. |
*/ |
size_t i = 0; /* Index in the msg[] buffer: */ |
char msg[192]; |
/* Each iteration through the following loop writes at most one character |
* to msg[i++] then returns here to validate that there is still space for |
* the trailing '\0'. It may (in the case of a parameter) read more than |
* one character from message[]; it must check for '\0' and continue to the |
* test if it finds the end of string. |
*/ |
while (i<(sizeof msg)-1 && *message != '\0') |
{ |
/* '@' at end of string is now just printed (previously it was skipped); |
* it is an error in the calling code to terminate the string with @. |
*/ |
if (p != NULL && *message == '@' && message[1] != '\0') |
{ |
int parameter_char = *++message; /* Consume the '@' */ |
static const char valid_parameters[] = "123456789"; |
int parameter = 0; |
/* Search for the parameter digit, the index in the string is the |
* parameter to use. |
*/ |
while (valid_parameters[parameter] != parameter_char && |
valid_parameters[parameter] != '\0') |
++parameter; |
/* If the parameter digit is out of range it will just get printed. */ |
if (parameter < PNG_WARNING_PARAMETER_COUNT) |
{ |
/* Append this parameter */ |
png_const_charp parm = p[parameter]; |
png_const_charp pend = p[parameter] + (sizeof p[parameter]); |
/* No need to copy the trailing '\0' here, but there is no guarantee |
* that parm[] has been initialized, so there is no guarantee of a |
* trailing '\0': |
*/ |
while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend) |
msg[i++] = *parm++; |
/* Consume the parameter digit too: */ |
++message; |
continue; |
} |
/* else not a parameter and there is a character after the @ sign; just |
* copy that. This is known not to be '\0' because of the test above. |
*/ |
} |
/* At this point *message can't be '\0', even in the bad parameter case |
* above where there is a lone '@' at the end of the message string. |
*/ |
msg[i++] = *message++; |
} |
/* i is always less than (sizeof msg), so: */ |
msg[i] = '\0'; |
/* And this is the formatted message. It may be larger than |
* PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these |
* are not (currently) formatted. |
*/ |
png_warning(png_ptr, msg); |
} |
#endif /* PNG_WARNINGS_SUPPORTED */ |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_benign_error(png_structp png_ptr, png_const_charp error_message) |
png_benign_error(png_const_structrp png_ptr, png_const_charp error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) |
{ |
# ifdef PNG_READ_SUPPORTED |
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && |
png_ptr->chunk_name != 0) |
png_chunk_warning(png_ptr, error_message); |
else |
# endif |
png_warning(png_ptr, error_message); |
} |
else |
{ |
# ifdef PNG_READ_SUPPORTED |
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && |
png_ptr->chunk_name != 0) |
png_chunk_error(png_ptr, error_message); |
else |
# endif |
png_error(png_ptr, error_message); |
} |
#endif |
} |
void /* PRIVATE */ |
png_app_warning(png_const_structrp png_ptr, png_const_charp error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) |
png_warning(png_ptr, error_message); |
else |
png_error(png_ptr, error_message); |
} |
void /* PRIVATE */ |
png_app_error(png_const_structrp png_ptr, png_const_charp error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) |
png_warning(png_ptr, error_message); |
else |
png_error(png_ptr, error_message); |
} |
#endif /* BENIGN_ERRORS */ |
/* These utilities are used internally to build an error message that relates |
* to the current chunk. The chunk name comes from png_ptr->chunk_name, |
* this is used to prefix the message. The message is limited in length |
153,17 → 415,20 |
'A', 'B', 'C', 'D', 'E', 'F' |
}; |
#define PNG_MAX_ERROR_TEXT 64 |
#define PNG_MAX_ERROR_TEXT 196 /* Currently limited be profile_error in png.c */ |
#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) |
static void /* PRIVATE */ |
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp |
png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp |
error_message) |
{ |
int iout = 0, iin = 0; |
png_uint_32 chunk_name = png_ptr->chunk_name; |
int iout = 0, ishift = 24; |
while (iin < 4) |
while (ishift >= 0) |
{ |
int c = png_ptr->chunk_name[iin++]; |
int c = (int)(chunk_name >> ishift) & 0xff; |
ishift -= 8; |
if (isnonalpha(c)) |
{ |
buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET; |
174,7 → 439,7 |
else |
{ |
buffer[iout++] = (png_byte)c; |
buffer[iout++] = (char)c; |
} |
} |
183,10 → 448,16 |
else |
{ |
int iin = 0; |
buffer[iout++] = ':'; |
buffer[iout++] = ' '; |
png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT); |
buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0'; |
while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0') |
buffer[iout++] = error_message[iin++]; |
/* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */ |
buffer[iout] = '\0'; |
} |
} |
#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ |
193,7 → 464,7 |
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) |
PNG_FUNCTION(void,PNGAPI |
png_chunk_error,(png_structp png_ptr, png_const_charp error_message), |
png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
char msg[18+PNG_MAX_ERROR_TEXT]; |
210,7 → 481,7 |
#ifdef PNG_WARNINGS_SUPPORTED |
void PNGAPI |
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) |
png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message) |
{ |
char msg[18+PNG_MAX_ERROR_TEXT]; |
if (png_ptr == NULL) |
227,7 → 498,8 |
#ifdef PNG_READ_SUPPORTED |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message) |
png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp |
error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) |
png_chunk_warning(png_ptr, error_message); |
238,16 → 510,51 |
#endif |
#endif /* PNG_READ_SUPPORTED */ |
void /* PRIVATE */ |
png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error) |
{ |
/* This is always supported, but for just read or just write it |
* unconditionally does the right thing. |
*/ |
# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED) |
if (png_ptr->mode & PNG_IS_READ_STRUCT) |
# endif |
# ifdef PNG_READ_SUPPORTED |
{ |
if (error < PNG_CHUNK_ERROR) |
png_chunk_warning(png_ptr, message); |
else |
png_chunk_benign_error(png_ptr, message); |
} |
# endif |
# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED) |
else if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) |
# endif |
# ifdef PNG_WRITE_SUPPORTED |
{ |
if (error < PNG_CHUNK_WRITE_ERROR) |
png_app_warning(png_ptr, message); |
else |
png_app_error(png_ptr, message); |
} |
# endif |
} |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_FUNCTION(void, |
png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN) |
png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN) |
{ |
# define fixed_message "fixed point overflow in " |
# define fixed_message_ln ((sizeof fixed_message)-1) |
int iin; |
char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; |
png_memcpy(msg, fixed_message, fixed_message_ln); |
memcpy(msg, fixed_message, fixed_message_ln); |
iin = 0; |
if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0) |
{ |
265,15 → 572,112 |
* otherwise it is necessary for png_default_error to be overridden. |
*/ |
jmp_buf* PNGAPI |
png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn, |
png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn, |
size_t jmp_buf_size) |
{ |
if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf)) |
/* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value |
* and it must not change after that. Libpng doesn't care how big the |
* buffer is, just that it doesn't change. |
* |
* If the buffer size is no *larger* than the size of jmp_buf when libpng is |
* compiled a built in jmp_buf is returned; this preserves the pre-1.6.0 |
* semantics that this call will not fail. If the size is larger, however, |
* the buffer is allocated and this may fail, causing the function to return |
* NULL. |
*/ |
if (png_ptr == NULL) |
return NULL; |
if (png_ptr->jmp_buf_ptr == NULL) |
{ |
png_ptr->jmp_buf_size = 0; /* not allocated */ |
if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local)) |
png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; |
else |
{ |
png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *, |
png_malloc_warn(png_ptr, jmp_buf_size)); |
if (png_ptr->jmp_buf_ptr == NULL) |
return NULL; /* new NULL return on OOM */ |
png_ptr->jmp_buf_size = jmp_buf_size; |
} |
} |
else /* Already allocated: check the size */ |
{ |
size_t size = png_ptr->jmp_buf_size; |
if (size == 0) |
{ |
size = (sizeof png_ptr->jmp_buf_local); |
if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local) |
{ |
/* This is an internal error in libpng: somehow we have been left |
* with a stack allocated jmp_buf when the application regained |
* control. It's always possible to fix this up, but for the moment |
* this is a png_error because that makes it easy to detect. |
*/ |
png_error(png_ptr, "Libpng jmp_buf still allocated"); |
/* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */ |
} |
} |
if (size != jmp_buf_size) |
{ |
png_warning(png_ptr, "Application jmp_buf size changed"); |
return NULL; /* caller will probably crash: no choice here */ |
} |
} |
/* Finally fill in the function, now we have a satisfactory buffer. It is |
* valid to change the function on every call. |
*/ |
png_ptr->longjmp_fn = longjmp_fn; |
return &png_ptr->png_jmpbuf; |
return png_ptr->jmp_buf_ptr; |
} |
void /* PRIVATE */ |
png_free_jmpbuf(png_structrp png_ptr) |
{ |
if (png_ptr != NULL) |
{ |
jmp_buf *jb = png_ptr->jmp_buf_ptr; |
/* A size of 0 is used to indicate a local, stack, allocation of the |
* pointer; used here and in png.c |
*/ |
if (jb != NULL && png_ptr->jmp_buf_size > 0) |
{ |
/* This stuff is so that a failure to free the error control structure |
* does not leave libpng in a state with no valid error handling: the |
* free always succeeds, if there is an error it gets ignored. |
*/ |
if (jb != &png_ptr->jmp_buf_local) |
{ |
/* Make an internal, libpng, jmp_buf to return here */ |
jmp_buf free_jmp_buf; |
if (!setjmp(free_jmp_buf)) |
{ |
png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */ |
png_ptr->jmp_buf_size = 0; /* stack allocation */ |
png_ptr->longjmp_fn = longjmp; |
png_free(png_ptr, jb); /* Return to setjmp on error */ |
} |
} |
} |
/* *Always* cancel everything out: */ |
png_ptr->jmp_buf_size = 0; |
png_ptr->jmp_buf_ptr = NULL; |
png_ptr->longjmp_fn = 0; |
} |
} |
#endif |
/* This is the default error handling function. Note that replacements for |
282,12 → 686,13 |
* error function pointer in png_set_error_fn(). |
*/ |
static PNG_FUNCTION(void /* PRIVATE */, |
png_default_error,(png_structp png_ptr, png_const_charp error_message), |
png_default_error,(png_const_structrp png_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*error_message == PNG_LITERAL_SHARP) |
/* Check on NULL only added in 1.5.4 */ |
if (error_message != NULL && *error_message == PNG_LITERAL_SHARP) |
{ |
/* Strip "#nnnn " from beginning of error message. */ |
int offset; |
317,11 → 722,11 |
else |
#endif |
{ |
fprintf(stderr, "libpng error: %s", error_message); |
fprintf(stderr, "libpng error: %s", error_message ? error_message : |
"undefined"); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
#endif |
#ifndef PNG_CONSOLE_IO_SUPPORTED |
#else |
PNG_UNUSED(error_message) /* Make compiler happy */ |
#endif |
png_longjmp(png_ptr, 1); |
328,23 → 733,13 |
} |
PNG_FUNCTION(void,PNGAPI |
png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN) |
png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
if (png_ptr && png_ptr->longjmp_fn) |
{ |
# ifdef USE_FAR_KEYWORD |
{ |
jmp_buf png_jmpbuf; |
png_memcpy(png_jmpbuf, png_ptr->png_jmpbuf, png_sizeof(jmp_buf)); |
png_ptr->longjmp_fn(png_jmpbuf, val); |
} |
if (png_ptr && png_ptr->longjmp_fn && png_ptr->jmp_buf_ptr) |
png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val); |
#endif |
# else |
png_ptr->longjmp_fn(png_ptr->png_jmpbuf, val); |
# endif |
} |
#endif |
/* Here if not setjmp support or if png_ptr is null. */ |
PNG_ABORT(); |
} |
356,7 → 751,7 |
* not used, but it is passed in case it may be useful. |
*/ |
static void /* PRIVATE */ |
png_default_warning(png_structp png_ptr, png_const_charp warning_message) |
png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
# ifdef PNG_ERROR_NUMBERS_SUPPORTED |
403,10 → 798,10 |
/* This function is called when the application wants to use another method |
* of handling errors and warnings. Note that the error function MUST NOT |
* return to the calling routine or serious problems will occur. The return |
* method used in the default routine calls longjmp(png_ptr->png_jmpbuf, 1) |
* method used in the default routine calls longjmp(png_ptr->jmp_buf_ptr, 1) |
*/ |
void PNGAPI |
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, |
png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warning_fn) |
{ |
if (png_ptr == NULL) |
414,7 → 809,11 |
png_ptr->error_ptr = error_ptr; |
png_ptr->error_fn = error_fn; |
#ifdef PNG_WARNINGS_SUPPORTED |
png_ptr->warning_fn = warning_fn; |
#else |
PNG_UNUSED(warning_fn) |
#endif |
} |
423,7 → 822,7 |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_error_ptr(png_const_structp png_ptr) |
png_get_error_ptr(png_const_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return NULL; |
434,7 → 833,7 |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
void PNGAPI |
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) |
png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode) |
{ |
if (png_ptr != NULL) |
{ |
444,4 → 843,90 |
} |
} |
#endif |
#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ |
defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) |
/* Currently the above both depend on SETJMP_SUPPORTED, however it would be |
* possible to implement without setjmp support just so long as there is some |
* way to handle the error return here: |
*/ |
PNG_FUNCTION(void /* PRIVATE */, |
png_safe_error,(png_structp png_nonconst_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
const png_const_structrp png_ptr = png_nonconst_ptr; |
png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr); |
/* An error is always logged here, overwriting anything (typically a warning) |
* that is already there: |
*/ |
if (image != NULL) |
{ |
png_safecat(image->message, (sizeof image->message), 0, error_message); |
image->warning_or_error |= PNG_IMAGE_ERROR; |
/* Retrieve the jmp_buf from within the png_control, making this work for |
* C++ compilation too is pretty tricky: C++ wants a pointer to the first |
* element of a jmp_buf, but C doesn't tell us the type of that. |
*/ |
if (image->opaque != NULL && image->opaque->error_buf != NULL) |
longjmp(png_control_jmp_buf(image->opaque), 1); |
/* Missing longjmp buffer, the following is to help debugging: */ |
{ |
size_t pos = png_safecat(image->message, (sizeof image->message), 0, |
"bad longjmp: "); |
png_safecat(image->message, (sizeof image->message), pos, |
error_message); |
} |
} |
/* Here on an internal programming error. */ |
abort(); |
} |
#ifdef PNG_WARNINGS_SUPPORTED |
void /* PRIVATE */ |
png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message) |
{ |
const png_const_structrp png_ptr = png_nonconst_ptr; |
png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr); |
/* A warning is only logged if there is no prior warning or error. */ |
if (image->warning_or_error == 0) |
{ |
png_safecat(image->message, (sizeof image->message), 0, warning_message); |
image->warning_or_error |= PNG_IMAGE_WARNING; |
} |
} |
#endif |
int /* PRIVATE */ |
png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg) |
{ |
volatile png_imagep image = image_in; |
volatile int result; |
volatile png_voidp saved_error_buf; |
jmp_buf safe_jmpbuf; |
/* Safely execute function(arg) with png_error returning to this function. */ |
saved_error_buf = image->opaque->error_buf; |
result = setjmp(safe_jmpbuf) == 0; |
if (result) |
{ |
image->opaque->error_buf = safe_jmpbuf; |
result = function(arg); |
} |
image->opaque->error_buf = saved_error_buf; |
/* And do the cleanup prior to any failure return. */ |
if (!result) |
png_image_free(image); |
return result; |
} |
#endif /* SIMPLIFIED READ/WRITE */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngget.c |
---|
1,8 → 1,8 |
/* pngget.c - retrieval of values from info struct |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.1 [March 28, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
17,7 → 17,7 |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_uint_32 flag) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
27,7 → 27,7 |
} |
png_size_t PNGAPI |
png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->rowbytes); |
37,7 → 37,7 |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
png_bytepp PNGAPI |
png_get_rows(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->row_pointers); |
49,7 → 49,7 |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* Easy access to info, added in libpng-0.99 */ |
png_uint_32 PNGAPI |
png_get_image_width(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->width; |
58,7 → 58,7 |
} |
png_uint_32 PNGAPI |
png_get_image_height(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->height; |
67,7 → 67,7 |
} |
png_byte PNGAPI |
png_get_bit_depth(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->bit_depth; |
76,7 → 76,7 |
} |
png_byte PNGAPI |
png_get_color_type(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->color_type; |
85,7 → 85,7 |
} |
png_byte PNGAPI |
png_get_filter_type(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->filter_type; |
94,7 → 94,7 |
} |
png_byte PNGAPI |
png_get_interlace_type(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->interlace_type; |
103,7 → 103,7 |
} |
png_byte PNGAPI |
png_get_compression_type(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->compression_type; |
112,7 → 112,8 |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp |
info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
129,7 → 130,8 |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp |
info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
146,7 → 148,7 |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
164,7 → 166,8 |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp |
info_ptr) |
{ |
#ifdef PNG_READ_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
175,6 → 178,9 |
return ((float)((float)info_ptr->y_pixels_per_unit |
/(float)info_ptr->x_pixels_per_unit)); |
} |
#else |
PNG_UNUSED(png_ptr) |
PNG_UNUSED(info_ptr) |
#endif |
return ((float)0.0); |
183,8 → 189,8 |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point PNGAPI |
png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr, |
png_const_infop info_ptr) |
png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr, |
png_const_inforp info_ptr) |
{ |
#ifdef PNG_READ_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) |
203,6 → 209,9 |
(png_int_32)info_ptr->x_pixels_per_unit)) |
return res; |
} |
#else |
PNG_UNUSED(png_ptr) |
PNG_UNUSED(info_ptr) |
#endif |
return 0; |
210,7 → 219,7 |
#endif |
png_int_32 PNGAPI |
png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
226,7 → 235,7 |
} |
png_int_32 PNGAPI |
png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
242,7 → 251,7 |
} |
png_int_32 PNGAPI |
png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
258,7 → 267,7 |
} |
png_int_32 PNGAPI |
png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
307,19 → 316,19 |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr)); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr)); |
} |
326,7 → 335,7 |
#ifdef PNG_FIXED_POINT_SUPPORTED |
static png_fixed_point |
png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns) |
png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns) |
{ |
/* Convert from metres * 1,000,000 to inches * 100,000, meters to |
* inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. |
337,8 → 346,8 |
} |
png_fixed_point PNGAPI |
png_get_x_offset_inches_fixed(png_structp png_ptr, |
png_const_infop info_ptr) |
png_get_x_offset_inches_fixed(png_const_structrp png_ptr, |
png_const_inforp info_ptr) |
{ |
return png_fixed_inches_from_microns(png_ptr, |
png_get_x_offset_microns(png_ptr, info_ptr)); |
347,8 → 356,8 |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point PNGAPI |
png_get_y_offset_inches_fixed(png_structp png_ptr, |
png_const_infop info_ptr) |
png_get_y_offset_inches_fixed(png_const_structrp png_ptr, |
png_const_inforp info_ptr) |
{ |
return png_fixed_inches_from_microns(png_ptr, |
png_get_y_offset_microns(png_ptr, info_ptr)); |
357,7 → 366,7 |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
/* To avoid the overflow do the conversion directly in floating |
* point. |
368,7 → 377,7 |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
/* To avoid the overflow do the conversion directly in floating |
* point. |
379,7 → 388,7 |
#ifdef PNG_pHYs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pHYs_dpi(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
422,8 → 431,9 |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
png_byte PNGAPI |
png_get_channels(png_const_structp png_ptr, png_const_infop info_ptr) |
png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->channels); |
431,8 → 441,9 |
return (0); |
} |
#ifdef PNG_READ_SUPPORTED |
png_const_bytep PNGAPI |
png_get_signature(png_const_structp png_ptr, png_infop info_ptr) |
png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->signature); |
439,10 → 450,11 |
return (NULL); |
} |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
png_uint_32 PNGAPI |
png_get_bKGD(png_const_structp png_ptr, png_infop info_ptr, |
png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, |
png_color_16p *background) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) |
459,42 → 471,142 |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the |
* same time to correct the rgb grayscale coefficient defaults obtained from the |
* cHRM chunk in 1.5.4 |
*/ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr, |
double *white_x, double *white_y, double *red_x, double *red_y, |
double *green_x, double *green_y, double *blue_x, double *blue_y) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
/* Quiet API change: this code used to only return the end points if a cHRM |
* chunk was present, but the end points can also come from iCCP or sRGB |
* chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and |
* the png_set_ APIs merely check that set end points are mutually |
* consistent. |
*/ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) |
{ |
png_debug1(1, "in %s retrieval function", "cHRM"); |
if (white_x != NULL) |
*white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X"); |
*white_x = png_float(png_ptr, |
info_ptr->colorspace.end_points_xy.whitex, "cHRM white X"); |
if (white_y != NULL) |
*white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y"); |
*white_y = png_float(png_ptr, |
info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y"); |
if (red_x != NULL) |
*red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X"); |
*red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx, |
"cHRM red X"); |
if (red_y != NULL) |
*red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y"); |
*red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy, |
"cHRM red Y"); |
if (green_x != NULL) |
*green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X"); |
*green_x = png_float(png_ptr, |
info_ptr->colorspace.end_points_xy.greenx, "cHRM green X"); |
if (green_y != NULL) |
*green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y"); |
*green_y = png_float(png_ptr, |
info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y"); |
if (blue_x != NULL) |
*blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X"); |
*blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex, |
"cHRM blue X"); |
if (blue_y != NULL) |
*blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y"); |
*blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey, |
"cHRM blue Y"); |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr, |
double *red_X, double *red_Y, double *red_Z, double *green_X, |
double *green_Y, double *green_Z, double *blue_X, double *blue_Y, |
double *blue_Z) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) |
{ |
png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)"); |
if (red_X != NULL) |
*red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X, |
"cHRM red X"); |
if (red_Y != NULL) |
*red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y, |
"cHRM red Y"); |
if (red_Z != NULL) |
*red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z, |
"cHRM red Z"); |
if (green_X != NULL) |
*green_X = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X"); |
if (green_Y != NULL) |
*green_Y = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y"); |
if (green_Z != NULL) |
*green_Z = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z"); |
if (blue_X != NULL) |
*blue_X = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X"); |
if (blue_Y != NULL) |
*blue_Y = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y"); |
if (blue_Z != NULL) |
*blue_Z = png_float(png_ptr, |
info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z"); |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
# endif |
# ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM_fixed(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *int_red_X, png_fixed_point *int_red_Y, |
png_fixed_point *int_red_Z, png_fixed_point *int_green_X, |
png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, |
png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, |
png_fixed_point *int_blue_Z) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) |
{ |
png_debug1(1, "in %s retrieval function", "cHRM_XYZ"); |
if (int_red_X != NULL) |
*int_red_X = info_ptr->colorspace.end_points_XYZ.red_X; |
if (int_red_Y != NULL) |
*int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y; |
if (int_red_Z != NULL) |
*int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z; |
if (int_green_X != NULL) |
*int_green_X = info_ptr->colorspace.end_points_XYZ.green_X; |
if (int_green_Y != NULL) |
*int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y; |
if (int_green_Z != NULL) |
*int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z; |
if (int_blue_X != NULL) |
*int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X; |
if (int_blue_Y != NULL) |
*int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y; |
if (int_blue_Z != NULL) |
*int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, |
png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, |
png_fixed_point *blue_x, png_fixed_point *blue_y) |
501,24 → 613,25 |
{ |
png_debug1(1, "in %s retrieval function", "cHRM"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) |
{ |
if (white_x != NULL) |
*white_x = info_ptr->x_white; |
*white_x = info_ptr->colorspace.end_points_xy.whitex; |
if (white_y != NULL) |
*white_y = info_ptr->y_white; |
*white_y = info_ptr->colorspace.end_points_xy.whitey; |
if (red_x != NULL) |
*red_x = info_ptr->x_red; |
*red_x = info_ptr->colorspace.end_points_xy.redx; |
if (red_y != NULL) |
*red_y = info_ptr->y_red; |
*red_y = info_ptr->colorspace.end_points_xy.redy; |
if (green_x != NULL) |
*green_x = info_ptr->x_green; |
*green_x = info_ptr->colorspace.end_points_xy.greenx; |
if (green_y != NULL) |
*green_y = info_ptr->y_green; |
*green_y = info_ptr->colorspace.end_points_xy.greeny; |
if (blue_x != NULL) |
*blue_x = info_ptr->x_blue; |
*blue_x = info_ptr->colorspace.end_points_xy.bluex; |
if (blue_y != NULL) |
*blue_y = info_ptr->y_blue; |
*blue_y = info_ptr->colorspace.end_points_xy.bluey; |
return (PNG_INFO_cHRM); |
} |
528,41 → 641,49 |
#endif |
#ifdef PNG_gAMA_SUPPORTED |
png_uint_32 PNGFAPI |
png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr, |
# ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_fixed_point *file_gamma) |
{ |
png_debug1(1, "in %s retrieval function", "gAMA"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& file_gamma != NULL) |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) && |
file_gamma != NULL) |
{ |
*file_gamma = info_ptr->gamma; |
*file_gamma = info_ptr->colorspace.gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
# endif |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, |
double *file_gamma) |
{ |
png_fixed_point igamma; |
png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma); |
png_debug1(1, "in %s retrieval function", "gAMA(float)"); |
if (ok) |
*file_gamma = png_float(png_ptr, igamma, "png_get_gAMA"); |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) && |
file_gamma != NULL) |
{ |
*file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma, |
"png_get_gAMA"); |
return (PNG_INFO_gAMA); |
} |
return ok; |
return (0); |
} |
# endif |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr, |
int *file_srgb_intent) |
{ |
png_debug1(1, "in %s retrieval function", "sRGB"); |
570,7 → 691,7 |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) |
&& file_srgb_intent != NULL) |
{ |
*file_srgb_intent = (int)info_ptr->srgb_intent; |
*file_srgb_intent = info_ptr->colorspace.rendering_intent; |
return (PNG_INFO_sRGB); |
} |
580,7 → 701,7 |
#ifdef PNG_iCCP_SUPPORTED |
png_uint_32 PNGAPI |
png_get_iCCP(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, |
png_charpp name, int *compression_type, |
png_bytepp profile, png_uint_32 *proflen) |
{ |
587,15 → 708,16 |
png_debug1(1, "in %s retrieval function", "iCCP"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) |
&& name != NULL && profile != NULL && proflen != NULL) |
&& name != NULL && compression_type != NULL && profile != NULL && |
proflen != NULL) |
{ |
*name = info_ptr->iccp_name; |
*profile = info_ptr->iccp_profile; |
/* Compression_type is a dummy so the API won't have to change |
* if we introduce multiple compression types later. |
*proflen = png_get_uint_32(info_ptr->iccp_profile); |
/* This is somewhat irrelevant since the profile data returned has |
* actually been uncompressed. |
*/ |
*proflen = (int)info_ptr->iccp_proflen; |
*compression_type = (int)info_ptr->iccp_compression; |
*compression_type = PNG_COMPRESSION_TYPE_BASE; |
return (PNG_INFO_iCCP); |
} |
604,14 → 726,14 |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sPLT(png_const_structp png_ptr, png_const_infop info_ptr, |
int PNGAPI |
png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr, |
png_sPLT_tpp spalettes) |
{ |
if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) |
{ |
*spalettes = info_ptr->splt_palettes; |
return ((png_uint_32)info_ptr->splt_palettes_num); |
return info_ptr->splt_palettes_num; |
} |
return (0); |
620,7 → 742,7 |
#ifdef PNG_hIST_SUPPORTED |
png_uint_32 PNGAPI |
png_get_hIST(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr, |
png_uint_16p *hist) |
{ |
png_debug1(1, "in %s retrieval function", "hIST"); |
637,11 → 759,10 |
#endif |
png_uint_32 PNGAPI |
png_get_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_uint_32 *width, png_uint_32 *height, int *bit_depth, |
int *color_type, int *interlace_type, int *compression_type, |
int *filter_type) |
{ |
png_debug1(1, "in %s retrieval function", "IHDR"); |
677,7 → 798,7 |
#ifdef PNG_oFFs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) |
{ |
png_debug1(1, "in %s retrieval function", "oFFs"); |
697,7 → 818,7 |
#ifdef PNG_pCAL_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pCAL(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, |
png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, |
png_charp *units, png_charpp *params) |
{ |
723,9 → 844,10 |
#ifdef PNG_sCAL_SUPPORTED |
# ifdef PNG_FIXED_POINT_SUPPORTED |
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr, |
png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, |
int *unit, png_fixed_point *width, png_fixed_point *height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
732,7 → 854,10 |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
/*TODO: make this work without FP support */ |
/*TODO: make this work without FP support; the API is currently eliminated |
* if neither floating point APIs nor internal floating point arithmetic |
* are enabled. |
*/ |
*width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); |
*height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), |
"sCAL height"); |
745,7 → 870,7 |
# endif /* FIXED_POINT */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr, |
int *unit, double *width, double *height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
761,7 → 886,7 |
} |
# endif /* FLOATING POINT */ |
png_uint_32 PNGAPI |
png_get_sCAL_s(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr, |
int *unit, png_charpp width, png_charpp height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
779,7 → 904,7 |
#ifdef PNG_pHYs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
813,7 → 938,7 |
#endif /* pHYs */ |
png_uint_32 PNGAPI |
png_get_PLTE(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr, |
png_colorp *palette, int *num_palette) |
{ |
png_debug1(1, "in %s retrieval function", "PLTE"); |
832,7 → 957,7 |
#ifdef PNG_sBIT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr, |
png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, |
png_color_8p *sig_bit) |
{ |
png_debug1(1, "in %s retrieval function", "sBIT"); |
849,15 → 974,14 |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_text(png_const_structp png_ptr, png_const_infop info_ptr, |
int PNGAPI |
png_get_text(png_const_structrp png_ptr, png_inforp info_ptr, |
png_textp *text_ptr, int *num_text) |
{ |
if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) |
{ |
png_debug1(1, "in %s retrieval function", |
(png_ptr->chunk_name[0] == '\0' ? "text" : |
(png_const_charp)png_ptr->chunk_name)); |
png_debug1(1, "in 0x%lx retrieval function", |
(unsigned long)png_ptr->chunk_name); |
if (text_ptr != NULL) |
*text_ptr = info_ptr->text; |
865,7 → 989,7 |
if (num_text != NULL) |
*num_text = info_ptr->num_text; |
return ((png_uint_32)info_ptr->num_text); |
return info_ptr->num_text; |
} |
if (num_text != NULL) |
877,7 → 1001,8 |
#ifdef PNG_tIME_SUPPORTED |
png_uint_32 PNGAPI |
png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time) |
png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr, |
png_timep *mod_time) |
{ |
png_debug1(1, "in %s retrieval function", "tIME"); |
894,7 → 1019,7 |
#ifdef PNG_tRNS_SUPPORTED |
png_uint_32 PNGAPI |
png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr, |
png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr, |
png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) |
{ |
png_uint_32 retval = 0; |
937,9 → 1062,9 |
} |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
int PNGAPI |
png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop info_ptr, |
png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, |
png_unknown_chunkpp unknowns) |
{ |
if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) |
954,7 → 1079,7 |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
png_byte PNGAPI |
png_get_rgb_to_gray_status (png_const_structp png_ptr) |
png_get_rgb_to_gray_status (png_const_structrp png_ptr) |
{ |
return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); |
} |
962,7 → 1087,7 |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
png_voidp PNGAPI |
png_get_user_chunk_ptr(png_const_structp png_ptr) |
png_get_user_chunk_ptr(png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_ptr : NULL); |
} |
969,23 → 1094,39 |
#endif |
png_size_t PNGAPI |
png_get_compression_buffer_size(png_const_structp png_ptr) |
png_get_compression_buffer_size(png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->zbuf_size : 0L); |
if (png_ptr == NULL) |
return 0; |
# ifdef PNG_WRITE_SUPPORTED |
if (png_ptr->mode & PNG_IS_READ_STRUCT) |
# endif |
{ |
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
return png_ptr->IDAT_read_size; |
# else |
return PNG_IDAT_READ_SIZE; |
# endif |
} |
# ifdef PNG_WRITE_SUPPORTED |
else |
return png_ptr->zbuffer_size; |
# endif |
} |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
/* These functions were added to libpng 1.2.6 and were enabled |
* by default in libpng-1.4.0 */ |
png_uint_32 PNGAPI |
png_get_user_width_max (png_const_structp png_ptr) |
png_get_user_width_max (png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_width_max : 0); |
} |
png_uint_32 PNGAPI |
png_get_user_height_max (png_const_structp png_ptr) |
png_get_user_height_max (png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_height_max : 0); |
} |
992,7 → 1133,7 |
/* This function was added to libpng 1.4.0 */ |
png_uint_32 PNGAPI |
png_get_chunk_cache_max (png_const_structp png_ptr) |
png_get_chunk_cache_max (png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_cache_max : 0); |
} |
999,7 → 1140,7 |
/* This function was added to libpng 1.4.1 */ |
png_alloc_size_t PNGAPI |
png_get_chunk_malloc_max (png_const_structp png_ptr) |
png_get_chunk_malloc_max (png_const_structrp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); |
} |
1008,25 → 1149,29 |
/* These functions were added to libpng 1.4.0 */ |
#ifdef PNG_IO_STATE_SUPPORTED |
png_uint_32 PNGAPI |
png_get_io_state (png_structp png_ptr) |
png_get_io_state (png_const_structrp png_ptr) |
{ |
return png_ptr->io_state; |
} |
png_uint_32 PNGAPI |
png_get_io_chunk_type (png_const_structp png_ptr) |
png_get_io_chunk_type (png_const_structrp png_ptr) |
{ |
return ((png_ptr->chunk_name[0] << 24) + |
(png_ptr->chunk_name[1] << 16) + |
(png_ptr->chunk_name[2] << 8) + |
(png_ptr->chunk_name[3])); |
return png_ptr->chunk_name; |
} |
#endif /* ?PNG_IO_STATE_SUPPORTED */ |
png_const_bytep PNGAPI |
png_get_io_chunk_name (png_structp png_ptr) |
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
# ifdef PNG_GET_PALETTE_MAX_SUPPORTED |
int PNGAPI |
png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
return png_ptr->chunk_name; |
if (png_ptr != NULL && info_ptr != NULL) |
return png_ptr->num_palette_max; |
return (-1); |
} |
#endif /* ?PNG_IO_STATE_SUPPORTED */ |
# endif |
#endif |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pnginfo.h |
---|
1,11 → 1,11 |
/* pnginfo.h - header file for PNG reference library |
* |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Last changed in libpng 1.6.1 [March 28, 2013] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
55,7 → 55,7 |
struct png_info_def |
{ |
/* the following are necessary for every PNG file */ |
/* The following are necessary for every PNG file */ |
png_uint_32 width; /* width of image in pixels (from IHDR) */ |
png_uint_32 height; /* height of image in pixels (from IHDR) */ |
png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ |
70,11 → 70,17 |
png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ |
png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
/* The following is informational only on read, and not used on writes. */ |
/* The following are set by png_set_IHDR, called from the application on |
* write, but the are never actually used by the write code. |
*/ |
png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte spare_byte; /* to align the data, and for future use */ |
#ifdef PNG_READ_SUPPORTED |
/* This is never set during write */ |
png_byte signature[8]; /* magic bytes read by libpng from start of file */ |
#endif |
/* The rest of the data is optional. If you are reading, check the |
* valid field to see if the information in these are valid. If you |
82,18 → 88,25 |
* and initialize the appropriate fields below. |
*/ |
#if defined(PNG_gAMA_SUPPORTED) |
/* The gAMA chunk describes the gamma characteristics of the system |
* on which the image was created, normally in the range [1.0, 2.5]. |
* Data is valid if (valid & PNG_INFO_gAMA) is non-zero. |
#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED) |
/* png_colorspace only contains 'flags' if neither GAMMA or COLORSPACE are |
* defined. When COLORSPACE is switched on all the colorspace-defining |
* chunks should be enabled, when GAMMA is switched on all the gamma-defining |
* chunks should be enabled. If this is not done it becomes possible to read |
* inconsistent PNG files and assign a probably incorrect interpretation to |
* the information. (In other words, by carefully choosing which chunks to |
* recognize the system configuration can select an interpretation for PNG |
* files containing ambiguous data and this will result in inconsistent |
* behavior between different libpng builds!) |
*/ |
png_fixed_point gamma; |
png_colorspace colorspace; |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
/* GR-P, 0.96a */ |
/* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ |
png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ |
#ifdef PNG_iCCP_SUPPORTED |
/* iCCP chunk data. */ |
png_charp iccp_name; /* profile name */ |
png_bytep iccp_profile; /* International Color Consortium profile data */ |
png_uint_32 iccp_proflen; /* ICC profile data length */ |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
138,7 → 151,6 |
* single color specified that should be treated as fully transparent. |
* Data is valid if (valid & PNG_INFO_tRNS) is non-zero. |
*/ |
png_bytep trans; /* alpha values for paletted image */ |
png_bytep trans_alpha; /* alpha values for paletted image */ |
png_color_16 trans_color; /* transparent color for non-palette image */ |
#endif |
184,23 → 196,6 |
png_uint_16p hist; |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
/* The cHRM chunk describes the CIE color characteristics of the monitor |
* on which the PNG was created. This data allows the viewer to do gamut |
* mapping of the input image to ensure that the viewer sees the same |
* colors in the image as the creator. Values are in the range |
* [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. |
*/ |
png_fixed_point x_white; |
png_fixed_point y_white; |
png_fixed_point x_red; |
png_fixed_point y_red; |
png_fixed_point x_green; |
png_fixed_point y_green; |
png_fixed_point x_blue; |
png_fixed_point y_blue; |
#endif |
#ifdef PNG_pCAL_SUPPORTED |
/* The pCAL chunk describes a transformation between the stored pixel |
* values and original physical data values used to create the image. |
225,25 → 220,20 |
/* New members added in libpng-1.0.6 */ |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
/* Storage for unknown chunks that the library doesn't recognize. */ |
png_unknown_chunkp unknown_chunks; |
/* The type of this field is limited by the type of |
* png_struct::user_chunk_cache_max, else overflow can occur. |
*/ |
int unknown_chunks_num; |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
/* iCCP chunk data. */ |
png_charp iccp_name; /* profile name */ |
png_bytep iccp_profile; /* International Color Consortium profile data */ |
png_uint_32 iccp_proflen; /* ICC profile data length */ |
png_byte iccp_compression; /* Always zero */ |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
/* Data on sPLT chunks (there may be more than one). */ |
png_sPLT_tp splt_palettes; |
png_uint_32 splt_palettes_num; |
int splt_palettes_num; /* Match type returned by png_get API */ |
#endif |
#ifdef PNG_sCAL_SUPPORTED |
/programs/develop/libraries/libpng/pnglibconf.h |
---|
1,8 → 1,8 |
/* pnglibconf.h - library build configuration */ |
/* libpng version 1.5.0 - January 6, 2011 */ |
/* libpng version 1.6.5 - September 14, 2013 */ |
/* Copyright (c) 1998-2011 Glenn Randers-Pehrson */ |
/* Copyright (c) 1998-2012 Glenn Randers-Pehrson */ |
/* This code is released under the libpng license. */ |
/* For conditions of distribution and use, see the disclaimer */ |
13,161 → 13,197 |
/* Derived from: scripts/pnglibconf.dfa */ |
#ifndef PNGLCONF_H |
#define PNGLCONF_H |
/* settings */ |
#define PNG_MAX_GAMMA_8 11 |
#define PNG_CALLOC_SUPPORTED |
#define PNG_QUANTIZE_RED_BITS 5 |
#define PNG_USER_WIDTH_MAX 1000000L |
#define PNG_QUANTIZE_GREEN_BITS 5 |
#define PNG_API_RULE 0 |
#define PNG_QUANTIZE_BLUE_BITS 5 |
#define PNG_USER_CHUNK_CACHE_MAX 0 |
#define PNG_USER_HEIGHT_MAX 1000000L |
#define PNG_sCAL_PRECISION 5 |
#define PNG_COST_SHIFT 3 |
#define PNG_WEIGHT_SHIFT 8 |
#define PNG_USER_CHUNK_MALLOC_MAX 0 |
#define PNG_DEFAULT_READ_MACROS 1 |
#define PNG_ZBUF_SIZE 8192 |
#define PNG_GAMMA_THRESHOLD_FIXED 5000 |
/* end of settings */ |
/* options */ |
#define PNG_INFO_IMAGE_SUPPORTED |
#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
#define PNG_POINTER_INDEXING_SUPPORTED |
#define PNG_WARNINGS_SUPPORTED |
#define PNG_FLOATING_ARITHMETIC_SUPPORTED |
#define PNG_WRITE_SUPPORTED |
#define PNG_WRITE_INTERLACING_SUPPORTED |
#define PNG_WRITE_16BIT_SUPPORTED |
#define PNG_16BIT_SUPPORTED |
#define PNG_ALIGNED_MEMORY_SUPPORTED |
/*#undef PNG_ARM_NEON_API_SUPPORTED*/ |
/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/ |
#define PNG_BENIGN_ERRORS_SUPPORTED |
#define PNG_BENIGN_READ_ERRORS_SUPPORTED |
/*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/ |
#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED |
#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
#define PNG_COLORSPACE_SUPPORTED |
#define PNG_CONSOLE_IO_SUPPORTED |
#define PNG_CONVERT_tIME_SUPPORTED |
#define PNG_EASY_ACCESS_SUPPORTED |
#define PNG_ALIGN_MEMORY_SUPPORTED |
#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_USER_LIMITS_SUPPORTED |
/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ |
#define PNG_ERROR_TEXT_SUPPORTED |
#define PNG_FIXED_POINT_SUPPORTED |
#define PNG_ERROR_NUMBERS_SUPPORTED |
#define PNG_ERROR_TEXT_SUPPORTED |
#define PNG_READ_SUPPORTED |
/*#undef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED*/ |
#define PNG_BENIGN_ERRORS_SUPPORTED |
#define PNG_SETJMP_SUPPORTED |
#define PNG_WRITE_FLUSH_SUPPORTED |
#define PNG_MNG_FEATURES_SUPPORTED |
#define PNG_FLOATING_ARITHMETIC_SUPPORTED |
#define PNG_FLOATING_POINT_SUPPORTED |
#define PNG_FORMAT_AFIRST_SUPPORTED |
#define PNG_FORMAT_BGR_SUPPORTED |
#define PNG_GAMMA_SUPPORTED |
#define PNG_GET_PALETTE_MAX_SUPPORTED |
#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
#define PNG_INCH_CONVERSIONS_SUPPORTED |
#define PNG_STDIO_SUPPORTED |
#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_USER_MEM_SUPPORTED |
#define PNG_INFO_IMAGE_SUPPORTED |
#define PNG_IO_STATE_SUPPORTED |
#define PNG_SET_USER_LIMITS_SUPPORTED |
#define PNG_MNG_FEATURES_SUPPORTED |
#define PNG_POINTER_INDEXING_SUPPORTED |
#define PNG_PROGRESSIVE_READ_SUPPORTED |
#define PNG_READ_16BIT_SUPPORTED |
#define PNG_READ_ALPHA_MODE_SUPPORTED |
#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED |
#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#define PNG_WRITE_FILTER_SUPPORTED |
#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED |
#define PNG_WRITE_iCCP_SUPPORTED |
#define PNG_READ_TRANSFORMS_SUPPORTED |
#define PNG_READ_BACKGROUND_SUPPORTED |
#define PNG_READ_BGR_SUPPORTED |
#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED |
#define PNG_READ_COMPOSITE_NODIV_SUPPORTED |
#define PNG_READ_COMPRESSED_TEXT_SUPPORTED |
#define PNG_READ_EXPAND_16_SUPPORTED |
#define PNG_READ_EXPAND_SUPPORTED |
#define PNG_READ_FILLER_SUPPORTED |
#define PNG_READ_GAMMA_SUPPORTED |
#define PNG_READ_bKGD_SUPPORTED |
#define PNG_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_READ_sCAL_SUPPORTED |
#define PNG_WRITE_hIST_SUPPORTED |
#define PNG_READ_OPT_PLTE_SUPPORTED |
#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
#define PNG_WRITE_gAMA_SUPPORTED |
#define PNG_READ_GET_PALETTE_MAX_SUPPORTED |
#define PNG_READ_GRAY_TO_RGB_SUPPORTED |
#define PNG_WRITE_pCAL_SUPPORTED |
#define PNG_READ_INTERLACING_SUPPORTED |
#define PNG_READ_INT_FUNCTIONS_SUPPORTED |
#define PNG_READ_INVERT_ALPHA_SUPPORTED |
#define PNG_WRITE_TRANSFORMS_SUPPORTED |
#define PNG_READ_sBIT_SUPPORTED |
#define PNG_READ_INVERT_SUPPORTED |
#define PNG_READ_OPT_PLTE_SUPPORTED |
#define PNG_READ_PACKSWAP_SUPPORTED |
#define PNG_READ_PACK_SUPPORTED |
#define PNG_WRITE_SWAP_SUPPORTED |
#define PNG_READ_cHRM_SUPPORTED |
#define PNG_WRITE_tIME_SUPPORTED |
#define PNG_READ_INTERLACING_SUPPORTED |
#define PNG_READ_tRNS_SUPPORTED |
#define PNG_WRITE_pHYs_SUPPORTED |
#define PNG_WRITE_INVERT_SUPPORTED |
#define PNG_READ_QUANTIZE_SUPPORTED |
#define PNG_READ_RGB_TO_GRAY_SUPPORTED |
#define PNG_WRITE_sRGB_SUPPORTED |
#define PNG_READ_oFFs_SUPPORTED |
#define PNG_WRITE_FILLER_SUPPORTED |
#define PNG_WRITE_TEXT_SUPPORTED |
#define PNG_WRITE_SHIFT_SUPPORTED |
#define PNG_PROGRESSIVE_READ_SUPPORTED |
#define PNG_READ_SCALE_16_TO_8_SUPPORTED |
#define PNG_READ_SHIFT_SUPPORTED |
#define PNG_CONVERT_tIME_SUPPORTED |
#define PNG_READ_STRIP_16_TO_8_SUPPORTED |
#define PNG_READ_STRIP_ALPHA_SUPPORTED |
#define PNG_READ_SUPPORTED |
#define PNG_READ_SWAP_ALPHA_SUPPORTED |
#define PNG_READ_SWAP_SUPPORTED |
#define PNG_READ_TEXT_SUPPORTED |
#define PNG_READ_TRANSFORMS_SUPPORTED |
#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_READ_USER_CHUNKS_SUPPORTED |
#define PNG_READ_USER_TRANSFORM_SUPPORTED |
#define PNG_READ_INT_FUNCTIONS_SUPPORTED |
#define PNG_READ_USER_CHUNKS_SUPPORTED |
#define PNG_READ_bKGD_SUPPORTED |
#define PNG_READ_cHRM_SUPPORTED |
#define PNG_READ_gAMA_SUPPORTED |
#define PNG_READ_hIST_SUPPORTED |
#define PNG_READ_16BIT_SUPPORTED |
#define PNG_READ_SWAP_ALPHA_SUPPORTED |
#define PNG_READ_COMPOSITE_NODIV_SUPPORTED |
#define PNG_SEQUENTIAL_READ_SUPPORTED |
#define PNG_READ_BACKGROUND_SUPPORTED |
#define PNG_READ_QUANTIZE_SUPPORTED |
#define PNG_READ_iCCP_SUPPORTED |
#define PNG_READ_STRIP_ALPHA_SUPPORTED |
#define PNG_READ_PACKSWAP_SUPPORTED |
#define PNG_READ_iTXt_SUPPORTED |
#define PNG_READ_oFFs_SUPPORTED |
#define PNG_READ_pCAL_SUPPORTED |
#define PNG_READ_pHYs_SUPPORTED |
#define PNG_READ_sBIT_SUPPORTED |
#define PNG_READ_sCAL_SUPPORTED |
#define PNG_READ_sPLT_SUPPORTED |
#define PNG_READ_sRGB_SUPPORTED |
#define PNG_WRITE_tEXt_SUPPORTED |
#define PNG_READ_gAMA_SUPPORTED |
#define PNG_READ_pCAL_SUPPORTED |
#define PNG_READ_EXPAND_SUPPORTED |
#define PNG_WRITE_sPLT_SUPPORTED |
#define PNG_READ_SWAP_SUPPORTED |
#define PNG_READ_tEXt_SUPPORTED |
#define PNG_READ_tIME_SUPPORTED |
#define PNG_READ_pHYs_SUPPORTED |
#define PNG_WRITE_SWAP_ALPHA_SUPPORTED |
#define PNG_READ_tRNS_SUPPORTED |
#define PNG_READ_zTXt_SUPPORTED |
/*#undef PNG_SAFE_LIMITS_SUPPORTED*/ |
#define PNG_SAVE_INT_32_SUPPORTED |
#define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_SEQUENTIAL_READ_SUPPORTED |
#define PNG_SETJMP_SUPPORTED |
#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED |
#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
#define PNG_SET_OPTION_SUPPORTED |
#define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_SET_USER_LIMITS_SUPPORTED |
#define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED |
#define PNG_SIMPLIFIED_READ_BGR_SUPPORTED |
#define PNG_SIMPLIFIED_READ_SUPPORTED |
#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED |
#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED |
#define PNG_SIMPLIFIED_WRITE_SUPPORTED |
#define PNG_STDIO_SUPPORTED |
#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_TEXT_SUPPORTED |
#define PNG_TIME_RFC1123_SUPPORTED |
#define PNG_READ_TEXT_SUPPORTED |
#define PNG_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_USER_CHUNKS_SUPPORTED |
#define PNG_USER_LIMITS_SUPPORTED |
#define PNG_USER_MEM_SUPPORTED |
#define PNG_USER_TRANSFORM_INFO_SUPPORTED |
#define PNG_USER_TRANSFORM_PTR_SUPPORTED |
#define PNG_WARNINGS_SUPPORTED |
#define PNG_WRITE_16BIT_SUPPORTED |
#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#define PNG_WRITE_BGR_SUPPORTED |
#define PNG_USER_CHUNKS_SUPPORTED |
#define PNG_CONSOLE_IO_SUPPORTED |
#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED |
#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED |
#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED |
#define PNG_WRITE_FILLER_SUPPORTED |
#define PNG_WRITE_FILTER_SUPPORTED |
#define PNG_WRITE_FLUSH_SUPPORTED |
#define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED |
#define PNG_WRITE_INTERLACING_SUPPORTED |
#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED |
#define PNG_WRITE_INVERT_ALPHA_SUPPORTED |
#define PNG_WRITE_INVERT_SUPPORTED |
#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED |
#define PNG_WRITE_PACKSWAP_SUPPORTED |
#define PNG_WRITE_PACK_SUPPORTED |
#define PNG_READ_FILLER_SUPPORTED |
#define PNG_WRITE_SHIFT_SUPPORTED |
#define PNG_WRITE_SUPPORTED |
#define PNG_WRITE_SWAP_ALPHA_SUPPORTED |
#define PNG_WRITE_SWAP_SUPPORTED |
#define PNG_WRITE_TEXT_SUPPORTED |
#define PNG_WRITE_TRANSFORMS_SUPPORTED |
#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_WRITE_USER_TRANSFORM_SUPPORTED |
#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
#define PNG_WRITE_bKGD_SUPPORTED |
#define PNG_WRITE_tRNS_SUPPORTED |
#define PNG_READ_sPLT_SUPPORTED |
#define PNG_WRITE_sCAL_SUPPORTED |
#define PNG_WRITE_cHRM_SUPPORTED |
#define PNG_WRITE_gAMA_SUPPORTED |
#define PNG_WRITE_hIST_SUPPORTED |
#define PNG_WRITE_iCCP_SUPPORTED |
#define PNG_WRITE_iTXt_SUPPORTED |
#define PNG_WRITE_oFFs_SUPPORTED |
#define PNG_READ_tEXt_SUPPORTED |
#define PNG_WRITE_pCAL_SUPPORTED |
#define PNG_WRITE_pHYs_SUPPORTED |
#define PNG_WRITE_sBIT_SUPPORTED |
#define PNG_READ_INVERT_SUPPORTED |
#define PNG_READ_16_TO_8_SUPPORTED |
#define PNG_WRITE_cHRM_SUPPORTED |
#define PNG_16BIT_SUPPORTED |
#define PNG_WRITE_USER_TRANSFORM_SUPPORTED |
#define PNG_READ_BGR_SUPPORTED |
#define PNG_WRITE_PACKSWAP_SUPPORTED |
#define PNG_WRITE_INVERT_ALPHA_SUPPORTED |
#define PNG_sCAL_SUPPORTED |
#define PNG_WRITE_sCAL_SUPPORTED |
#define PNG_WRITE_sPLT_SUPPORTED |
#define PNG_WRITE_sRGB_SUPPORTED |
#define PNG_WRITE_tEXt_SUPPORTED |
#define PNG_WRITE_tIME_SUPPORTED |
#define PNG_WRITE_tRNS_SUPPORTED |
#define PNG_WRITE_zTXt_SUPPORTED |
#define PNG_USER_TRANSFORM_INFO_SUPPORTED |
#define PNG_sBIT_SUPPORTED |
#define PNG_bKGD_SUPPORTED |
#define PNG_cHRM_SUPPORTED |
#define PNG_bKGD_SUPPORTED |
#define PNG_tRNS_SUPPORTED |
#define PNG_WRITE_iTXt_SUPPORTED |
#define PNG_oFFs_SUPPORTED |
#define PNG_USER_TRANSFORM_PTR_SUPPORTED |
#define PNG_gAMA_SUPPORTED |
#define PNG_hIST_SUPPORTED |
#define PNG_iCCP_SUPPORTED |
#define PNG_sRGB_SUPPORTED |
#define PNG_READ_zTXt_SUPPORTED |
#define PNG_gAMA_SUPPORTED |
#define PNG_iTXt_SUPPORTED |
#define PNG_oFFs_SUPPORTED |
#define PNG_pCAL_SUPPORTED |
#define PNG_CHECK_cHRM_SUPPORTED |
#define PNG_tIME_SUPPORTED |
#define PNG_pHYs_SUPPORTED |
#define PNG_READ_iTXt_SUPPORTED |
#define PNG_TEXT_SUPPORTED |
#define PNG_SAVE_INT_32_SUPPORTED |
#define PNG_sBIT_SUPPORTED |
#define PNG_sCAL_SUPPORTED |
#define PNG_sPLT_SUPPORTED |
#define PNG_sRGB_SUPPORTED |
#define PNG_tEXt_SUPPORTED |
#define PNG_tIME_SUPPORTED |
#define PNG_tRNS_SUPPORTED |
#define PNG_zTXt_SUPPORTED |
#define PNG_iTXt_SUPPORTED |
/* end of options */ |
/* settings */ |
#define PNG_API_RULE 0 |
#define PNG_CALLOC_SUPPORTED |
#define PNG_COST_SHIFT 3 |
#define PNG_DEFAULT_READ_MACROS 1 |
#define PNG_GAMMA_THRESHOLD_FIXED 5000 |
#define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE |
#define PNG_INFLATE_BUF_SIZE 1024 |
#define PNG_MAX_GAMMA_8 11 |
#define PNG_QUANTIZE_BLUE_BITS 5 |
#define PNG_QUANTIZE_GREEN_BITS 5 |
#define PNG_QUANTIZE_RED_BITS 5 |
#define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1) |
#define PNG_TEXT_Z_DEFAULT_STRATEGY 0 |
#define PNG_WEIGHT_SHIFT 8 |
#define PNG_ZBUF_SIZE 8192 |
#define PNG_ZLIB_VERNUM 0x1280 |
#define PNG_Z_DEFAULT_COMPRESSION (-1) |
#define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0 |
#define PNG_Z_DEFAULT_STRATEGY 1 |
#define PNG_sCAL_PRECISION 5 |
#define PNG_sRGB_PROFILE_CHECKS 2 |
/* end of settings */ |
#endif /* PNGLCONF_H */ |
/programs/develop/libraries/libpng/pngmem.c |
---|
1,8 → 1,8 |
/* pngmem.c - stub functions for memory allocation |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.0 [February 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
20,86 → 20,25 |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
/* Borland DOS special memory handler */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
/* If you change this, be sure to change the one in png.h also */ |
/* Allocate memory for a png_struct. The malloc and memset can be replaced |
by a single call to calloc() if this is thought to improve performance. */ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct,(int type),PNG_ALLOCATED) |
/* Free a png_struct */ |
void /* PRIVATE */ |
png_destroy_png_struct(png_structrp png_ptr) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, NULL, NULL)); |
} |
/* Alternate version of png_create_struct, for use with user-defined malloc. */ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), |
PNG_ALLOCATED) |
if (png_ptr != NULL) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
/* png_free might call png_error and may certainly call |
* png_get_mem_ptr, so fake a temporary png_struct to support this. |
*/ |
png_struct dummy_struct = *png_ptr; |
memset(png_ptr, 0, (sizeof *png_ptr)); |
png_free(&dummy_struct, png_ptr); |
if (type == PNG_STRUCT_INFO) |
size = png_sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = png_sizeof(png_struct); |
else |
return (png_get_copyright(NULL)); |
# ifdef PNG_USER_MEM_SUPPORTED |
if (malloc_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); |
} |
else |
# endif /* PNG_USER_MEM_SUPPORTED */ |
struct_ptr = (png_voidp)farmalloc(size); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, NULL, NULL); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
# ifdef PNG_SETJMP_SUPPORTED |
/* We may have a jmp_buf left to deallocate. */ |
png_free_jmpbuf(&dummy_struct); |
# endif |
if (struct_ptr != NULL) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
if (free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
# endif /* PNG_USER_MEM_SUPPORTED */ |
farfree (struct_ptr); |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
* 64K. However, zlib may allocate more then 64K if you don't tell |
106,467 → 45,184 |
* it not to. See zconf.h and png.h for more information. zlib does |
* need to allocate exactly 64K, so whatever you call here must |
* have the ability to do that. |
* |
* Borland seems to have a problem in DOS mode for exactly 64K. |
* It gives you a segment with an offset of 8 (perhaps to store its |
* memory stuff). zlib doesn't like this at all, so we have to |
* detect and deal with it. This code should not be needed in |
* Windows or OS/2 modes, and only in 16 bit mode. This code has |
* been updated by Alexander Lehmann for version 0.89 to waste less |
* memory. |
* |
* Note that we can't use png_size_t for the "size" declaration, |
* since on some systems a png_size_t is a 16-bit quantity, and as a |
* result, we would be truncating potentially larger memory requests |
* (which should cause a fatal error) and introducing major problems. |
*/ |
PNG_FUNCTION(png_voidp,PNGAPI |
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
ret = (png_malloc(png_ptr, size)); |
ret = png_malloc(png_ptr, size); |
if (ret != NULL) |
png_memset(ret,0,(png_size_t)size); |
memset(ret, 0, size); |
return (ret); |
return ret; |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
/* png_malloc_base, an internal function added at libpng 1.6.0, does the work of |
* allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED. |
* Checking and error handling must happen outside this routine; it returns NULL |
* if the allocation cannot be done (for any reason.) |
*/ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED) |
{ |
png_voidp ret; |
if (png_ptr == NULL || size == 0) |
return (NULL); |
/* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS |
* allocators have also been removed in 1.6.0, so any 16-bit system now has |
* to implement a user memory handler. This checks to be sure it isn't |
* called with big numbers. |
*/ |
# ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->malloc_fn != NULL) |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
else |
ret = (png_malloc_default(png_ptr, size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory"); |
return (ret); |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL || size == 0) |
return (NULL); |
PNG_UNUSED(png_ptr) |
#endif |
if (size > 0 && size <= PNG_SIZE_MAX |
# ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
png_warning(png_ptr, "Cannot Allocate > 64K"); |
ret = NULL; |
} |
else |
&& size <= 65536U |
# endif |
if (size != (size_t)size) |
ret = NULL; |
else if (size == (png_uint_32)65536L) |
) |
{ |
if (png_ptr->offset_table == NULL) |
{ |
/* Try to see if we need to do any of this fancy stuff */ |
ret = farmalloc(size); |
if (ret == NULL || ((png_size_t)ret & 0xffff)) |
{ |
int num_blocks; |
png_uint_32 total_size; |
png_bytep table; |
int i; |
png_byte huge * hptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr != NULL && png_ptr->malloc_fn != NULL) |
return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size); |
if (ret != NULL) |
{ |
farfree(ret); |
ret = NULL; |
} |
if (png_ptr->zlib_window_bits > 14) |
num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); |
else |
num_blocks = 1; |
if (png_ptr->zlib_mem_level >= 7) |
num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); |
else |
num_blocks++; |
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; |
table = farmalloc(total_size); |
if (table == NULL) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */ |
else |
png_warning(png_ptr, "Out Of Memory"); |
# endif |
return (NULL); |
return malloc((size_t)size); /* checked for truncation above */ |
} |
if ((png_size_t)table & 0xfff0) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
else |
png_warning(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
# endif |
return (NULL); |
return NULL; |
} |
png_ptr->offset_table = table; |
png_ptr->offset_table_ptr = farmalloc(num_blocks * |
png_sizeof(png_bytep)); |
if (png_ptr->offset_table_ptr == NULL) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */ |
else |
png_warning(png_ptr, "Out Of memory"); |
# endif |
return (NULL); |
} |
hptr = (png_byte huge *)table; |
if ((png_size_t)hptr & 0xf) |
{ |
hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); |
hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ |
} |
for (i = 0; i < num_blocks; i++) |
{ |
png_ptr->offset_table_ptr[i] = (png_bytep)hptr; |
hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ |
} |
png_ptr->offset_table_number = num_blocks; |
png_ptr->offset_table_count = 0; |
png_ptr->offset_table_count_free = 0; |
} |
} |
if (png_ptr->offset_table_count >= png_ptr->offset_table_number) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); /* Note "o" and "M" */ |
else |
png_warning(png_ptr, "Out of Memory"); |
# endif |
return (NULL); |
} |
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; |
} |
else |
ret = farmalloc(size); |
# ifndef PNG_USER_MEM_SUPPORTED |
if (ret == NULL) |
{ |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */ |
else |
png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */ |
} |
# endif |
return (ret); |
} |
/* Free a pointer allocated by png_malloc(). In the default |
* configuration, png_ptr is not used, but is passed in case it |
* is needed. If ptr is NULL, return without taking any action. |
/* This is really here only to work round a spurious warning in GCC 4.6 and 4.7 |
* that arises because of the checks in png_realloc_array that are repeated in |
* png_malloc_array. |
*/ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
static png_voidp |
png_malloc_array_checked(png_const_structrp png_ptr, int nelements, |
size_t element_size) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
png_alloc_size_t req = nelements; /* known to be > 0 */ |
# ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
if (req <= PNG_SIZE_MAX/element_size) |
return png_malloc_base(png_ptr, req * element_size); |
else |
png_free_default(png_ptr, ptr); |
/* The failure case when the request is too large */ |
return NULL; |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_malloc_array,(png_const_structrp png_ptr, int nelements, |
size_t element_size),PNG_ALLOCATED) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (nelements <= 0 || element_size == 0) |
png_error(png_ptr, "internal error: array alloc"); |
if (png_ptr == NULL || ptr == NULL) |
return; |
if (png_ptr->offset_table != NULL) |
{ |
int i; |
for (i = 0; i < png_ptr->offset_table_count; i++) |
{ |
if (ptr == png_ptr->offset_table_ptr[i]) |
{ |
ptr = NULL; |
png_ptr->offset_table_count_free++; |
break; |
return png_malloc_array_checked(png_ptr, nelements, element_size); |
} |
} |
if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) |
{ |
farfree(png_ptr->offset_table); |
farfree(png_ptr->offset_table_ptr); |
png_ptr->offset_table = NULL; |
png_ptr->offset_table_ptr = NULL; |
} |
} |
if (ptr != NULL) |
farfree(ptr); |
} |
#else /* Not the Borland DOS special memory handler */ |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct,(int type),PNG_ALLOCATED) |
png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array, |
int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, NULL, NULL)); |
} |
/* These are internal errors: */ |
if (add_elements <= 0 || element_size == 0 || old_elements < 0 || |
(old_array == NULL && old_elements > 0)) |
png_error(png_ptr, "internal error: array realloc"); |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), |
PNG_ALLOCATED) |
/* Check for overflow on the elements count (so the caller does not have to |
* check.) |
*/ |
if (add_elements <= INT_MAX - old_elements) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
png_voidp new_array = png_malloc_array_checked(png_ptr, |
old_elements+add_elements, element_size); |
if (type == PNG_STRUCT_INFO) |
size = png_sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = png_sizeof(png_struct); |
else |
return (NULL); |
# ifdef PNG_USER_MEM_SUPPORTED |
if (malloc_fn != NULL) |
if (new_array != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, size); |
/* Because png_malloc_array worked the size calculations below cannot |
* overflow. |
*/ |
if (old_elements > 0) |
memcpy(new_array, old_array, element_size*(unsigned)old_elements); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
memset((char*)new_array + element_size*(unsigned)old_elements, 0, |
element_size*(unsigned)add_elements); |
return (struct_ptr); |
return new_array; |
} |
# endif /* PNG_USER_MEM_SUPPORTED */ |
# if defined(__TURBOC__) && !defined(__FLAT__) |
struct_ptr = (png_voidp)farmalloc(size); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
struct_ptr = (png_voidp)halloc(size, 1); |
# else |
struct_ptr = (png_voidp)malloc(size); |
# endif |
# endif |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, NULL, NULL); |
return NULL; /* error */ |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (struct_ptr != NULL) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
if (free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
# endif /* PNG_USER_MEM_SUPPORTED */ |
# if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(struct_ptr); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(struct_ptr); |
# else |
free(struct_ptr); |
# endif |
# endif |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
* 64K. However, zlib may allocate more then 64K if you don't tell |
* it not to. See zconf.h and png.h for more information. zlib does |
* need to allocate exactly 64K, so whatever you call here must |
* have the ability to do that. |
/* Various functions that have different error handling are derived from this. |
* png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate |
* function png_malloc_default is also provided. |
*/ |
PNG_FUNCTION(png_voidp,PNGAPI |
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
ret = (png_malloc(png_ptr, size)); |
if (png_ptr == NULL) |
return NULL; |
if (ret != NULL) |
png_memset(ret,0,(png_size_t)size); |
ret = png_malloc_base(png_ptr, size); |
return (ret); |
if (ret == NULL) |
png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */ |
return ret; |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED PNG_DEPRECATED) |
{ |
png_voidp ret; |
# ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr == NULL || size == 0) |
return (NULL); |
if (png_ptr == NULL) |
return NULL; |
if (png_ptr->malloc_fn != NULL) |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
/* Passing 'NULL' here bypasses the application provided memory handler. */ |
ret = png_malloc_base(NULL/*use malloc*/, size); |
else |
ret = (png_malloc_default(png_ptr, size)); |
if (ret == NULL) |
png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */ |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
return (ret); |
return ret; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
/* This function was added at libpng version 1.2.3. The png_malloc_warn() |
* function will issue a png_warning and return NULL instead of issuing a |
* png_error, if it fails to allocate the requested memory. |
*/ |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED) |
{ |
png_voidp ret; |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr != NULL) |
{ |
png_voidp ret = png_malloc_base(png_ptr, size); |
if (png_ptr == NULL || size == 0) |
return (NULL); |
if (ret != NULL) |
return ret; |
# ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
png_warning(png_ptr, "Out of memory"); |
} |
else |
# endif |
return NULL; |
} |
# endif |
/* Check for overflow */ |
# if defined(__TURBOC__) && !defined(__FLAT__) |
if (size != (unsigned long)size) |
ret = NULL; |
else |
ret = farmalloc(size); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
if (size != (unsigned long)size) |
ret = NULL; |
else |
ret = halloc(size, 1); |
# else |
if (size != (size_t)size) |
ret = NULL; |
else |
ret = malloc((size_t)size); |
# endif |
# endif |
# ifndef PNG_USER_MEM_SUPPORTED |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
# endif |
return (ret); |
} |
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return |
* without taking any action. |
*/ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
png_free(png_const_structrp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
573,65 → 229,28 |
# ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr); |
else |
png_free_default(png_ptr, ptr); |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
PNG_FUNCTION(void,PNGAPI |
png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
# endif /* PNG_USER_MEM_SUPPORTED */ |
# if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(ptr); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(ptr); |
# else |
free(ptr); |
# endif |
# endif |
} |
#endif /* Not Borland DOS special memory handler */ |
/* This function was added at libpng version 1.2.3. The png_malloc_warn() |
* function will set up png_malloc() to issue a png_warning and return NULL |
* instead of issuing a png_error, if it fails to allocate the requested |
* memory. |
*/ |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ptr; |
png_uint_32 save_flags; |
if (png_ptr == NULL) |
return (NULL); |
save_flags = png_ptr->flags; |
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); |
png_ptr->flags=save_flags; |
return(ptr); |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
/* This function is called when the application wants to use another method |
* of allocating and freeing memory. |
*/ |
void PNGAPI |
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr |
png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr |
malloc_fn, png_free_ptr free_fn) |
{ |
if (png_ptr != NULL) |
647,12 → 266,12 |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_mem_ptr(png_const_structp png_ptr) |
png_get_mem_ptr(png_const_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return NULL; |
return ((png_voidp)png_ptr->mem_ptr); |
return png_ptr->mem_ptr; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngpread.c |
---|
1,8 → 1,8 |
/* pngpread.c - read a png file in push mode |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.0 [February 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
27,7 → 27,7 |
#define PNG_ERROR_MODE 8 |
void PNGAPI |
png_process_data(png_structp png_ptr, png_infop info_ptr, |
png_process_data(png_structrp png_ptr, png_inforp info_ptr, |
png_bytep buffer, png_size_t buffer_size) |
{ |
if (png_ptr == NULL || info_ptr == NULL) |
42,7 → 42,7 |
} |
png_size_t PNGAPI |
png_process_data_pause(png_structp png_ptr, int save) |
png_process_data_pause(png_structrp png_ptr, int save) |
{ |
if (png_ptr != NULL) |
{ |
69,7 → 69,7 |
} |
png_uint_32 PNGAPI |
png_process_data_skip(png_structp png_ptr) |
png_process_data_skip(png_structrp png_ptr) |
{ |
png_uint_32 remaining = 0; |
103,7 → 103,7 |
* doing before we ran out of data... |
*/ |
void /* PRIVATE */ |
png_process_some_data(png_structp png_ptr, png_infop info_ptr) |
png_process_some_data(png_structrp png_ptr, png_inforp info_ptr) |
{ |
if (png_ptr == NULL) |
return; |
128,30 → 128,6 |
break; |
} |
#ifdef PNG_READ_tEXt_SUPPORTED |
case PNG_READ_tEXt_MODE: |
{ |
png_push_read_tEXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
case PNG_READ_zTXt_MODE: |
{ |
png_push_read_zTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
case PNG_READ_iTXt_MODE: |
{ |
png_push_read_iTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
case PNG_SKIP_MODE: |
{ |
png_push_crc_finish(png_ptr); |
173,9 → 149,9 |
* routine. |
*/ |
void /* PRIVATE */ |
png_push_read_sig(png_structp png_ptr, png_infop info_ptr) |
png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr) |
{ |
png_size_t num_checked = png_ptr->sig_bytes, |
png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ |
num_to_check = 8 - num_checked; |
if (png_ptr->buffer_size < num_to_check) |
206,63 → 182,12 |
} |
void /* PRIVATE */ |
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) |
png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr) |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
png_uint_32 chunk_name; |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int keep; /* unknown handling method */ |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
/* First we make sure we have enough data for the 4 byte chunk name |
* and the 4 byte chunk length before proceeding with decoding the |
273,6 → 198,7 |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
png_byte chunk_tag[4]; |
if (png_ptr->buffer_size < 8) |
{ |
283,16 → 209,41 |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_crc_read(png_ptr, chunk_tag, 4); |
png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag); |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
chunk_name = png_ptr->chunk_name; |
if (chunk_name == png_IDAT) |
{ |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
/* If we reach an IDAT chunk, this means we have read all of the |
* header chunks, and we can start reading the image (or if this |
* is called after the image has been read - we have an error). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
png_ptr->mode |= PNG_HAVE_IDAT; |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) |
if (png_ptr->push_length == 0) |
return; |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_benign_error(png_ptr, "Too many IDATs found"); |
} |
if (chunk_name == png_IHDR) |
{ |
if (png_ptr->push_length != 13) |
png_error(png_ptr, "Invalid IHDR length"); |
306,7 → 257,7 |
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
else if (chunk_name == png_IEND) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
321,7 → 272,7 |
} |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
329,27 → 280,14 |
return; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep); |
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); |
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
if (chunk_name == png_PLTE) |
png_ptr->mode |= PNG_HAVE_PLTE; |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
} |
} |
#endif |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
else if (chunk_name == png_PLTE) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
359,32 → 297,9 |
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
else if (chunk_name == png_IDAT) |
{ |
/* If we reach an IDAT chunk, this means we have read all of the |
* header chunks, and we can start reading the image (or if this |
* is called after the image has been read - we have an error). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) |
if (png_ptr->push_length == 0) |
return; |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_benign_error(png_ptr, "Too many IDATs found"); |
} |
png_ptr->idat_size = png_ptr->push_length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_ptr->process_mode = PNG_READ_IDAT_MODE; |
png_push_have_info(png_ptr, info_ptr); |
png_ptr->zstream.avail_out = |
395,7 → 310,7 |
} |
#ifdef PNG_READ_gAMA_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
else if (png_ptr->chunk_name == png_gAMA) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
408,7 → 323,7 |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
else if (png_ptr->chunk_name == png_sBIT) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
421,7 → 336,7 |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
else if (png_ptr->chunk_name == png_cHRM) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
434,7 → 349,7 |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
else if (chunk_name == png_sRGB) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
447,7 → 362,7 |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
else if (png_ptr->chunk_name == png_iCCP) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
460,7 → 375,7 |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
else if (chunk_name == png_sPLT) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
473,7 → 388,7 |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
else if (chunk_name == png_tRNS) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
486,7 → 401,7 |
#endif |
#ifdef PNG_READ_bKGD_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
else if (chunk_name == png_bKGD) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
499,7 → 414,7 |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
else if (chunk_name == png_hIST) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
512,7 → 427,7 |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
else if (chunk_name == png_pHYs) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
525,7 → 440,7 |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
else if (chunk_name == png_oFFs) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
538,7 → 453,7 |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
else if (chunk_name == png_pCAL) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
551,7 → 466,7 |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
else if (chunk_name == png_sCAL) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
564,7 → 479,7 |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
else if (chunk_name == png_tIME) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
577,7 → 492,7 |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
else if (chunk_name == png_tEXt) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
585,12 → 500,12 |
return; |
} |
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); |
png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
else if (chunk_name == png_zTXt) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
598,12 → 513,12 |
return; |
} |
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); |
png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
else if (chunk_name == png_iTXt) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
611,7 → 526,7 |
return; |
} |
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); |
png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
622,7 → 537,8 |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); |
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, |
PNG_HANDLE_CHUNK_AS_DEFAULT); |
} |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
629,7 → 545,7 |
} |
void /* PRIVATE */ |
png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) |
png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip) |
{ |
png_ptr->process_mode = PNG_SKIP_MODE; |
png_ptr->skip_length = skip; |
636,7 → 552,7 |
} |
void /* PRIVATE */ |
png_push_crc_finish(png_structp png_ptr) |
png_push_crc_finish(png_structrp png_ptr) |
{ |
if (png_ptr->skip_length && png_ptr->save_buffer_size) |
{ |
715,7 → 631,7 |
else |
save_size = png_ptr->save_buffer_size; |
png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); |
memcpy(ptr, png_ptr->save_buffer_ptr, save_size); |
length -= save_size; |
ptr += save_size; |
png_ptr->buffer_size -= save_size; |
732,7 → 648,7 |
else |
save_size = png_ptr->current_buffer_size; |
png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); |
memcpy(ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
740,7 → 656,7 |
} |
void /* PRIVATE */ |
png_push_save_buffer(png_structp png_ptr) |
png_push_save_buffer(png_structrp png_ptr) |
{ |
if (png_ptr->save_buffer_size) |
{ |
781,13 → 697,13 |
png_error(png_ptr, "Insufficient memory for save_buffer"); |
} |
png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); |
memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); |
png_free(png_ptr, old_buffer); |
png_ptr->save_buffer_max = new_max; |
} |
if (png_ptr->current_buffer_size) |
{ |
png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, |
memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, |
png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); |
png_ptr->save_buffer_size += png_ptr->current_buffer_size; |
png_ptr->current_buffer_size = 0; |
797,7 → 713,7 |
} |
void /* PRIVATE */ |
png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, |
png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
png_ptr->current_buffer = buffer; |
807,13 → 723,14 |
} |
void /* PRIVATE */ |
png_push_read_IDAT(png_structp png_ptr) |
png_push_read_IDAT(png_structrp png_ptr) |
{ |
PNG_IDAT; |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
png_byte chunk_tag[4]; |
/* TODO: this code can be commoned up with the same code in push_read */ |
if (png_ptr->buffer_size < 8) |
{ |
png_push_save_buffer(png_ptr); |
823,14 → 740,15 |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_crc_read(png_ptr, chunk_tag, 4); |
png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
if (png_ptr->chunk_name != png_IDAT) |
{ |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) |
png_error(png_ptr, "Not enough compressed data"); |
return; |
838,6 → 756,7 |
png_ptr->idat_size = png_ptr->push_length; |
} |
if (png_ptr->idat_size && png_ptr->save_buffer_size) |
{ |
png_size_t save_size = png_ptr->save_buffer_size; |
901,11 → 820,12 |
png_crc_finish(png_ptr, 0); |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->zowner = 0; |
} |
} |
void /* PRIVATE */ |
png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, |
png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
/* The caller checks for a non-zero buffer length. */ |
917,6 → 837,7 |
* handle the uncompressed results. |
*/ |
png_ptr->zstream.next_in = buffer; |
/* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */ |
png_ptr->zstream.avail_in = (uInt)buffer_length; |
/* Keep going until the decompressed data is all processed |
923,7 → 844,7 |
* or the stream marked as finished. |
*/ |
while (png_ptr->zstream.avail_in > 0 && |
!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) |
{ |
int ret; |
934,9 → 855,9 |
*/ |
if (!(png_ptr->zstream.avail_out > 0)) |
{ |
png_ptr->zstream.avail_out = |
(uInt) PNG_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1; |
/* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */ |
png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1); |
png_ptr->zstream.next_out = png_ptr->row_buf; |
} |
954,7 → 875,8 |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
/* Terminate the decompression. */ |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; |
png_ptr->zowner = 0; |
/* This may be a truncated stream (missing or |
* damaged end code). Treat that as a warning. |
982,7 → 904,8 |
{ |
/* Extra data. */ |
png_warning(png_ptr, "Extra compressed data in IDAT"); |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; |
png_ptr->zowner = 0; |
/* Do no more processing; skip the unprocessed |
* input check below. |
997,7 → 920,7 |
/* And check for the end of the stream. */ |
if (ret == Z_STREAM_END) |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; |
} |
/* All the data should have been processed, if anything |
1009,36 → 932,58 |
} |
void /* PRIVATE */ |
png_push_process_row(png_structp png_ptr) |
png_push_process_row(png_structrp png_ptr) |
{ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
/* 1.5.6: row_info moved out of png_struct to a local here. */ |
png_row_info row_info; |
png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */ |
row_info.color_type = png_ptr->color_type; |
row_info.bit_depth = png_ptr->bit_depth; |
row_info.channels = png_ptr->channels; |
row_info.pixel_depth = png_ptr->pixel_depth; |
row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE) |
{ |
if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) |
png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, |
png_ptr->prev_row + 1, png_ptr->row_buf[0]); |
else |
png_error(png_ptr, "bad adaptive filter value"); |
} |
png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1); |
/* libpng 1.5.6: the following line was copying png_ptr->rowbytes before |
* 1.5.6, while the buffer really is this big in current versions of libpng |
* it may not be in the future, so this was changed just to copy the |
* interlaced row count: |
*/ |
memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); |
if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) |
png_do_read_transformations(png_ptr); |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr, &row_info); |
#endif |
/* The transformed pixel depth should match the depth now in row_info. */ |
if (png_ptr->transformed_pixel_depth == 0) |
{ |
png_ptr->transformed_pixel_depth = row_info.pixel_depth; |
if (row_info.pixel_depth > png_ptr->maximum_pixel_depth) |
png_error(png_ptr, "progressive row overflow"); |
} |
else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) |
png_error(png_ptr, "internal progressive row size calculation error"); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Blow up interlaced rows to full size */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* old interface (pre-1.0.9): |
png_do_read_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, |
png_ptr->transformations); |
switch (png_ptr->pass) |
{ |
1216,26 → 1161,28 |
} |
void /* PRIVATE */ |
png_read_push_finish_row(png_structp png_ptr) |
png_read_push_finish_row(png_structrp png_ptr) |
{ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
#endif |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
1245,7 → 1192,7 |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
do |
{ |
1279,528 → 1226,15 |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
} |
#ifdef PNG_READ_tEXt_SUPPORTED |
void /* PRIVATE */ |
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
png_push_have_info(png_structrp png_ptr, png_inforp info_ptr) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place tEXt"); |
/*NOT REACHED*/ |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_size_t)(length + 1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_tEXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#ifdef PNG_MAX_MALLOC_64K |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* Empty loop */ ; |
if (text < key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, png_sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
text_ptr->itxt_length = 0; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
png_ptr->current_text = NULL; |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk"); |
} |
} |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
void /* PRIVATE */ |
png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place zTXt"); |
/*NOT REACHED*/ |
} |
#ifdef PNG_MAX_MALLOC_64K |
/* We can't handle zTXt chunks > 64K, since we don't have enough space |
* to be able to store the uncompressed data. Actually, the threshold |
* is probably around 32K, but it isn't as definite as 64K is. |
*/ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "zTXt chunk too large to fit in memory"); |
png_push_crc_skip(png_ptr, length); |
return; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_size_t)(length + 1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_zTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
png_size_t text_size, key_size; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* Empty loop */ ; |
/* zTXt can't have zero text */ |
if (text >= key + png_ptr->current_text_size) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */ |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
png_ptr->zstream.next_in = (png_bytep)text; |
png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - |
(text - key)); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
key_size = text - key; |
text_size = 0; |
text = NULL; |
ret = Z_STREAM_END; |
while (png_ptr->zstream.avail_in) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) |
{ |
if (text == NULL) |
{ |
text = (png_charp)png_malloc(png_ptr, |
(png_ptr->zbuf_size |
- png_ptr->zstream.avail_out + key_size + 1)); |
png_memcpy(text + key_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_memcpy(text, key, key_size); |
text_size = key_size + png_ptr->zbuf_size - |
png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
else |
{ |
png_charp tmp; |
tmp = text; |
text = (png_charp)png_malloc(png_ptr, text_size + |
(png_ptr->zbuf_size |
- png_ptr->zstream.avail_out + 1)); |
png_memcpy(text, tmp, text_size); |
png_free(png_ptr, tmp); |
png_memcpy(text + text_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
if (ret != Z_STREAM_END) |
{ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
else |
{ |
break; |
} |
if (ret == Z_STREAM_END) |
break; |
} |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
if (ret != Z_STREAM_END) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
key = text; |
text += key_size; |
text_ptr = (png_textp)png_malloc(png_ptr, |
png_sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; |
text_ptr->key = key; |
text_ptr->itxt_length = 0; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk"); |
} |
} |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
void /* PRIVATE */ |
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place iTXt"); |
/*NOT REACHED*/ |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "iTXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_size_t)(length + 1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_iTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp key; |
int comp_flag; |
png_charp lang; |
png_charp lang_key; |
png_charp text; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#ifdef PNG_MAX_MALLOC_64K |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (lang = key; *lang; lang++) |
/* Empty loop */ ; |
if (lang < key + png_ptr->current_text_size - 3) |
lang++; |
comp_flag = *lang++; |
lang++; /* Skip comp_type, always zero */ |
for (lang_key = lang; *lang_key; lang_key++) |
/* Empty loop */ ; |
lang_key++; /* Skip NUL separator */ |
text=lang_key; |
if (lang_key < key + png_ptr->current_text_size - 1) |
{ |
for (; *text; text++) |
/* Empty loop */ ; |
} |
if (text < key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, |
png_sizeof(png_text)); |
text_ptr->compression = comp_flag + 2; |
text_ptr->key = key; |
text_ptr->lang = lang; |
text_ptr->lang_key = lang_key; |
text_ptr->text = text; |
text_ptr->text_length = 0; |
text_ptr->itxt_length = png_strlen(text); |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_ptr->current_text = NULL; |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store iTXt chunk"); |
} |
} |
#endif |
/* This function is called when we haven't found a handler for this |
* chunk. If there isn't a problem with the chunk itself (ie a bad chunk |
* name or a critical chunk), the chunk is (currently) silently ignored. |
*/ |
void /* PRIVATE */ |
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
png_uint_32 skip = 0; |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
} |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_memcpy((png_charp)png_ptr->unknown_chunk.name, |
(png_charp)png_ptr->chunk_name, |
png_sizeof(png_ptr->unknown_chunk.name)); |
png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1] |
= '\0'; |
png_ptr->unknown_chunk.size = (png_size_t)length; |
if (length == 0) |
png_ptr->unknown_chunk.data = NULL; |
else |
{ |
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, |
(png_size_t)length); |
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); |
} |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
if (png_ptr->read_user_chunk_fn != NULL) |
{ |
/* Callback to user unknown chunk handler */ |
int ret; |
ret = (*(png_ptr->read_user_chunk_fn)) |
(png_ptr, &png_ptr->unknown_chunk); |
if (ret < 0) |
png_chunk_error(png_ptr, "error in user chunk"); |
if (ret == 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS) |
png_chunk_error(png_ptr, "unknown critical chunk"); |
png_set_unknown_chunks(png_ptr, info_ptr, |
&png_ptr->unknown_chunk, 1); |
} |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
else |
#endif |
skip=length; |
png_push_crc_skip(png_ptr, skip); |
} |
void /* PRIVATE */ |
png_push_have_info(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->info_fn != NULL) |
(*(png_ptr->info_fn))(png_ptr, info_ptr); |
} |
void /* PRIVATE */ |
png_push_have_end(png_structp png_ptr, png_infop info_ptr) |
png_push_have_end(png_structrp png_ptr, png_inforp info_ptr) |
{ |
if (png_ptr->end_fn != NULL) |
(*(png_ptr->end_fn))(png_ptr, info_ptr); |
1807,7 → 1241,7 |
} |
void /* PRIVATE */ |
png_push_have_row(png_structp png_ptr, png_bytep row) |
png_push_have_row(png_structrp png_ptr, png_bytep row) |
{ |
if (png_ptr->row_fn != NULL) |
(*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, |
1814,22 → 1248,25 |
(int)png_ptr->pass); |
} |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
void PNGAPI |
png_progressive_combine_row (png_structp png_ptr, png_bytep old_row, |
png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row, |
png_const_bytep new_row) |
{ |
PNG_CONST int FARDATA png_pass_dsp_mask[7] = |
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
if (png_ptr == NULL) |
return; |
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ |
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); |
/* new_row is a flag here - if it is NULL then the app callback was called |
* from an empty row (see the calls to png_struct::row_fn below), otherwise |
* it must be png_ptr->row_buf+1 |
*/ |
if (new_row != NULL) |
png_combine_row(png_ptr, old_row, 1/*display*/); |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
void PNGAPI |
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, |
png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr, |
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
png_progressive_end_ptr end_fn) |
{ |
1844,7 → 1281,7 |
} |
png_voidp PNGAPI |
png_get_progressive_ptr(png_const_structp png_ptr) |
png_get_progressive_ptr(png_const_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
/programs/develop/libraries/libpng/pngprefix.h |
---|
--- libraries/libpng/pngpriv.h (revision 3927) |
+++ libraries/libpng/pngpriv.h (revision 3928) |
@@ -2,11 +2,11 @@ |
/* pngpriv.h - private declarations for use inside libpng |
* |
* For conditions of distribution and use, see copyright notice in png.h |
- * Copyright (c) 1998-2011 Glenn Randers-Pehrson |
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
- * Last changed in libpng 1.5.0 [January 6, 2011] |
+ * Last changed in libpng 1.6.3 [July 18, 2013] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
@@ -14,7 +14,7 @@ |
*/ |
/* The symbols declared in this file (including the functions declared |
- * as PNG_EXTERN) are PRIVATE. They are not part of the libpng public |
+ * as extern) are PRIVATE. They are not part of the libpng public |
* interface, and are not recommended for use by regular applications. |
* Some of them may become public in the future; others may stay private, |
* change in an incompatible way, or even disappear. |
@@ -25,12 +25,58 @@ |
#ifndef PNGPRIV_H |
#define PNGPRIV_H |
-/* This is required for the definition of abort(), used as a last ditch |
- * error handler when all else fails. |
+/* Feature Test Macros. The following are defined here to ensure that correctly |
+ * implemented libraries reveal the APIs libpng needs to build and hide those |
+ * that are not needed and potentially damaging to the compilation. |
+ * |
+ * Feature Test Macros must be defined before any system header is included (see |
+ * POSIX 1003.1 2.8.2 "POSIX Symbols." |
+ * |
+ * These macros only have an effect if the operating system supports either |
+ * POSIX 1003.1 or C99, or both. On other operating systems (particularly |
+ * Windows/Visual Studio) there is no effect; the OS specific tests below are |
+ * still required (as of 2011-05-02.) |
*/ |
+#define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */ |
+ |
+#ifndef PNG_VERSION_INFO_ONLY |
+/* Standard library headers not required by png.h: */ |
#include <stdlib.h> |
+# include <string.h> |
+#endif |
-#define PNGLIB_BUILD |
+#define PNGLIB_BUILD /*libpng is being built, not used*/ |
+ |
+/* If HAVE_CONFIG_H is defined during the build then the build system must |
+ * provide an appropriate "config.h" file on the include path. The header file |
+ * must provide definitions as required below (search for "HAVE_CONFIG_H"); |
+ * see configure.ac for more details of the requirements. The macro |
+ * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on |
+ * 'configure'; define this macro to prevent the configure build including the |
+ * configure generated config.h. Libpng is expected to compile without *any* |
+ * special build system support on a reasonably ANSI-C compliant system. |
+ */ |
+#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H) |
+# include <config.h> |
+ |
+ /* Pick up the definition of 'restrict' from config.h if it was read: */ |
+# define PNG_RESTRICT restrict |
+#endif |
+ |
+/* To support symbol prefixing it is necessary to know *before* including png.h |
+ * whether the fixed point (and maybe other) APIs are exported, because if they |
+ * are not internal definitions may be required. This is handled below just |
+ * before png.h is included, but load the configuration now if it is available. |
+ */ |
+#ifndef PNGLCONF_H |
+# include "pnglibconf.h" |
+#endif |
+ |
+/* Local renames may change non-exported API functions from png.h */ |
+#if defined(PNG_PREFIX) && !defined(PNGPREFIX_H) |
+# include "pngprefix.h" |
+#endif |
+ |
#ifdef PNG_USER_CONFIG |
# include "pngusr.h" |
/* These should have been defined in pngusr.h */ |
@@ -41,28 +87,199 @@ |
# define PNG_USER_DLLFNAME_POSTFIX "Cb" |
# endif |
#endif |
-#include "png.h" |
-#include "pnginfo.h" |
-#include "pngstruct.h" |
-/* This is used for 16 bit gamma tables - only the top level pointers are const, |
- * this could be changed: |
+/* Compile time options. |
+ * ===================== |
+ * In a multi-arch build the compiler may compile the code several times for the |
+ * same object module, producing different binaries for different architectures. |
+ * When this happens configure-time setting of the target host options cannot be |
+ * done and this interferes with the handling of the ARM NEON optimizations, and |
+ * possibly other similar optimizations. Put additional tests here; in general |
+ * this is needed when the same option can be changed at both compile time and |
+ * run time depending on the target OS (i.e. iOS vs Android.) |
+ * |
+ * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because |
+ * this is not possible with certain compilers (Oracle SUN OS CC), as a result |
+ * it is necessary to ensure that all extern functions that *might* be used |
+ * regardless of $(CFLAGS) get declared in this file. The test on __ARM_NEON__ |
+ * below is one example of this behavior because it is controlled by the |
+ * presence or not of -mfpu=neon on the GCC command line, it is possible to do |
+ * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely |
+ * do this. |
*/ |
-typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp; |
+#ifndef PNG_ARM_NEON_OPT |
+ /* ARM NEON optimizations are being controlled by the compiler settings, |
+ * typically the target FPU. If the FPU has been set to NEON (-mfpu=neon |
+ * with GCC) then the compiler will define __ARM_NEON__ and we can rely |
+ * unconditionally on NEON instructions not crashing, otherwise we must |
+ * disable use of NEON instructions: |
+ */ |
+# ifdef __ARM_NEON__ |
+# define PNG_ARM_NEON_OPT 2 |
+# else |
+# define PNG_ARM_NEON_OPT 0 |
+# endif |
+#endif |
-/* Added at libpng-1.2.9 */ |
-/* Moved to pngpriv.h at libpng-1.5.0 */ |
+#if PNG_ARM_NEON_OPT > 0 |
+ /* NEON optimizations are to be at least considered by libpng, so enable the |
+ * callbacks to do this. |
+ */ |
+# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon |
+#endif |
-/* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure" |
- * script. We may need it here to get the correct configuration on things |
- * like limits. |
+/* Is this a build of a DLL where compilation of the object modules requires |
+ * different preprocessor settings to those required for a simple library? If |
+ * so PNG_BUILD_DLL must be set. |
+ * |
+ * If libpng is used inside a DLL but that DLL does not export the libpng APIs |
+ * PNG_BUILD_DLL must not be set. To avoid the code below kicking in build a |
+ * static library of libpng then link the DLL against that. |
*/ |
-#ifdef PNG_CONFIGURE_LIBPNG |
-# ifdef HAVE_CONFIG_H |
-# include "config.h" |
+#ifndef PNG_BUILD_DLL |
+# ifdef DLL_EXPORT |
+ /* This is set by libtool when files are compiled for a DLL; libtool |
+ * always compiles twice, even on systems where it isn't necessary. Set |
+ * PNG_BUILD_DLL in case it is necessary: |
+ */ |
+# define PNG_BUILD_DLL |
+# else |
+# ifdef _WINDLL |
+ /* This is set by the Microsoft Visual Studio IDE in projects that |
+ * build a DLL. It can't easily be removed from those projects (it |
+ * isn't visible in the Visual Studio UI) so it is a fairly reliable |
+ * indication that PNG_IMPEXP needs to be set to the DLL export |
+ * attributes. |
+ */ |
+# define PNG_BUILD_DLL |
+# else |
+# ifdef __DLL__ |
+ /* This is set by the Borland C system when compiling for a DLL |
+ * (as above.) |
+ */ |
+# define PNG_BUILD_DLL |
+# else |
+ /* Add additional compiler cases here. */ |
# endif |
#endif |
+# endif |
+#endif /* Setting PNG_BUILD_DLL if required */ |
+/* See pngconf.h for more details: the builder of the library may set this on |
+ * the command line to the right thing for the specific compilation system or it |
+ * may be automagically set above (at present we know of no system where it does |
+ * need to be set on the command line.) |
+ * |
+ * PNG_IMPEXP must be set here when building the library to prevent pngconf.h |
+ * setting it to the "import" setting for a DLL build. |
+ */ |
+#ifndef PNG_IMPEXP |
+# ifdef PNG_BUILD_DLL |
+# define PNG_IMPEXP PNG_DLL_EXPORT |
+# else |
+ /* Not building a DLL, or the DLL doesn't require specific export |
+ * definitions. |
+ */ |
+# define PNG_IMPEXP |
+# endif |
+#endif |
+ |
+/* No warnings for private or deprecated functions in the build: */ |
+#ifndef PNG_DEPRECATED |
+# define PNG_DEPRECATED |
+#endif |
+#ifndef PNG_PRIVATE |
+# define PNG_PRIVATE |
+#endif |
+ |
+/* Symbol preprocessing support. |
+ * |
+ * To enable listing global, but internal, symbols the following macros should |
+ * always be used to declare an extern data or function object in this file. |
+ */ |
+#ifndef PNG_INTERNAL_DATA |
+# define PNG_INTERNAL_DATA(type, name, array) extern type name array |
+#endif |
+ |
+#ifndef PNG_INTERNAL_FUNCTION |
+# define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\ |
+ extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes) |
+#endif |
+ |
+/* If floating or fixed point APIs are disabled they may still be compiled |
+ * internally. To handle this make sure they are declared as the appropriate |
+ * internal extern function (otherwise the symbol prefixing stuff won't work and |
+ * the functions will be used without definitions.) |
+ * |
+ * NOTE: although all the API functions are declared here they are not all |
+ * actually built! Because the declarations are still made it is necessary to |
+ * fake out types that they depend on. |
+ */ |
+#ifndef PNG_FP_EXPORT |
+# ifndef PNG_FLOATING_POINT_SUPPORTED |
+# define PNG_FP_EXPORT(ordinal, type, name, args)\ |
+ PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY); |
+# ifndef PNG_VERSION_INFO_ONLY |
+ typedef struct png_incomplete png_double; |
+ typedef png_double* png_doublep; |
+ typedef const png_double* png_const_doublep; |
+ typedef png_double** png_doublepp; |
+# endif |
+# endif |
+#endif |
+#ifndef PNG_FIXED_EXPORT |
+# ifndef PNG_FIXED_POINT_SUPPORTED |
+# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ |
+ PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY); |
+# endif |
+#endif |
+ |
+#include "png.h" |
+ |
+/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */ |
+#ifndef PNG_DLL_EXPORT |
+# define PNG_DLL_EXPORT |
+#endif |
+ |
+/* SECURITY and SAFETY: |
+ * |
+ * By default libpng is built without any internal limits on image size, |
+ * individual heap (png_malloc) allocations or the total amount of memory used. |
+ * If PNG_SAFE_LIMITS_SUPPORTED is defined, however, the limits below are used |
+ * (unless individually overridden). These limits are believed to be fairly |
+ * safe, but builders of secure systems should verify the values against the |
+ * real system capabilities. |
+ */ |
+#ifdef PNG_SAFE_LIMITS_SUPPORTED |
+ /* 'safe' limits */ |
+# ifndef PNG_USER_WIDTH_MAX |
+# define PNG_USER_WIDTH_MAX 1000000 |
+# endif |
+# ifndef PNG_USER_HEIGHT_MAX |
+# define PNG_USER_HEIGHT_MAX 1000000 |
+# endif |
+# ifndef PNG_USER_CHUNK_CACHE_MAX |
+# define PNG_USER_CHUNK_CACHE_MAX 128 |
+# endif |
+# ifndef PNG_USER_CHUNK_MALLOC_MAX |
+# define PNG_USER_CHUNK_MALLOC_MAX 8000000 |
+# endif |
+#else |
+ /* values for no limits */ |
+# ifndef PNG_USER_WIDTH_MAX |
+# define PNG_USER_WIDTH_MAX 0x7fffffff |
+# endif |
+# ifndef PNG_USER_HEIGHT_MAX |
+# define PNG_USER_HEIGHT_MAX 0x7fffffff |
+# endif |
+# ifndef PNG_USER_CHUNK_CACHE_MAX |
+# define PNG_USER_CHUNK_CACHE_MAX 0 |
+# endif |
+# ifndef PNG_USER_CHUNK_MALLOC_MAX |
+# define PNG_USER_CHUNK_MALLOC_MAX 0 |
+# endif |
+#endif |
+ |
/* Moved to pngpriv.h at libpng-1.5.0 */ |
/* NOTE: some of these may have been used in external applications as |
* these definitions were exposed in pngconf.h prior to 1.5. |
@@ -83,6 +300,7 @@ |
# define PNG_MAX_MALLOC_64K |
#endif |
+#ifndef PNG_UNUSED |
/* Unused formal parameter warnings are silenced using the following macro |
* which is expected to have no bad effects on performance (optimizing |
* compilers will probably remove it entirely). Note that if you replace |
@@ -90,6 +308,7 @@ |
* semicolon. |
*/ |
#define PNG_UNUSED(param) (void)param; |
+#endif |
/* Just a little check that someone hasn't tried to define something |
* contradictory. |
@@ -99,12 +318,20 @@ |
# define PNG_ZBUF_SIZE 65536L |
#endif |
-/* If warnings or errors are turned off the code is disabled |
- * or redirected here. |
+/* If warnings or errors are turned off the code is disabled or redirected here. |
+ * From 1.5.4 functions have been added to allow very limited formatting of |
+ * error and warning messages - this code will also be disabled here. |
*/ |
-#ifndef PNG_WARNINGS_SUPPORTED |
-# define png_warning(s1,s2) ((void)0) |
-# define png_chunk_warning(s1,s2) ((void)0) |
+#ifdef PNG_WARNINGS_SUPPORTED |
+# define PNG_WARNING_PARAMETERS(p) png_warning_parameters p; |
+#else |
+# define png_warning(s1,s2) ((void)(s1)) |
+# define png_chunk_warning(s1,s2) ((void)(s1)) |
+# define png_warning_parameter(p,number,string) ((void)0) |
+# define png_warning_parameter_unsigned(p,number,format,value) ((void)0) |
+# define png_warning_parameter_signed(p,number,format,value) ((void)0) |
+# define png_formatted_warning(pp,p,message) ((void)(pp)) |
+# define PNG_WARNING_PARAMETERS(p) |
#endif |
#ifndef PNG_ERROR_TEXT_SUPPORTED |
# define png_error(s1,s2) png_err(s1) |
@@ -112,16 +339,24 @@ |
# define png_fixed_error(s1,s2) png_err(s1) |
#endif |
-#ifndef PNG_EXTERN |
-/* The functions exported by PNG_EXTERN are internal functions, which |
- * aren't usually used outside the library (as far as I know), so it is |
- * debatable if they should be exported at all. In the future, when it |
- * is possible to have run-time registry of chunk-handling functions, |
- * some of these might be made available again. |
-# define PNG_EXTERN extern |
+/* C allows up-casts from (void*) to any pointer and (const void*) to any |
+ * pointer to a const object. C++ regards this as a type error and requires an |
+ * explicit, static, cast and provides the static_cast<> rune to ensure that |
+ * const is not cast away. |
*/ |
-# define PNG_EXTERN |
-#endif |
+#ifdef __cplusplus |
+# define png_voidcast(type, value) static_cast<type>(value) |
+# define png_constcast(type, value) const_cast<type>(value) |
+# define png_aligncast(type, value) \ |
+ static_cast<type>(static_cast<void*>(value)) |
+# define png_aligncastconst(type, value) \ |
+ static_cast<type>(static_cast<const void*>(value)) |
+#else |
+# define png_voidcast(type, value) (value) |
+# define png_constcast(type, value) ((type)(value)) |
+# define png_aligncast(type, value) ((void*)(value)) |
+# define png_aligncastconst(type, value) ((const void*)(value)) |
+#endif /* __cplusplus */ |
/* Some fixed point APIs are still required even if not exported because |
* they get used by the corresponding floating point APIs. This magic |
@@ -133,6 +368,7 @@ |
# define PNGFAPI /* PRIVATE */ |
#endif |
+#ifndef PNG_VERSION_INFO_ONLY |
/* Other defines specific to compilers can go here. Try to keep |
* them inside an appropriate ifdef/endif pair for portability. |
*/ |
@@ -173,6 +409,11 @@ |
# include <alloc.h> |
#endif |
+#if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \ |
+ defined(_WIN32) || defined(__WIN32__) |
+# include <windows.h> /* defines _WINDOWS_ macro */ |
+#endif |
+#endif /* PNG_VERSION_INFO_ONLY */ |
/* Moved here around 1.5.0beta36 from pngconf.h */ |
/* Users may want to use these so they are not private. Any library |
@@ -188,66 +429,52 @@ |
# endif |
#endif |
-#ifdef USE_FAR_KEYWORD |
-/* Use this to make far-to-near assignments */ |
-# define CHECK 1 |
-# define NOCHECK 0 |
-# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) |
-# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) |
-# define png_strcpy _fstrcpy |
-# define png_strncpy _fstrncpy /* Added to v 1.2.6 */ |
-# define png_strlen _fstrlen |
-# define png_memcmp _fmemcmp /* SJT: added */ |
-# define png_memcpy _fmemcpy |
-# define png_memset _fmemset |
-# define png_sprintf sprintf |
+/* These macros may need to be architecture dependent. */ |
+#define PNG_ALIGN_NONE 0 /* do not use data alignment */ |
+#define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */ |
+#ifdef offsetof |
+# define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */ |
#else |
-# ifdef _WINDOWS_ /* Favor Windows over C runtime fns */ |
-# define CVT_PTR(ptr) (ptr) |
-# define CVT_PTR_NOCHECK(ptr) (ptr) |
-# define png_strcpy lstrcpyA |
-# define png_strncpy lstrcpynA |
-# define png_strlen lstrlenA |
-# define png_memcmp memcmp |
-# define png_memcpy CopyMemory |
-# define png_memset memset |
-# define png_sprintf wsprintfA |
-# else |
-# define CVT_PTR(ptr) (ptr) |
-# define CVT_PTR_NOCHECK(ptr) (ptr) |
-# define png_strcpy strcpy |
-# define png_strncpy strncpy /* Added to v 1.2.6 */ |
-# define png_strlen strlen |
-# define png_memcmp memcmp /* SJT: added */ |
-# define png_memcpy memcpy |
-# define png_memset memset |
-# define png_sprintf sprintf |
+# define PNG_ALIGN_OFFSET -1 /* prevent the use of this */ |
# endif |
+#define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */ |
+ |
+#ifndef PNG_ALIGN_TYPE |
+ /* Default to using aligned access optimizations and requiring alignment to a |
+ * multiple of the data type size. Override in a compiler specific fashion |
+ * if necessary by inserting tests here: |
+ */ |
+# define PNG_ALIGN_TYPE PNG_ALIGN_SIZE |
#endif |
-/* End of memory model/platform independent support */ |
-#ifndef PNG_NO_SNPRINTF |
-# ifdef _MSC_VER |
-# define png_snprintf _snprintf /* Added to v 1.2.19 */ |
-# define png_snprintf2 _snprintf |
-# define png_snprintf6 _snprintf |
+#if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE |
+ /* This is used because in some compiler implementations non-aligned |
+ * structure members are supported, so the offsetof approach below fails. |
+ * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access |
+ * is good for performance. Do not do this unless you have tested the result |
+ * and understand it. |
+ */ |
+# define png_alignof(type) (sizeof (type)) |
# else |
-# define png_snprintf snprintf /* Added to v 1.2.19 */ |
-# define png_snprintf2 snprintf |
-# define png_snprintf6 snprintf |
+# if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET |
+# define png_alignof(type) offsetof(struct{char c; type t;}, t) |
+# else |
+# if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS |
+# define png_alignof(type) (1) |
# endif |
+ /* Else leave png_alignof undefined to prevent use thereof */ |
+# endif |
+#endif |
+ |
+/* This implicitly assumes alignment is always to a power of 2. */ |
+#ifdef png_alignof |
+# define png_isaligned(ptr, type)\ |
+ ((((const char*)ptr-(const char*)0) & (png_alignof(type)-1)) == 0) |
#else |
- /* You don't have or don't want to use snprintf(). Caution: Using |
- * sprintf instead of snprintf exposes your application to accidental |
- * or malevolent buffer overflows. If you don't have snprintf() |
- * as a general rule you should provide one (you can get one from |
- * Portable OpenSSH). |
- */ |
-# define png_snprintf(s1,n,fmt,x1) png_sprintf(s1,fmt,x1) |
-# define png_snprintf2(s1,n,fmt,x1,x2) png_sprintf(s1,fmt,x1,x2) |
-# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \ |
- png_sprintf(s1,fmt,x1,x2,x3,x4,x5,x6) |
+# define png_isaligned(ptr, type) 0 |
#endif |
+ |
+/* End of memory model/platform independent support */ |
/* End of 1.5.0beta36 move from pngconf.h */ |
/* CONSTANTS and UTILITY MACROS |
@@ -255,16 +482,18 @@ |
*/ |
/* Various modes of operation. Note that after an init, mode is set to |
- * zero automatically when the structure is created. |
+ * zero automatically when the structure is created. Three of these |
+ * are defined in png.h because they need to be visible to applications |
+ * that call png_set_unknown_chunk(). |
*/ |
-#define PNG_HAVE_IHDR 0x01 |
-#define PNG_HAVE_PLTE 0x02 |
+/* #define PNG_HAVE_IHDR 0x01 (defined in png.h) */ |
+/* #define PNG_HAVE_PLTE 0x02 (defined in png.h) */ |
#define PNG_HAVE_IDAT 0x04 |
-#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ |
+/* #define PNG_AFTER_IDAT 0x08 (defined in png.h) */ |
#define PNG_HAVE_IEND 0x10 |
-#define PNG_HAVE_gAMA 0x20 |
-#define PNG_HAVE_cHRM 0x40 |
-#define PNG_HAVE_sRGB 0x80 |
+ /* 0x20 (unused) */ |
+ /* 0x40 (unused) */ |
+ /* 0x80 (unused) */ |
#define PNG_HAVE_CHUNK_HEADER 0x100 |
#define PNG_WROTE_tIME 0x200 |
#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 |
@@ -271,6 +500,8 @@ |
#define PNG_BACKGROUND_IS_GRAY 0x800 |
#define PNG_HAVE_PNG_SIGNATURE 0x1000 |
#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ |
+ /* 0x4000 (unused) */ |
+#define PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */ |
/* Flags for the transformations the PNG library does on the image data */ |
#define PNG_BGR 0x0001 |
@@ -280,32 +511,31 @@ |
#define PNG_SWAP_BYTES 0x0010 |
#define PNG_INVERT_MONO 0x0020 |
#define PNG_QUANTIZE 0x0040 |
-#define PNG_BACKGROUND 0x0080 |
+#define PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */ |
#define PNG_BACKGROUND_EXPAND 0x0100 |
- /* 0x0200 unused */ |
-#define PNG_16_TO_8 0x0400 |
+#define PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */ |
+#define PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */ |
#define PNG_RGBA 0x0800 |
#define PNG_EXPAND 0x1000 |
#define PNG_GAMMA 0x2000 |
#define PNG_GRAY_TO_RGB 0x4000 |
-#define PNG_FILLER 0x8000L |
-#define PNG_PACKSWAP 0x10000L |
-#define PNG_SWAP_ALPHA 0x20000L |
-#define PNG_STRIP_ALPHA 0x40000L |
-#define PNG_INVERT_ALPHA 0x80000L |
-#define PNG_USER_TRANSFORM 0x100000L |
-#define PNG_RGB_TO_GRAY_ERR 0x200000L |
-#define PNG_RGB_TO_GRAY_WARN 0x400000L |
-#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ |
- /* 0x800000L Unused */ |
-#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ |
-#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ |
- /* 0x4000000L unused */ |
- /* 0x8000000L unused */ |
- /* 0x10000000L unused */ |
- /* 0x20000000L unused */ |
- /* 0x40000000L unused */ |
- |
+#define PNG_FILLER 0x8000 |
+#define PNG_PACKSWAP 0x10000 |
+#define PNG_SWAP_ALPHA 0x20000 |
+#define PNG_STRIP_ALPHA 0x40000 |
+#define PNG_INVERT_ALPHA 0x80000 |
+#define PNG_USER_TRANSFORM 0x100000 |
+#define PNG_RGB_TO_GRAY_ERR 0x200000 |
+#define PNG_RGB_TO_GRAY_WARN 0x400000 |
+#define PNG_RGB_TO_GRAY 0x600000 /* two bits, RGB_TO_GRAY_ERR|WARN */ |
+#define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */ |
+#define PNG_ADD_ALPHA 0x1000000 /* Added to libpng-1.2.7 */ |
+#define PNG_EXPAND_tRNS 0x2000000 /* Added to libpng-1.2.9 */ |
+#define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */ |
+ /* 0x8000000 unused */ |
+ /* 0x10000000 unused */ |
+ /* 0x20000000 unused */ |
+ /* 0x40000000 unused */ |
/* Flags for png_create_struct */ |
#define PNG_STRUCT_PNG 0x0001 |
#define PNG_STRUCT_INFO 0x0002 |
@@ -316,11 +546,11 @@ |
/* Flags for the png_ptr->flags rather than declaring a byte for each one */ |
#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 |
-#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 |
-#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 |
-#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 |
-#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 |
-#define PNG_FLAG_ZLIB_FINISHED 0x0020 |
+#define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */ |
+ /* 0x0004 unused */ |
+#define PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */ |
+ /* 0x0010 unused */ |
+ /* 0x0020 unused */ |
#define PNG_FLAG_ROW_INIT 0x0040 |
#define PNG_FLAG_FILLER_AFTER 0x0080 |
#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 |
@@ -327,25 +557,25 @@ |
#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 |
#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 |
#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 |
- /* 0x1000 unused */ |
- /* 0x2000 unused */ |
- /* 0x4000 unused */ |
-#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L |
-#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L |
-#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L |
-#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L |
-#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L |
-#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L |
-#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ |
-#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ |
-#define PNG_FLAG_BENIGN_ERRORS_WARN 0x800000L /* Added to libpng-1.4.0 */ |
- /* 0x1000000L unused */ |
- /* 0x2000000L unused */ |
- /* 0x4000000L unused */ |
- /* 0x8000000L unused */ |
- /* 0x10000000L unused */ |
- /* 0x20000000L unused */ |
- /* 0x40000000L unused */ |
+#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */ |
+#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */ |
+#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */ |
+/* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000 */ |
+/* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000 */ |
+#define PNG_FLAG_LIBRARY_MISMATCH 0x20000 |
+#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000 |
+#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000 |
+#define PNG_FLAG_BENIGN_ERRORS_WARN 0x100000 /* Added to libpng-1.4.0 */ |
+#define PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */ |
+#define PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */ |
+ /* 0x800000 unused */ |
+ /* 0x1000000 unused */ |
+ /* 0x2000000 unused */ |
+ /* 0x4000000 unused */ |
+ /* 0x8000000 unused */ |
+ /* 0x10000000 unused */ |
+ /* 0x20000000 unused */ |
+ /* 0x40000000 unused */ |
#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ |
PNG_FLAG_CRC_ANCILLARY_NOWARN) |
@@ -356,18 +586,6 @@ |
#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ |
PNG_FLAG_CRC_CRITICAL_MASK) |
-/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib |
- * can handle at once. This type need be no larger than 16 bits (so maximum of |
- * 65535), this define allows us to discover how big it is, but limited by the |
- * maximuum for png_size_t. The value can be overriden in a library build |
- * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably |
- * lower value (e.g. 255 works). A lower value may help memory usage (slightly) |
- * and may even improve performance on some systems (and degrade it on others.) |
- */ |
-#ifndef ZLIB_IO_MAX |
-# define ZLIB_IO_MAX ((uInt)-1) |
-#endif |
- |
/* Save typing and make code easier to understand */ |
#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ |
@@ -374,6 +592,17 @@ |
abs((int)((c1).green) - (int)((c2).green)) + \ |
abs((int)((c1).blue) - (int)((c2).blue))) |
+/* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255 |
+ * by dividing by 257 *with rounding*. This macro is exact for the given range. |
+ * See the discourse in pngrtran.c png_do_scale_16_to_8. The values in the |
+ * macro were established by experiment (modifying the added value). The macro |
+ * has a second variant that takes a value already scaled by 255 and divides by |
+ * 65535 - this has a maximum error of .502. Over the range 0..65535*65535 it |
+ * only gives off-by-one errors and only for 0.5% (1 in 200) of the values. |
+ */ |
+#define PNG_DIV65535(v24) (((v24) + 32895) >> 16) |
+#define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255) |
+ |
/* Added to libpng-1.2.6 JB */ |
#define PNG_ROWBYTES(pixel_bits, width) \ |
((pixel_bits) >= 8 ? \ |
@@ -421,74 +650,251 @@ |
#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED |
#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\ |
((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0)) |
-#else |
-PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp, |
- png_const_charp text)); |
#endif |
+/* else the corresponding function is defined below, inside the scope of the |
+ * cplusplus test. |
+ */ |
#endif |
-/* Constant strings for known chunk types. If you need to add a chunk, |
- * define the name here, and add an invocation of the macro wherever it's |
- * needed. |
+/* Constants for known chunk types. If you need to add a chunk, define the name |
+ * here. For historical reasons these constants have the form png_<name>; i.e. |
+ * the prefix is lower case. Please use decimal values as the parameters to |
+ * match the ISO PNG specification and to avoid relying on the C locale |
+ * interpretation of character values. |
+ * |
+ * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values |
+ * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string |
+ * to be generated if required. |
+ * |
+ * PNG_32b correctly produces a value shifted by up to 24 bits, even on |
+ * architectures where (int) is only 16 bits. |
*/ |
-#define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} |
-#define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} |
-#define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} |
-#define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} |
-#define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} |
-#define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} |
-#define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} |
-#define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} |
-#define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} |
-#define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} |
-#define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} |
-#define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} |
-#define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} |
-#define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} |
-#define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} |
-#define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} |
-#define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} |
-#define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115, 84, 69, 82, '\0'} |
-#define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} |
-#define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} |
-#define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} |
-#define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} |
+#define PNG_32b(b,s) ((png_uint_32)(b) << (s)) |
+#define PNG_U32(b1,b2,b3,b4) \ |
+ (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0)) |
+/* Constants for known chunk types. |
+ * |
+ * MAINTAINERS: If you need to add a chunk, define the name here. |
+ * For historical reasons these constants have the form png_<name>; i.e. |
+ * the prefix is lower case. Please use decimal values as the parameters to |
+ * match the ISO PNG specification and to avoid relying on the C locale |
+ * interpretation of character values. Please keep the list sorted. |
+ * |
+ * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk |
+ * type. In fact the specification does not express chunk types this way, |
+ * however using a 32-bit value means that the chunk type can be read from the |
+ * stream using exactly the same code as used for a 32-bit unsigned value and |
+ * can be examined far more efficiently (using one arithmetic compare). |
+ * |
+ * Prior to 1.5.6 the chunk type constants were expressed as C strings. The |
+ * libpng API still uses strings for 'unknown' chunks and a macro, |
+ * PNG_STRING_FROM_CHUNK, allows a string to be generated if required. Notice |
+ * that for portable code numeric values must still be used; the string "IHDR" |
+ * is not portable and neither is PNG_U32('I', 'H', 'D', 'R'). |
+ * |
+ * In 1.7.0 the definitions will be made public in png.h to avoid having to |
+ * duplicate the same definitions in application code. |
+ */ |
+#define png_IDAT PNG_U32( 73, 68, 65, 84) |
+#define png_IEND PNG_U32( 73, 69, 78, 68) |
+#define png_IHDR PNG_U32( 73, 72, 68, 82) |
+#define png_PLTE PNG_U32( 80, 76, 84, 69) |
+#define png_bKGD PNG_U32( 98, 75, 71, 68) |
+#define png_cHRM PNG_U32( 99, 72, 82, 77) |
+#define png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */ |
+#define png_gAMA PNG_U32(103, 65, 77, 65) |
+#define png_gIFg PNG_U32(103, 73, 70, 103) |
+#define png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */ |
+#define png_gIFx PNG_U32(103, 73, 70, 120) |
+#define png_hIST PNG_U32(104, 73, 83, 84) |
+#define png_iCCP PNG_U32(105, 67, 67, 80) |
+#define png_iTXt PNG_U32(105, 84, 88, 116) |
+#define png_oFFs PNG_U32(111, 70, 70, 115) |
+#define png_pCAL PNG_U32(112, 67, 65, 76) |
+#define png_pHYs PNG_U32(112, 72, 89, 115) |
+#define png_sBIT PNG_U32(115, 66, 73, 84) |
+#define png_sCAL PNG_U32(115, 67, 65, 76) |
+#define png_sPLT PNG_U32(115, 80, 76, 84) |
+#define png_sRGB PNG_U32(115, 82, 71, 66) |
+#define png_sTER PNG_U32(115, 84, 69, 82) |
+#define png_tEXt PNG_U32(116, 69, 88, 116) |
+#define png_tIME PNG_U32(116, 73, 77, 69) |
+#define png_tRNS PNG_U32(116, 82, 78, 83) |
+#define png_zTXt PNG_U32(122, 84, 88, 116) |
+/* The following will work on (signed char*) strings, whereas the get_uint_32 |
+ * macro will fail on top-bit-set values because of the sign extension. |
+ */ |
+#define PNG_CHUNK_FROM_STRING(s)\ |
+ PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3]) |
+ |
+/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is |
+ * signed and the argument is a (char[]) This macro will fail miserably on |
+ * systems where (char) is more than 8 bits. |
+ */ |
+#define PNG_STRING_FROM_CHUNK(s,c)\ |
+ (void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\ |
+ ((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c))) |
+ |
+/* Do the same but terminate with a null character. */ |
+#define PNG_CSTRING_FROM_CHUNK(s,c)\ |
+ (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0) |
+ |
+/* Test on flag values as defined in the spec (section 5.4): */ |
+#define PNG_CHUNK_ANCILLARY(c) (1 & ((c) >> 29)) |
+#define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c)) |
+#define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21)) |
+#define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13)) |
+#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5)) |
+ |
+/* Gamma values (new at libpng-1.5.4): */ |
+#define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */ |
+#define PNG_GAMMA_MAC_INVERSE 65909 |
+#define PNG_GAMMA_sRGB_INVERSE 45455 |
+ |
+/* Almost everything below is C specific; the #defines above can be used in |
+ * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot. |
+ */ |
+#ifndef PNG_VERSION_INFO_ONLY |
+ |
+#include "pngstruct.h" |
+#include "pnginfo.h" |
+ |
+/* Validate the include paths - the include path used to generate pnglibconf.h |
+ * must match that used in the build, or we must be using pnglibconf.h.prebuilt: |
+ */ |
+#if PNG_ZLIB_VERNUM != 0 && PNG_ZLIB_VERNUM != ZLIB_VERNUM |
+# error ZLIB_VERNUM != PNG_ZLIB_VERNUM \ |
+ "-I (include path) error: see the notes in pngpriv.h" |
+ /* This means that when pnglibconf.h was built the copy of zlib.h that it |
+ * used is not the same as the one being used here. Because the build of |
+ * libpng makes decisions to use inflateInit2 and inflateReset2 based on the |
+ * zlib version number and because this affects handling of certain broken |
+ * PNG files the -I directives must match. |
+ * |
+ * The most likely explanation is that you passed a -I in CFLAGS, this will |
+ * not work; all the preprocessor directories and in particular all the -I |
+ * directives must be in CPPFLAGS. |
+ */ |
+#endif |
+ |
+/* This is used for 16 bit gamma tables -- only the top level pointers are |
+ * const; this could be changed: |
+ */ |
+typedef const png_uint_16p * png_const_uint_16pp; |
+ |
+/* Added to libpng-1.5.7: sRGB conversion tables */ |
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ |
+ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) |
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED |
+PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]); |
+ /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value, |
+ * 0..65535. This table gives the closest 16-bit answers (no errors). |
+ */ |
+#endif |
+ |
+PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]); |
+PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]); |
+ |
+#define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\ |
+ ((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)) |
+ /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB |
+ * encoded value with maximum error 0.646365. Note that the input is not a |
+ * 16-bit value; it has been multiplied by 255! */ |
+#endif /* PNG_SIMPLIFIED_READ/WRITE */ |
+ |
+ |
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
#ifdef __cplusplus |
extern "C" { |
#endif /* __cplusplus */ |
-/* These functions are used internally in the code. They generally |
- * shouldn't be used unless you are writing code to add or replace some |
- * functionality in libpng. More information about most functions can |
- * be found in the files where the functions are located. |
+/* Internal functions; these are not exported from a DLL however because they |
+ * are used within several of the C source files they have to be C extern. |
+ * |
+ * All of these functions must be declared with PNG_INTERNAL_FUNCTION. |
*/ |
-/* Allocate memory for an internal libpng struct */ |
-PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)), |
- PNG_ALLOCATED); |
+/* Zlib support */ |
+#define PNG_UNEXPECTED_ZLIB_RETURN (-7) |
+PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret), |
+ PNG_EMPTY); |
+ /* Used by the zlib handling functions to ensure that z_stream::msg is always |
+ * set before they return. |
+ */ |
+#ifdef PNG_WRITE_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr, |
+ png_compression_bufferp *list),PNG_EMPTY); |
+ /* Free the buffer list used by the compressed write code. */ |
+#endif |
+ |
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && \ |
+ !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \ |
+ (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \ |
+ defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \ |
+ (defined(PNG_sCAL_SUPPORTED) && \ |
+ defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)) |
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr, |
+ double fp, png_const_charp text),PNG_EMPTY); |
+#endif |
+ |
+/* Check the user version string for compatibility, returns false if the version |
+ * numbers aren't compatible. |
+ */ |
+PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr, |
+ png_const_charp user_png_ver),PNG_EMPTY); |
+ |
+/* Internal base allocator - no messages, NULL on failure to allocate. This |
+ * does, however, call the application provided allocator and that could call |
+ * png_error (although that would be a bug in the application implementation.) |
+ */ |
+PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr, |
+ png_alloc_size_t size),PNG_ALLOCATED); |
+ |
+#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\ |
+ defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) |
+/* Internal array allocator, outputs no error or warning messages on failure, |
+ * just returns NULL. |
+ */ |
+PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr, |
+ int nelements, size_t element_size),PNG_ALLOCATED); |
+ |
+/* The same but an existing array is extended by add_elements. This function |
+ * also memsets the new elements to 0 and copies the old elements. The old |
+ * array is not freed or altered. |
+ */ |
+PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr, |
+ png_const_voidp array, int old_elements, int add_elements, |
+ size_t element_size),PNG_ALLOCATED); |
+#endif /* text, sPLT or unknown chunks */ |
+ |
+/* Magic to create a struct when there is no struct to call the user supplied |
+ * memory allocators. Because error handling has not been set up the memory |
+ * handlers can't safely call png_error, but this is an obscure and undocumented |
+ * restriction so libpng has to assume that the 'free' handler, at least, might |
+ * call png_error. |
+ */ |
+PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct, |
+ (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, |
+ png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn, |
+ png_free_ptr free_fn),PNG_ALLOCATED); |
+ |
/* Free memory from internal libpng struct */ |
-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr), |
+ PNG_EMPTY); |
-PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct_2, |
- PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)), |
- PNG_ALLOCATED); |
-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, |
- png_free_ptr free_fn, png_voidp mem_ptr)); |
+/* Free an allocated jmp_buf (always succeeds) */ |
+PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY); |
-/* Free any memory that info_ptr points to and reset struct. */ |
-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
- |
/* Function to allocate memory for zlib. PNGAPI is disallowed. */ |
-PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items, |
- uInt size)),PNG_ALLOCATED); |
+PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size), |
+ PNG_ALLOCATED); |
/* Function to free memory for zlib. PNGAPI is disallowed. */ |
-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY); |
/* Next four functions are used internally as callbacks. PNGCBAPI is required |
* but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to |
@@ -495,67 +901,63 @@ |
* PNGCBAPI at 1.5.0 |
*/ |
-PNG_EXTERN void PNGCBAPI png_default_read_data PNGARG((png_structp png_ptr, |
- png_bytep data, png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr, |
+ png_bytep data, png_size_t length),PNG_EMPTY); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
-PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr, |
- png_bytep buffer, png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr, |
+ png_bytep buffer, png_size_t length),PNG_EMPTY); |
#endif |
-PNG_EXTERN void PNGCBAPI png_default_write_data PNGARG((png_structp png_ptr, |
- png_bytep data, png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr, |
+ png_bytep data, png_size_t length),PNG_EMPTY); |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
# ifdef PNG_STDIO_SUPPORTED |
-PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr), |
+ PNG_EMPTY); |
# endif |
#endif |
/* Reset the CRC variable */ |
-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY); |
/* Write the "data" buffer to whatever output you are using */ |
-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, |
- png_const_bytep data, png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr, |
+ png_const_bytep data, png_size_t length),PNG_EMPTY); |
/* Read and check the PNG file signature */ |
-PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
/* Read the chunk header (length + type name) */ |
-PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr), |
+ PNG_EMPTY); |
/* Read data from whatever input you are using into the "data" buffer */ |
-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, |
- png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data, |
+ png_size_t length),PNG_EMPTY); |
/* Read bytes into buf, and update png_ptr->crc */ |
-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, |
- png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf, |
+ png_uint_32 length),PNG_EMPTY); |
-/* Decompress data in a chunk that uses compression */ |
-#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ |
- defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) |
-PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr, |
- int comp_type, png_size_t chunklength, png_size_t prefix_length, |
- png_size_t *data_length)); |
-#endif |
- |
/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ |
-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); |
+PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr, |
+ png_uint_32 skip),PNG_EMPTY); |
/* Read the CRC from the file and compare it to the libpng calculated CRC */ |
-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY); |
/* Calculate the CRC over a section of data. Note that we are only |
* passing a maximum of 64K on systems that have this as a memory limit, |
* since this is the maximum buffer size we can specify. |
*/ |
-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, |
- png_const_bytep ptr, png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr, |
+ png_const_bytep ptr, png_size_t length),PNG_EMPTY); |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY); |
#endif |
/* Write various chunks */ |
@@ -563,152 +965,165 @@ |
/* Write the IHDR chunk, and update the png_struct with the necessary |
* information. |
*/ |
-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, |
- png_uint_32 height, |
- int bit_depth, int color_type, int compression_method, int filter_method, |
- int interlace_method)); |
+PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr, |
+ png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, |
+ int compression_method, int filter_method, int interlace_method),PNG_EMPTY); |
-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, |
- png_const_colorp palette, png_uint_32 num_pal)); |
+PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr, |
+ png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY); |
-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, |
- png_size_t length)); |
+PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr, |
+ png_const_bytep row_data, png_alloc_size_t row_data_length, int flush), |
+ PNG_EMPTY); |
-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY); |
#ifdef PNG_WRITE_gAMA_SUPPORTED |
-# ifdef PNG_FLOATING_POINT_SUPPORTED |
-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); |
+PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr, |
+ png_fixed_point file_gamma),PNG_EMPTY); |
# endif |
-# ifdef PNG_FIXED_POINT_SUPPORTED |
-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, |
- png_fixed_point file_gamma)); |
-# endif |
-#endif |
#ifdef PNG_WRITE_sBIT_SUPPORTED |
-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, |
- png_const_color_8p sbit, int color_type)); |
+PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr, |
+ png_const_color_8p sbit, int color_type),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_cHRM_SUPPORTED |
-# ifdef PNG_FLOATING_POINT_SUPPORTED |
-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, |
- double white_x, double white_y, |
- double red_x, double red_y, double green_x, double green_y, |
- double blue_x, double blue_y)); |
+PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr, |
+ const png_xy *xy), PNG_EMPTY); |
+ /* The xy value must have been previously validated */ |
# endif |
-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, |
- png_fixed_point int_white_x, png_fixed_point int_white_y, |
- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
- png_fixed_point int_blue_y)); |
-#endif |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, |
- int intent)); |
+PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr, |
+ int intent),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, |
- png_const_charp name, int compression_type, |
- png_const_charp profile, int proflen)); |
- /* Note to maintainer: profile should be png_bytep */ |
+PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr, |
+ png_const_charp name, png_const_bytep profile), PNG_EMPTY); |
+ /* The profile must have been previously validated for correctness, the |
+ * length comes from the first four bytes. Only the base, deflate, |
+ * compression is supported. |
+ */ |
#endif |
#ifdef PNG_WRITE_sPLT_SUPPORTED |
-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, |
- png_const_sPLT_tp palette)); |
+PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr, |
+ png_const_sPLT_tp palette),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_tRNS_SUPPORTED |
-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, |
+PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr, |
png_const_bytep trans, png_const_color_16p values, int number, |
- int color_type)); |
+ int color_type),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_bKGD_SUPPORTED |
-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, |
- png_const_color_16p values, int color_type)); |
+PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr, |
+ png_const_color_16p values, int color_type),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_hIST_SUPPORTED |
-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, |
- png_const_uint_16p hist, int num_hist)); |
+PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr, |
+ png_const_uint_16p hist, int num_hist),PNG_EMPTY); |
#endif |
-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, |
- png_const_charp key, png_charpp new_key)); |
-#endif |
- |
+/* Chunks that have keywords */ |
#ifdef PNG_WRITE_tEXt_SUPPORTED |
-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key, |
- png_const_charp text, png_size_t text_len)); |
+PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr, |
+ png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_zTXt_SUPPORTED |
-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key, |
- png_const_charp text, png_size_t text_len, int compression)); |
+PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp |
+ key, png_const_charp text, png_size_t text_len, int compression),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_iTXt_SUPPORTED |
-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, |
+PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr, |
int compression, png_const_charp key, png_const_charp lang, |
- png_const_charp lang_key, png_const_charp text)); |
+ png_const_charp lang_key, png_const_charp text),PNG_EMPTY); |
#endif |
#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */ |
-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_const_textp text_ptr, int num_text)); |
+PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr, |
+ png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_oFFs_SUPPORTED |
-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, |
- png_int_32 x_offset, png_int_32 y_offset, int unit_type)); |
+PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr, |
+ png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_pCAL_SUPPORTED |
-PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, |
- png_int_32 X0, png_int_32 X1, int type, int nparams, |
- png_const_charp units, png_charpp params)); |
+PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr, |
+ png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, |
+ png_const_charp units, png_charpp params),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_pHYs_SUPPORTED |
-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, |
+PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr, |
png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, |
- int unit_type)); |
+ int unit_type),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_tIME_SUPPORTED |
-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, |
- png_const_timep mod_time)); |
+PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr, |
+ png_const_timep mod_time),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_sCAL_SUPPORTED |
-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, |
- int unit, png_const_charp width, png_const_charp height)); |
+PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr, |
+ int unit, png_const_charp width, png_const_charp height),PNG_EMPTY); |
#endif |
/* Called when finished processing a row of data */ |
-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr), |
+ PNG_EMPTY); |
/* Internal use only. Called before first row of data */ |
-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr), |
+ PNG_EMPTY); |
-/* Combine a row of data, dealing with alpha, etc. if requested */ |
-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, |
- int mask)); |
+/* Combine a row of data, dealing with alpha, etc. if requested. 'row' is an |
+ * array of png_ptr->width pixels. If the image is not interlaced or this |
+ * is the final pass this just does a memcpy, otherwise the "display" flag |
+ * is used to determine whether to copy pixels that are not in the current pass. |
+ * |
+ * Because 'png_do_read_interlace' (below) replicates pixels this allows this |
+ * function to achieve the documented 'blocky' appearance during interlaced read |
+ * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row' |
+ * are not changed if they are not in the current pass, when display is 0. |
+ * |
+ * 'display' must be 0 or 1, otherwise the memcpy will be done regardless. |
+ * |
+ * The API always reads from the png_struct row buffer and always assumes that |
+ * it is full width (png_do_read_interlace has already been called.) |
+ * |
+ * This function is only ever used to write to row buffers provided by the |
+ * caller of the relevant libpng API and the row must have already been |
+ * transformed by the read transformations. |
+ * |
+ * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed |
+ * bitmasks for use within the code, otherwise runtime generated masks are used. |
+ * The default is compile time masks. |
+ */ |
+#ifndef PNG_USE_COMPILE_TIME_MASKS |
+# define PNG_USE_COMPILE_TIME_MASKS 1 |
+#endif |
+PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr, |
+ png_bytep row, int display),PNG_EMPTY); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
-/* Expand an interlaced row */ |
-/* OLD pre-1.0.9 interface: |
-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, |
- png_bytep row, int pass, png_uint_32 transformations)); |
+/* Expand an interlaced row: the 'row_info' describes the pass data that has |
+ * been read in and must correspond to the pixels in 'row', the pixels are |
+ * expanded (moved apart) in 'row' to match the final layout, when doing this |
+ * the pixels are *replicated* to the intervening space. This is essential for |
+ * the correct operation of png_combine_row, above. |
*/ |
-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_do_read_interlace,(png_row_infop row_info, |
+ png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY); |
#endif |
/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ |
@@ -715,387 +1130,631 @@ |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Grab pixels out of a row for an interlaced pass */ |
-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, |
- png_bytep row, int pass)); |
+PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info, |
+ png_bytep row, int pass),PNG_EMPTY); |
#endif |
-/* Unfilter a row */ |
-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, |
- png_row_infop row_info, png_bytep row, png_const_bytep prev_row, |
- int filter)); |
+/* Unfilter a row: check the filter value before calling this, there is no point |
+ * calling it for PNG_FILTER_VALUE_NONE. |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info, |
+ png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop |
+ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); |
+ |
/* Choose the best filter to use and filter the row data */ |
-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, |
- png_row_infop row_info)); |
+PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr, |
+ png_row_infop row_info),PNG_EMPTY); |
-/* Write out the filtered row. */ |
-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, |
- png_bytep filtered_row)); |
+#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr, |
+ png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY); |
+ /* Read 'avail_out' bytes of data from the IDAT stream. If the output buffer |
+ * is NULL the function checks, instead, for the end of the stream. In this |
+ * case a benign error will be issued if the stream end is not found or if |
+ * extra data has to be consumed. |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+ /* This cleans up when the IDAT LZ stream does not end when the last image |
+ * byte is read; there is still some pending input. |
+ */ |
+ |
+PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr), |
+ PNG_EMPTY); |
/* Finish a row while reading, dealing with interlacing passes, etc. */ |
-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); |
+#endif |
/* Initialize the row buffers, etc. */ |
-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY); |
+ |
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
/* Optional call to update the users info structure */ |
-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+#endif |
/* These are the functions that do the transformations */ |
#ifdef PNG_READ_FILLER_SUPPORTED |
-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, |
- png_bytep row, png_uint_32 filler, png_uint_32 flags)); |
+PNG_INTERNAL_FUNCTION(void,png_do_read_filler,(png_row_infop row_info, |
+ png_bytep row, png_uint_32 filler, png_uint_32 flags),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED |
-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_read_swap_alpha,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED |
-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_write_swap_alpha,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_read_invert_alpha,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED |
-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_write_invert_alpha,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
-PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, |
- png_bytep row, png_uint_32 flags)); |
+PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info, |
+ png_bytep row, int at_start),PNG_EMPTY); |
#endif |
#ifdef PNG_16BIT_SUPPORTED |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ |
defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, |
- png_row_infop row_info, png_bytep row)); |
+PNG_INTERNAL_FUNCTION(int,png_do_rgb_to_gray,(png_structrp png_ptr, |
+ png_row_infop row_info, png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_gray_to_rgb,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_PACK_SUPPORTED |
-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_unpack,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_SHIFT_SUPPORTED |
-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_color_8p sig_bits)); |
+PNG_INTERNAL_FUNCTION(void,png_do_unshift,(png_row_infop row_info, |
+ png_bytep row, png_const_color_8p sig_bits),PNG_EMPTY); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
-#ifdef PNG_READ_16_TO_8_SUPPORTED |
-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_scale_16_to_8,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
+#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_chop,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
+#endif |
+ |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
-PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info, |
+PNG_INTERNAL_FUNCTION(void,png_do_quantize,(png_row_infop row_info, |
png_bytep row, png_const_bytep palette_lookup, |
- png_const_bytep quantize_lookup)); |
+ png_const_bytep quantize_lookup),PNG_EMPTY); |
# ifdef PNG_CORRECT_PALETTE_SUPPORTED |
-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, |
- png_colorp palette, int num_palette)); |
+PNG_INTERNAL_FUNCTION(void,png_correct_palette,(png_structrp png_ptr, |
+ png_colorp palette, int num_palette),PNG_EMPTY); |
# endif |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_PACK_SUPPORTED |
-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, |
- png_bytep row, png_uint_32 bit_depth)); |
+PNG_INTERNAL_FUNCTION(void,png_do_pack,(png_row_infop row_info, |
+ png_bytep row, png_uint_32 bit_depth),PNG_EMPTY); |
#endif |
#ifdef PNG_WRITE_SHIFT_SUPPORTED |
-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_color_8p bit_depth)); |
+PNG_INTERNAL_FUNCTION(void,png_do_shift,(png_row_infop row_info, |
+ png_bytep row, png_const_color_8p bit_depth),PNG_EMPTY); |
#endif |
-#ifdef PNG_READ_BACKGROUND_SUPPORTED |
-# ifdef PNG_READ_GAMMA_SUPPORTED |
-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_color_16p trans_color, |
- png_const_color_16p background, png_const_color_16p background_1, |
- png_const_bytep gamma_table, png_const_bytep gamma_from_1, |
- png_const_bytep gamma_to_1, png_const_uint_16pp gamma_16, |
- png_const_uint_16pp gamma_16_from_1, png_const_uint_16pp gamma_16_to_1, |
- int gamma_shift)); |
-# else |
-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_color_16p trans_color, |
- png_const_color_16p background)); |
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
+ defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
+PNG_INTERNAL_FUNCTION(void,png_do_compose,(png_row_infop row_info, |
+ png_bytep row, png_structrp png_ptr),PNG_EMPTY); |
# endif |
-#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_bytep gamma_table, |
- png_const_uint_16pp gamma_16_table, int gamma_shift)); |
+PNG_INTERNAL_FUNCTION(void,png_do_gamma,(png_row_infop row_info, |
+ png_bytep row, png_structrp png_ptr),PNG_EMPTY); |
#endif |
+#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_encode_alpha,(png_row_infop row_info, |
+ png_bytep row, png_structrp png_ptr),PNG_EMPTY); |
+#endif |
+ |
#ifdef PNG_READ_EXPAND_SUPPORTED |
-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, |
+PNG_INTERNAL_FUNCTION(void,png_do_expand_palette,(png_row_infop row_info, |
png_bytep row, png_const_colorp palette, png_const_bytep trans, |
- int num_trans)); |
-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, |
- png_bytep row, png_const_color_16p trans_color)); |
+ int num_trans),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_do_expand,(png_row_infop row_info, |
+ png_bytep row, png_const_color_16p trans_color),PNG_EMPTY); |
#endif |
+#ifdef PNG_READ_EXPAND_16_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_expand_16,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
+#endif |
+ |
/* The following decodes the appropriate chunks, and does error correction, |
* then calls the appropriate callback for the chunk if it is valid. |
*/ |
/* Decode the IHDR chunk */ |
-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#ifdef PNG_READ_bKGD_SUPPORTED |
-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
-PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#ifdef PNG_READ_iTXt_SUPPORTED |
-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
-PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#ifdef PNG_READ_sRGB_SUPPORTED |
-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
- png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
#endif |
-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_uint_32 length)); |
+PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_structrp png_ptr, |
+ png_uint_32 chunk_name),PNG_EMPTY); |
-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, |
- png_const_bytep chunk_name)); |
+#ifdef PNG_READ_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY); |
+ /* This is the function that gets called for unknown chunks. The 'keep' |
+ * argument is either non-zero for a known chunk that has been set to be |
+ * handled as unknown or zero for an unknown chunk. By default the function |
+ * just skips the chunk or errors out if it is critical. |
+ */ |
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
+PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling, |
+ (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY); |
+ /* Exactly as the API png_handle_as_unknown() except that the argument is a |
+ * 32-bit chunk name, not a string. |
+ */ |
+#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */ |
+#endif /* PNG_READ_SUPPORTED */ |
+ |
/* Handle the transformations for reading and writing */ |
-PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); |
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr, |
+ png_row_infop row_info),PNG_EMPTY); |
+#endif |
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr, |
+ png_row_infop row_info),PNG_EMPTY); |
+#endif |
-PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); |
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, |
- png_uint_32 length)); |
-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, |
- png_bytep buffer, png_size_t buffer_length)); |
-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, |
- png_bytep buffer, png_size_t buffer_length)); |
-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); |
-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_uint_32 length)); |
-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); |
-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
-PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_crc_skip,(png_structrp png_ptr, |
+ png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_crc_finish,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr, |
+ png_bytep buffer, png_size_t buffer_length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr, |
+ png_bytep buffer, png_size_t buffer_length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr, |
+ png_bytep row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr), |
+ PNG_EMPTY); |
# ifdef PNG_READ_tEXt_SUPPORTED |
-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_uint_32 length)); |
-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
# endif |
# ifdef PNG_READ_zTXt_SUPPORTED |
-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_uint_32 length)); |
-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
# endif |
# ifdef PNG_READ_iTXt_SUPPORTED |
-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_uint_32 length)); |
-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, |
- png_infop info_ptr)); |
+PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr, |
+ png_inforp info_ptr),PNG_EMPTY); |
# endif |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, |
- png_bytep row)); |
-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, |
- png_bytep row)); |
+PNG_INTERNAL_FUNCTION(void,png_do_read_intrapixel,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_do_write_intrapixel,(png_row_infop row_info, |
+ png_bytep row),PNG_EMPTY); |
#endif |
-/* Added at libpng version 1.4.0 */ |
-#ifdef PNG_CHECK_cHRM_SUPPORTED |
-PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr, |
- png_fixed_point int_white_x, png_fixed_point int_white_y, |
- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
- png_fixed_point int_blue_y)); |
+/* Added at libpng version 1.6.0 */ |
+#ifdef PNG_GAMMA_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, png_fixed_point gAMA), PNG_EMPTY); |
+ /* Set the colorspace gamma with a value provided by the application or by |
+ * the gAMA chunk on read. The value will override anything set by an ICC |
+ * profile. |
+ */ |
+ |
+PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr, |
+ png_inforp info_ptr), PNG_EMPTY); |
+ /* Synchronize the info 'valid' flags with the colorspace */ |
+ |
+PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr, |
+ png_inforp info_ptr), PNG_EMPTY); |
+ /* Copy the png_struct colorspace to the info_struct and call the above to |
+ * synchronize the flags. Checks for NULL info_ptr and does nothing. |
+ */ |
#endif |
-#ifdef PNG_CHECK_cHRM_SUPPORTED |
-/* Added at libpng version 1.2.34 and 1.4.0 */ |
-/* Currently only used by png_check_cHRM_fixed */ |
-PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2, |
- unsigned long *hi_product, unsigned long *lo_product)); |
+/* Added at libpng version 1.4.0 */ |
+#ifdef PNG_COLORSPACE_SUPPORTED |
+/* These internal functions are for maintaining the colorspace structure within |
+ * a png_info or png_struct (or, indeed, both). |
+ */ |
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_chromaticities, |
+ (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy, |
+ int preferred), PNG_EMPTY); |
+ |
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints, |
+ (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ, |
+ int preferred), PNG_EMPTY); |
+ |
+#ifdef PNG_sRGB_SUPPORTED |
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, int intent), PNG_EMPTY); |
+ /* This does set the colorspace gAMA and cHRM values too, but doesn't set the |
+ * flags to write them, if it returns false there was a problem and an error |
+ * message has already been output (but the colorspace may still need to be |
+ * synced to record the invalid flag). |
+ */ |
+#endif /* sRGB */ |
+ |
+#ifdef PNG_iCCP_SUPPORTED |
+PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, png_const_charp name, |
+ png_uint_32 profile_length, png_const_bytep profile, int color_type), |
+ PNG_EMPTY); |
+ /* The 'name' is used for information only */ |
+ |
+/* Routines for checking parts of an ICC profile. */ |
+PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, png_const_charp name, |
+ png_uint_32 profile_length), PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, png_const_charp name, |
+ png_uint_32 profile_length, |
+ png_const_bytep profile /* first 132 bytes only */, int color_type), |
+ PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr, |
+ png_colorspacerp colorspace, png_const_charp name, |
+ png_uint_32 profile_length, |
+ png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY); |
+#ifdef PNG_sRGB_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,( |
+ png_const_structrp png_ptr, png_colorspacerp colorspace, |
+ png_const_bytep profile, uLong adler), PNG_EMPTY); |
+ /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may |
+ * be zero to indicate that it is not available. It is used, if provided, |
+ * as a fast check on the profile when checking to see if it is sRGB. |
+ */ |
#endif |
+#endif /* iCCP */ |
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_colorspace_set_rgb_coefficients, |
+ (png_structrp png_ptr), PNG_EMPTY); |
+ /* Set the rgb_to_gray coefficients from the colorspace Y values */ |
+#endif /* READ_RGB_TO_GRAY */ |
+#endif /* COLORSPACE */ |
+ |
/* Added at libpng version 1.4.0 */ |
-PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr, |
+PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
- int filter_type)); |
+ int filter_type),PNG_EMPTY); |
-/* Free all memory used by the read (old method - NOT DLL EXPORTED) */ |
-PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr, |
- png_infop info_ptr, png_infop end_info_ptr)); |
+/* Added at libpng version 1.5.10 */ |
+#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ |
+ defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) |
+PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes, |
+ (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY); |
+#endif |
-/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ |
-PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr)); |
- |
-#ifdef USE_FAR_KEYWORD /* memory model conversion function */ |
-PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr, |
- int check)); |
-#endif /* USE_FAR_KEYWORD */ |
- |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) |
-PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr, |
+PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr, |
png_const_charp name),PNG_NORETURN); |
#endif |
+/* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite |
+ * the end. Always leaves the buffer nul terminated. Never errors out (and |
+ * there is no error code.) |
+ */ |
+PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize, |
+ size_t pos, png_const_charp string),PNG_EMPTY); |
+ |
+/* Various internal functions to handle formatted warning messages, currently |
+ * only implemented for warnings. |
+ */ |
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) |
+/* Utility to dump an unsigned value into a buffer, given a start pointer and |
+ * and end pointer (which should point just *beyond* the end of the buffer!) |
+ * Returns the pointer to the start of the formatted string. This utility only |
+ * does unsigned values. |
+ */ |
+PNG_INTERNAL_FUNCTION(png_charp,png_format_number,(png_const_charp start, |
+ png_charp end, int format, png_alloc_size_t number),PNG_EMPTY); |
+ |
+/* Convenience macro that takes an array: */ |
+#define PNG_FORMAT_NUMBER(buffer,format,number) \ |
+ png_format_number(buffer, buffer + (sizeof buffer), format, number) |
+ |
+/* Suggested size for a number buffer (enough for 64 bits and a sign!) */ |
+#define PNG_NUMBER_BUFFER_SIZE 24 |
+ |
+/* These are the integer formats currently supported, the name is formed from |
+ * the standard printf(3) format string. |
+ */ |
+#define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */ |
+#define PNG_NUMBER_FORMAT_02u 2 |
+#define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */ |
+#define PNG_NUMBER_FORMAT_02d 2 |
+#define PNG_NUMBER_FORMAT_x 3 |
+#define PNG_NUMBER_FORMAT_02x 4 |
+#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */ |
+#endif |
+ |
+#ifdef PNG_WARNINGS_SUPPORTED |
+/* New defines and members adding in libpng-1.5.4 */ |
+# define PNG_WARNING_PARAMETER_SIZE 32 |
+# define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */ |
+ |
+/* An l-value of this type has to be passed to the APIs below to cache the |
+ * values of the parameters to a formatted warning message. |
+ */ |
+typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][ |
+ PNG_WARNING_PARAMETER_SIZE]; |
+ |
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p, |
+ int number, png_const_charp string),PNG_EMPTY); |
+ /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters, |
+ * including the trailing '\0'. |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter_unsigned, |
+ (png_warning_parameters p, int number, int format, png_alloc_size_t value), |
+ PNG_EMPTY); |
+ /* Use png_alloc_size_t because it is an unsigned type as big as any we |
+ * need to output. Use the following for a signed value. |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_warning_parameter_signed, |
+ (png_warning_parameters p, int number, int format, png_int_32 value), |
+ PNG_EMPTY); |
+ |
+PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr, |
+ png_warning_parameters p, png_const_charp message),PNG_EMPTY); |
+ /* 'message' follows the X/Open approach of using @1, @2 to insert |
+ * parameters previously supplied using the above functions. Errors in |
+ * specifying the parameters will simply result in garbage substitutions. |
+ */ |
+#endif |
+ |
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
+/* Application errors (new in 1.6); use these functions (declared below) for |
+ * errors in the parameters or order of API function calls on read. The |
+ * 'warning' should be used for an error that can be handled completely; the |
+ * 'error' for one which can be handled safely but which may lose application |
+ * information or settings. |
+ * |
+ * By default these both result in a png_error call prior to release, while in a |
+ * released version the 'warning' is just a warning. However if the application |
+ * explicitly disables benign errors (explicitly permitting the code to lose |
+ * information) they both turn into warnings. |
+ * |
+ * If benign errors aren't supported they end up as the corresponding base call |
+ * (png_warning or png_error.) |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr, |
+ png_const_charp message),PNG_EMPTY); |
+ /* The application provided invalid parameters to an API function or called |
+ * an API function at the wrong time, libpng can completely recover. |
+ */ |
+ |
+PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr, |
+ png_const_charp message),PNG_EMPTY); |
+ /* As above but libpng will ignore the call, or attempt some other partial |
+ * recovery from the error. |
+ */ |
+#else |
+# define png_app_warning(pp,s) png_warning(pp,s) |
+# define png_app_error(pp,s) png_error(pp,s) |
+#endif |
+ |
+PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr, |
+ png_const_charp message, int error),PNG_EMPTY); |
+ /* Report a recoverable issue in chunk data. On read this is used to report |
+ * a problem found while reading a particular chunk and the |
+ * png_chunk_benign_error or png_chunk_warning function is used as |
+ * appropriate. On write this is used to report an error that comes from |
+ * data set via an application call to a png_set_ API and png_app_error or |
+ * png_app_warning is used as appropriate. |
+ * |
+ * The 'error' parameter must have one of the following values: |
+ */ |
+#define PNG_CHUNK_WARNING 0 /* never an error */ |
+#define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */ |
+#define PNG_CHUNK_ERROR 2 /* always an error */ |
+ |
/* ASCII to FP interfaces, currently only implemented if sCAL |
* support is required. |
*/ |
-#if defined(PNG_READ_sCAL_SUPPORTED) |
+#if defined(PNG_sCAL_SUPPORTED) |
/* MAX_DIGITS is actually the maximum number of characters in an sCAL |
* width or height, derived from the precision (number of significant |
- * digits - a build time settable option) and assumpitions about the |
+ * digits - a build time settable option) and assumptions about the |
* maximum ridiculous exponent. |
*/ |
#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
-PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii, |
- png_size_t size, double fp, unsigned int precision)); |
+PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr, |
+ png_charp ascii, png_size_t size, double fp, unsigned int precision), |
+ PNG_EMPTY); |
#endif /* FLOATING_POINT */ |
#ifdef PNG_FIXED_POINT_SUPPORTED |
-PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr, |
- png_charp ascii, png_size_t size, png_fixed_point fp)); |
+PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr, |
+ png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY); |
#endif /* FIXED_POINT */ |
-#endif /* READ_sCAL */ |
+#endif /* sCAL */ |
#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) |
/* An internal API to validate the format of a floating point number. |
@@ -1119,7 +1778,7 @@ |
* NOTE: The dangling E problem. |
* There is a PNG valid floating point number in the following: |
* |
- * PNG floating point numb1.ers are not greedy. |
+ * PNG floating point numbers are not greedy. |
* |
* Working this out requires *TWO* character lookahead (because of the |
* sign), the parser does not do this - it will fail at the 'r' - this |
@@ -1137,9 +1796,19 @@ |
#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */ |
#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */ |
#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */ |
+ |
+/* These three values don't affect the parser. They are set but not used. |
+ */ |
#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */ |
-#define PNG_FP_INVALID 128 /* Available for callers as a distinct value */ |
+#define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */ |
+#define PNG_FP_NONZERO 256 /* A non-zero value */ |
+#define PNG_FP_STICKY 448 /* The above three flags */ |
+/* This is available for the caller to store in 'state' if required. Do not |
+ * call the parser after setting it (the parser sometimes clears it.) |
+ */ |
+#define PNG_FP_INVALID 512 /* Available for callers as a distinct value */ |
+ |
/* Result codes for the parser (boolean - true meants ok, false means |
* not ok yet.) |
*/ |
@@ -1146,14 +1815,28 @@ |
#define PNG_FP_MAYBE 0 /* The number may be valid in the future */ |
#define PNG_FP_OK 1 /* The number is valid */ |
-/* The actual parser. This can be called repeatedly, it updates |
+/* Tests on the sticky non-zero and negative flags. To pass these checks |
+ * the state must also indicate that the whole number is valid - this is |
+ * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this |
+ * is equivalent to PNG_FP_OK above.) |
+ */ |
+#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO) |
+ /* NZ_MASK: the string is valid and a non-zero negative value */ |
+#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO) |
+ /* Z MASK: the string is valid and a non-zero value. */ |
+ /* PNG_FP_SAW_DIGIT: the string is valid. */ |
+#define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT) |
+#define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK) |
+#define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK) |
+ |
+/* The actual parser. This can be called repeatedly. It updates |
* the index into the string and the state variable (which must |
- * be initialzed to 0). It returns a result code, as above. There |
+ * be initialized to 0). It returns a result code, as above. There |
* is no point calling the parser any more if it fails to advance to |
* the end of the string - it is stuck on an invalid character (or |
* terminated by '\0'). |
* |
- * Note that the pointer will consume an E or even an E+ then leave |
+ * Note that the pointer will consume an E or even an E+ and then leave |
* a 'maybe' state even though a preceding integer.fraction is valid. |
* The PNG_FP_WAS_VALID flag indicates that a preceding substring was |
* a valid number. It's possible to recover from this by calling |
@@ -1161,14 +1844,17 @@ |
* that omits the last character (i.e. set the size to the index of |
* the problem character.) This has not been tested within libpng. |
*/ |
-PNG_EXTERN int png_check_fp_number PNGARG((png_const_charp string, |
- png_size_t size, int *statep, png_size_tp whereami)); |
+PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string, |
+ png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY); |
/* This is the same but it checks a complete string and returns true |
- * only if it just contains a floating point number. |
+ * only if it just contains a floating point number. As of 1.5.4 this |
+ * function also returns the state at the end of parsing the number if |
+ * it was valid (otherwise it returns 0.) This can be used for testing |
+ * for negative or zero values using the sticky flag. |
*/ |
-PNG_EXTERN int png_check_fp_string PNGARG((png_const_charp string, |
- png_size_t size)); |
+PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string, |
+ png_size_t size),PNG_EMPTY); |
#endif /* pCAL || sCAL */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) ||\ |
@@ -1179,31 +1865,39 @@ |
* for overflow, true (1) if no overflow, in which case *res |
* holds the result. |
*/ |
-PNG_EXTERN int png_muldiv PNGARG((png_fixed_point_p res, png_fixed_point a, |
- png_int_32 times, png_int_32 div)); |
+PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a, |
+ png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) |
/* Same deal, but issue a warning on overflow and return 0. */ |
-PNG_EXTERN png_fixed_point png_muldiv_warn PNGARG((png_structp png_ptr, |
- png_fixed_point a, png_int_32 times, png_int_32 div)); |
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn, |
+ (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by, |
+ png_int_32 divided_by),PNG_EMPTY); |
#endif |
-#ifdef PNG_READ_GAMMA_SUPPORTED |
+#ifdef PNG_GAMMA_SUPPORTED |
/* Calculate a reciprocal - used for gamma values. This returns |
- * 0 if the argument is 0 in order to maintain an undefined value, |
+ * 0 if the argument is 0 in order to maintain an undefined value; |
* there are no warnings. |
*/ |
-PNG_EXTERN png_fixed_point png_reciprocal PNGARG((png_fixed_point a)); |
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a), |
+ PNG_EMPTY); |
+#ifdef PNG_READ_GAMMA_SUPPORTED |
/* The same but gives a reciprocal of the product of two fixed point |
* values. Accuracy is suitable for gamma calculations but this is |
- * not exact - use png_muldiv for that. |
+ * not exact - use png_muldiv for that. Only required at present on read. |
*/ |
-PNG_EXTERN png_fixed_point png_reciprocal2 PNGARG((png_fixed_point a, |
- png_fixed_point b)); |
+PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a, |
+ png_fixed_point b),PNG_EMPTY); |
#endif |
+/* Return true if the gamma value is significantly different from 1.0 */ |
+PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value), |
+ PNG_EMPTY); |
+#endif |
+ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Internal fixed point gamma correction. These APIs are called as |
* required to convert single values - they don't need to be fast, |
@@ -1212,20 +1906,94 @@ |
* While the input is an 'unsigned' value it must actually be the |
* correct bit value - 0..255 or 0..65535 as required. |
*/ |
-PNG_EXTERN png_uint_16 png_gamma_correct PNGARG((png_structp png_ptr, |
- unsigned int value, png_fixed_point gamma)); |
-PNG_EXTERN int png_gamma_significant PNGARG((png_fixed_point gamma)); |
-PNG_EXTERN png_uint_16 png_gamma_16bit_correct PNGARG((unsigned int value, |
- png_fixed_point gamma)); |
-PNG_EXTERN png_byte png_gamma_8bit_correct PNGARG((unsigned int value, |
- png_fixed_point gamma)); |
-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr, |
- int bit_depth)); |
+PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr, |
+ unsigned int value, png_fixed_point gamma_value),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value, |
+ png_fixed_point gamma_value),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value, |
+ png_fixed_point gamma_value),PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr), |
+ PNG_EMPTY); |
+PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr, |
+ int bit_depth),PNG_EMPTY); |
#endif |
-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
+/* SIMPLIFIED READ/WRITE SUPPORT */ |
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\ |
+ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) |
+/* The internal structure that png_image::opaque points to. */ |
+typedef struct png_control |
+{ |
+ png_structp png_ptr; |
+ png_infop info_ptr; |
+ png_voidp error_buf; /* Always a jmp_buf at present. */ |
+ png_const_bytep memory; /* Memory buffer. */ |
+ png_size_t size; /* Size of the memory buffer. */ |
+ unsigned int for_write :1; /* Otherwise it is a read structure */ |
+ unsigned int owned_file :1; /* We own the file in io_ptr */ |
+} png_control; |
+ |
+/* Return the pointer to the jmp_buf from a png_control: necessary because C |
+ * does not reveal the type of the elements of jmp_buf. |
+ */ |
+#ifdef __cplusplus |
+# define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0]) |
+#else |
+# define png_control_jmp_buf(pc) ((pc)->error_buf) |
+#endif |
+ |
+/* Utility to safely execute a piece of libpng code catching and logging any |
+ * errors that might occur. Returns true on success, false on failure (either |
+ * of the function or as a result of a png_error.) |
+ */ |
+PNG_INTERNAL_FUNCTION(void,png_safe_error,(png_structp png_ptr, |
+ png_const_charp error_message),PNG_NORETURN); |
+ |
+#ifdef PNG_WARNINGS_SUPPORTED |
+PNG_INTERNAL_FUNCTION(void,png_safe_warning,(png_structp png_ptr, |
+ png_const_charp warning_message),PNG_EMPTY); |
+#else |
+# define png_safe_warning 0/*dummy argument*/ |
+#endif |
+ |
+PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image, |
+ int (*function)(png_voidp), png_voidp arg),PNG_EMPTY); |
+ |
+/* Utility to log an error; this also cleans up the png_image; the function |
+ * always returns 0 (false). |
+ */ |
+PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image, |
+ png_const_charp error_message),PNG_EMPTY); |
+ |
+#ifndef PNG_SIMPLIFIED_READ_SUPPORTED |
+/* png_image_free is used by the write code but not exported */ |
+PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY); |
+#endif /* !SIMPLIFIED_READ */ |
+ |
+#endif /* SIMPLIFIED READ/WRITE */ |
+ |
+/* These are initialization functions for hardware specific PNG filter |
+ * optimizations; list these here then select the appropriate one at compile |
+ * time using the macro PNG_FILTER_OPTIMIZATIONS. If the macro is not defined |
+ * the generic code is used. |
+ */ |
+#ifdef PNG_FILTER_OPTIMIZATIONS |
+PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr, |
+ unsigned int bpp), PNG_EMPTY); |
+ /* Just declare the optimization that will be used */ |
+#else |
+ /* List *all* the possible optimizations here - this branch is required if |
+ * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in |
+ * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing. |
+ */ |
+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon, |
+ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY); |
+#endif |
+ |
+/* Maintainer: Put new private prototypes here ^ */ |
+ |
#include "pngdebug.h" |
#ifdef __cplusplus |
@@ -1232,4 +2000,5 @@ |
} |
#endif |
+#endif /* PNG_VERSION_INFO_ONLY */ |
#endif /* PNGPRIV_H */ |
/programs/develop/libraries/libpng/pngread.c |
---|
1,8 → 1,8 |
/* pngread.c - read a PNG file |
* |
* Last changed in libpng 1.5.1 [$RDATE%] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.1 [March 28, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
15,6 → 15,9 |
*/ |
#include "pngpriv.h" |
#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) |
# include <errno.h> |
#endif |
#ifdef PNG_READ_SUPPORTED |
23,10 → 26,12 |
png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL)); |
#ifndef PNG_USER_MEM_SUPPORTED |
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, |
error_fn, warn_fn, NULL, NULL, NULL); |
#else |
return png_create_read_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL); |
} |
/* Alternate create PNG structure for reading, and allocate any memory |
37,184 → 42,43 |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) |
{ |
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, |
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_SETJMP_SUPPORTED |
volatile |
#endif |
png_structp png_ptr; |
volatile int png_cleanup_needed = 0; |
if (png_ptr != NULL) |
{ |
png_ptr->mode = PNG_IS_READ_STRUCT; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf png_jmpbuf; |
/* Added in libpng-1.6.0; this can be used to detect a read structure if |
* required (it will be zero in a write structure.) |
*/ |
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE; |
#endif |
#endif |
int i; |
# ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED |
png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; |
png_debug(1, "in png_create_read_struct"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
malloc_fn, mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
/* In stable builds only warn if an application error can be completely |
* handled. |
*/ |
# if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC |
png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN; |
#endif |
if (png_ptr == NULL) |
return (NULL); |
/* Added at libpng-1.2.6 */ |
#ifdef PNG_USER_LIMITS_SUPPORTED |
png_ptr->user_width_max = PNG_USER_WIDTH_MAX; |
png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; |
# ifdef PNG_USER_CHUNK_CACHE_MAX |
/* Added at libpng-1.2.43 and 1.4.0 */ |
png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; |
# endif |
# ifdef PNG_SET_USER_CHUNK_MALLOC_MAX |
/* Added at libpng-1.2.43 and 1.4.1 */ |
png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; |
# endif |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then |
encounter a png_error() will longjmp here. Since the jmpbuf is |
then meaningless we abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(png_jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */ |
#endif |
PNG_ABORT(); |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(png_ptr), png_jmpbuf, png_sizeof(jmp_buf)); |
#endif |
#endif /* PNG_SETJMP_SUPPORTED */ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
if (user_png_ver) |
{ |
i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
} |
else |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
/* TODO: delay this, it can be done in png_init_io (if the app doesn't |
* do it itself) avoiding setting the default function if it is not |
* required. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[80]; |
if (user_png_ver) |
{ |
png_snprintf2(msg, 80, |
"Application built with libpng-%.20s" |
" but running with %.20s", |
user_png_ver, |
png_libpng_ver); |
png_warning(png_ptr, msg); |
png_set_read_fn(png_ptr, NULL, NULL); |
} |
#else |
png_warning(png_ptr, |
"Incompatible libpng version in application and library"); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags = 0; |
#endif |
png_cleanup_needed = 1; |
return png_ptr; |
} |
} |
if (!png_cleanup_needed) |
{ |
/* Initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf_size); |
if (png_ptr->zbuf == NULL) |
png_cleanup_needed = 1; |
} |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
if (!png_cleanup_needed) |
{ |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: |
break; /* Do nothing */ |
case Z_MEM_ERROR: |
png_warning(png_ptr, "zlib memory error"); |
png_cleanup_needed = 1; |
break; |
case Z_STREAM_ERROR: |
png_warning(png_ptr, "zlib stream error"); |
png_cleanup_needed = 1; |
break; |
case Z_VERSION_ERROR: |
png_warning(png_ptr, "zlib version error"); |
png_cleanup_needed = 1; |
break; |
default: png_warning(png_ptr, "Unknown zlib error"); |
png_cleanup_needed = 1; |
} |
} |
if (png_cleanup_needed) |
{ |
/* Clean up PNG structure and deallocate any memory. */ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, |
(png_free_ptr)free_fn, (png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
return (NULL); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, NULL, NULL); |
return (png_ptr); |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the information before the actual image data. This has been |
* changed in v0.90 to allow reading a file that already has the magic |
225,8 → 89,12 |
* read if it is determined that this isn't a valid PNG file. |
*/ |
void PNGAPI |
png_read_info(png_structp png_ptr, png_infop info_ptr) |
png_read_info(png_structrp png_ptr, png_inforp info_ptr) |
{ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int keep; |
#endif |
png_debug(1, "in png_read_info"); |
if (png_ptr == NULL || info_ptr == NULL) |
237,205 → 105,151 |
for (;;) |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
png_uint_32 length = png_read_chunk_header(png_ptr); |
PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; |
png_uint_32 chunk_name = png_ptr->chunk_name; |
/* IDAT logic needs to happen here to simplify getting the two flags |
* right. |
*/ |
if (chunk_name == png_IDAT) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_chunk_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_chunk_error(png_ptr, "Missing PLTE before IDAT"); |
else if (png_ptr->mode & PNG_AFTER_IDAT) |
png_chunk_benign_error(png_ptr, "Too many IDATs found"); |
png_ptr->mode |= PNG_HAVE_IDAT; |
} |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
/* This should be a binary subdivision search or a hash for |
* matching the chunk name rather than a linear search. |
*/ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; |
if (!png_memcmp(chunk_name, png_IHDR, 4)) |
if (chunk_name == png_IHDR) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(chunk_name, png_IEND, 4)) |
else if (chunk_name == png_IEND) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, chunk_name)) |
else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0) |
{ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length, keep); |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(chunk_name, png_PLTE, 4)) |
if (chunk_name == png_PLTE) |
png_ptr->mode |= PNG_HAVE_PLTE; |
else if (!png_memcmp(chunk_name, png_IDAT, 4)) |
else if (chunk_name == png_IDAT) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
png_ptr->idat_size = 0; /* It has been consumed */ |
break; |
} |
} |
#endif |
else if (!png_memcmp(chunk_name, png_PLTE, 4)) |
else if (chunk_name == png_PLTE) |
png_handle_PLTE(png_ptr, info_ptr, length); |
else if (!png_memcmp(chunk_name, png_IDAT, 4)) |
else if (chunk_name == png_IDAT) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
png_ptr->idat_size = length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
break; |
} |
#ifdef PNG_READ_bKGD_SUPPORTED |
else if (!png_memcmp(chunk_name, png_bKGD, 4)) |
else if (chunk_name == png_bKGD) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
else if (!png_memcmp(chunk_name, png_cHRM, 4)) |
else if (chunk_name == png_cHRM) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
else if (!png_memcmp(chunk_name, png_gAMA, 4)) |
else if (chunk_name == png_gAMA) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
else if (!png_memcmp(chunk_name, png_hIST, 4)) |
else if (chunk_name == png_hIST) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_oFFs, 4)) |
else if (chunk_name == png_oFFs) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pCAL, 4)) |
else if (chunk_name == png_pCAL) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sCAL, 4)) |
else if (chunk_name == png_sCAL) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pHYs, 4)) |
else if (chunk_name == png_pHYs) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sBIT, 4)) |
else if (chunk_name == png_sBIT) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sRGB, 4)) |
else if (chunk_name == png_sRGB) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iCCP, 4)) |
else if (chunk_name == png_iCCP) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sPLT, 4)) |
else if (chunk_name == png_sPLT) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tEXt, 4)) |
else if (chunk_name == png_tEXt) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tIME, 4)) |
else if (chunk_name == png_tIME) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tRNS, 4)) |
else if (chunk_name == png_tRNS) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_zTXt, 4)) |
else if (chunk_name == png_zTXt) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iTXt, 4)) |
else if (chunk_name == png_iTXt) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
png_handle_unknown(png_ptr, info_ptr, length, |
PNG_HANDLE_CHUNK_AS_DEFAULT); |
} |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
442,24 → 256,30 |
/* Optional call to update the users info_ptr structure */ |
void PNGAPI |
png_read_update_info(png_structp png_ptr, png_infop info_ptr) |
png_read_update_info(png_structrp png_ptr, png_inforp info_ptr) |
{ |
png_debug(1, "in png_read_update_info"); |
if (png_ptr == NULL) |
return; |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
if (png_ptr != NULL) |
{ |
if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) |
{ |
png_read_start_row(png_ptr); |
else |
png_warning(png_ptr, |
"Ignoring extra png_read_update_info() call;" |
" row buffer not reallocated"); |
# ifdef PNG_READ_TRANSFORMS_SUPPORTED |
png_read_transform_info(png_ptr, info_ptr); |
# else |
PNG_UNUSED(info_ptr) |
# endif |
} |
/* New in 1.6.0 this avoids the bug of doing the initializations twice */ |
else |
png_app_error(png_ptr, |
"png_read_update_info/png_start_read_image: duplicate call"); |
} |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Initialize palette, background, etc, after transformations |
* are set, but before any reading takes place. This allows |
467,31 → 287,28 |
* If the user doesn't call this, we will do it ourselves. |
*/ |
void PNGAPI |
png_start_read_image(png_structp png_ptr) |
png_start_read_image(png_structrp png_ptr) |
{ |
png_debug(1, "in png_start_read_image"); |
if (png_ptr == NULL) |
return; |
if (png_ptr != NULL) |
{ |
if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) |
png_read_start_row(png_ptr); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
/* New in 1.6.0 this avoids the bug of doing the initializations twice */ |
else |
png_warning(png_ptr, |
"Ignoring extra png_start_read_image() call;" |
" row buffer not reallocated"); |
png_app_error(png_ptr, |
"png_start_read_image/png_read_update_info: duplicate call"); |
} |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
void PNGAPI |
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) |
png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row) |
{ |
PNG_IDAT; |
PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, |
0xff}; |
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
int ret; |
png_row_info row_info; |
if (png_ptr == NULL) |
return; |
499,9 → 316,20 |
png_debug2(1, "in png_read_row (row %lu, pass %d)", |
(unsigned long)png_ptr->row_number, png_ptr->pass); |
/* png_read_start_row sets the information (in particular iwidth) for this |
* interlace pass. |
*/ |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
/* 1.5.6: row_info moved out of png_struct to a local here. */ |
row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */ |
row_info.color_type = png_ptr->color_type; |
row_info.bit_depth = png_ptr->bit_depth; |
row_info.channels = png_ptr->channels; |
row_info.pixel_depth = png_ptr->pixel_depth; |
row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); |
if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
{ |
/* Check for transforms that have been set but were defined out */ |
543,7 → 371,12 |
} |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* If interlaced and we do not need a new row, combine row and return */ |
/* If interlaced and we do not need a new row, combine row and return. |
* Notice that the pixels we have from previous rows have been transformed |
* already; we can only combine like with like (transformed or |
* untransformed) and, because of the libpng API for interlaced images, this |
* means we must transform before de-interlacing. |
*/ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
switch (png_ptr->pass) |
552,8 → 385,7 |
if (png_ptr->row_number & 0x07) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
} |
563,8 → 395,7 |
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
575,8 → 406,7 |
if ((png_ptr->row_number & 0x07) != 4) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 4)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
587,8 → 417,7 |
if ((png_ptr->row_number & 3) || png_ptr->width < 3) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
599,19 → 428,18 |
if ((png_ptr->row_number & 3) != 2) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 2)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 5: |
if ((png_ptr->row_number & 1) || png_ptr->width < 2) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
png_read_finish_row(png_ptr); |
return; |
633,78 → 461,51 |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "Invalid attempt to read row data"); |
png_ptr->zstream.next_out = png_ptr->row_buf; |
png_ptr->zstream.avail_out = |
(uInt)(PNG_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1); |
/* Fill the row with IDAT data: */ |
png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1); |
do |
if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE) |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_crc_finish(png_ptr, 0); |
png_ptr->idat_size = png_read_chunk_header(png_ptr); |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) |
png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, |
png_ptr->prev_row + 1, png_ptr->row_buf[0]); |
else |
png_error(png_ptr, "bad adaptive filter value"); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, |
(png_size_t)png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
/* libpng 1.5.6: the following line was copying png_ptr->rowbytes before |
* 1.5.6, while the buffer really is this big in current versions of libpng |
* it may not be in the future, so this was changed just to copy the |
* interlaced count: |
*/ |
memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); |
if (ret == Z_STREAM_END) |
{ |
if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_benign_error(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression error"); |
} while (png_ptr->zstream.avail_out); |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
if (png_ptr->row_buf[0]) |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1); |
} |
#endif |
if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) |
png_do_read_transformations(png_ptr); |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr, &row_info); |
#endif |
/* The transformed pixel depth should match the depth now in row_info. */ |
if (png_ptr->transformed_pixel_depth == 0) |
{ |
png_ptr->transformed_pixel_depth = row_info.pixel_depth; |
if (row_info.pixel_depth > png_ptr->maximum_pixel_depth) |
png_error(png_ptr, "sequential row overflow"); |
} |
else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) |
png_error(png_ptr, "internal sequential row size calculation error"); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Blow up interlaced rows to full size */ |
if (png_ptr->interlaced && |
711,17 → 512,14 |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* Old interface (pre-1.0.9): |
* png_do_read_interlace(&(png_ptr->row_info), |
* png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, |
png_ptr->transformations); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, png_pass_dsp_mask[png_ptr->pass]); |
png_combine_row(png_ptr, dsp_row, 1/*display*/); |
if (row != NULL) |
png_combine_row(png_ptr, row, png_pass_mask[png_ptr->pass]); |
png_combine_row(png_ptr, row, 0/*row*/); |
} |
else |
728,15 → 526,16 |
#endif |
{ |
if (row != NULL) |
png_combine_row(png_ptr, row, 0xff); |
png_combine_row(png_ptr, row, -1/*ignored*/); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, 0xff); |
png_combine_row(png_ptr, dsp_row, -1/*ignored*/); |
} |
png_read_finish_row(png_ptr); |
if (png_ptr->read_row_fn != NULL) |
(*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
766,7 → 565,7 |
*/ |
void PNGAPI |
png_read_rows(png_structp png_ptr, png_bytepp row, |
png_read_rows(png_structrp png_ptr, png_bytepp row, |
png_bytepp display_row, png_uint_32 num_rows) |
{ |
png_uint_32 i; |
821,7 → 620,7 |
* [*] png_handle_alpha() does not exist yet, as of this version of libpng |
*/ |
void PNGAPI |
png_read_image(png_structp png_ptr, png_bytepp image) |
png_read_image(png_structrp png_ptr, png_bytepp image) |
{ |
png_uint_32 i, image_height; |
int pass, j; |
886,96 → 685,58 |
* or time information at the end of the file, if info is not NULL. |
*/ |
void PNGAPI |
png_read_end(png_structp png_ptr, png_infop info_ptr) |
png_read_end(png_structrp png_ptr, png_inforp info_ptr) |
{ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int keep; |
#endif |
png_debug(1, "in png_read_end"); |
if (png_ptr == NULL) |
return; |
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ |
/* If png_read_end is called in the middle of reading the rows there may |
* still be pending IDAT data and an owned zstream. Deal with this here. |
*/ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (!png_chunk_unknown_handling(png_ptr, png_IDAT)) |
#endif |
png_read_finish_IDAT(png_ptr); |
#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED |
/* Report invalid palette index; added at libng-1.5.10 */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
png_ptr->num_palette_max > png_ptr->num_palette) |
png_benign_error(png_ptr, "Read palette index exceeding num_palette"); |
#endif |
do |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
png_uint_32 length = png_read_chunk_header(png_ptr); |
PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; |
png_uint_32 chunk_name = png_ptr->chunk_name; |
if (!png_memcmp(chunk_name, png_IHDR, 4)) |
if (chunk_name == png_IHDR) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(chunk_name, png_IEND, 4)) |
else if (chunk_name == png_IEND) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, chunk_name)) |
else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0) |
{ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
if (chunk_name == png_IDAT) |
{ |
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) |
png_benign_error(png_ptr, "Too many IDATs found"); |
} |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(chunk_name, png_PLTE, 4)) |
png_handle_unknown(png_ptr, info_ptr, length, keep); |
if (chunk_name == png_PLTE) |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
#endif |
else if (!png_memcmp(chunk_name, png_IDAT, 4)) |
else if (chunk_name == png_IDAT) |
{ |
/* Zero length IDATs are legal after the last IDAT has been |
* read, but not after other chunks have been read. |
985,200 → 746,114 |
png_crc_finish(png_ptr, length); |
} |
else if (!png_memcmp(chunk_name, png_PLTE, 4)) |
else if (chunk_name == png_PLTE) |
png_handle_PLTE(png_ptr, info_ptr, length); |
#ifdef PNG_READ_bKGD_SUPPORTED |
else if (!png_memcmp(chunk_name, png_bKGD, 4)) |
else if (chunk_name == png_bKGD) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
else if (!png_memcmp(chunk_name, png_cHRM, 4)) |
else if (chunk_name == png_cHRM) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
else if (!png_memcmp(chunk_name, png_gAMA, 4)) |
else if (chunk_name == png_gAMA) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
else if (!png_memcmp(chunk_name, png_hIST, 4)) |
else if (chunk_name == png_hIST) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_oFFs, 4)) |
else if (chunk_name == png_oFFs) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pCAL, 4)) |
else if (chunk_name == png_pCAL) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sCAL, 4)) |
else if (chunk_name == png_sCAL) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pHYs, 4)) |
else if (chunk_name == png_pHYs) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sBIT, 4)) |
else if (chunk_name == png_sBIT) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sRGB, 4)) |
else if (chunk_name == png_sRGB) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iCCP, 4)) |
else if (chunk_name == png_iCCP) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sPLT, 4)) |
else if (chunk_name == png_sPLT) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tEXt, 4)) |
else if (chunk_name == png_tEXt) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tIME, 4)) |
else if (chunk_name == png_tIME) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tRNS, 4)) |
else if (chunk_name == png_tRNS) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_zTXt, 4)) |
else if (chunk_name == png_zTXt) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iTXt, 4)) |
else if (chunk_name == png_iTXt) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
png_handle_unknown(png_ptr, info_ptr, length, |
PNG_HANDLE_CHUNK_AS_DEFAULT); |
} while (!(png_ptr->mode & PNG_HAVE_IEND)); |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
/* Free all memory used by the read */ |
void PNGAPI |
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, |
png_infopp end_info_ptr_ptr) |
/* Free all memory used in the read struct */ |
static void |
png_read_destroy(png_structrp png_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL, end_info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#endif |
png_debug(1, "in png_read_destroy"); |
png_debug(1, "in png_destroy_read_struct"); |
if (png_ptr_ptr != NULL) |
png_ptr = *png_ptr_ptr; |
if (png_ptr == NULL) |
return; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#ifdef PNG_READ_GAMMA_SUPPORTED |
png_destroy_gamma_table(png_ptr); |
#endif |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (end_info_ptr_ptr != NULL) |
end_info_ptr = *end_info_ptr_ptr; |
png_read_destroy(png_ptr, info_ptr, end_info_ptr); |
if (info_ptr != NULL) |
{ |
#ifdef PNG_TEXT_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (end_info_ptr != NULL) |
{ |
#ifdef PNG_READ_TEXT_SUPPORTED |
png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)end_info_ptr); |
#endif |
*end_info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* Free all memory used by the read (old method) */ |
void /* PRIVATE */ |
png_read_destroy(png_structp png_ptr, png_infop info_ptr, |
png_infop end_info_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_read_destroy"); |
if (info_ptr != NULL) |
png_info_destroy(png_ptr, info_ptr); |
if (end_info_ptr != NULL) |
png_info_destroy(png_ptr, end_info_ptr); |
png_free(png_ptr, png_ptr->zbuf); |
png_free(png_ptr, png_ptr->big_row_buf); |
png_free(png_ptr, png_ptr->prev_row); |
png_free(png_ptr, png_ptr->chunkdata); |
png_free(png_ptr, png_ptr->big_prev_row); |
png_free(png_ptr, png_ptr->read_buffer); |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
png_free(png_ptr, png_ptr->palette_lookup); |
1185,15 → 860,6 |
png_free(png_ptr, png_ptr->quantize_index); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
png_free(png_ptr, png_ptr->gamma_table); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
png_free(png_ptr, png_ptr->gamma_from_1); |
png_free(png_ptr, png_ptr->gamma_to_1); |
#endif |
if (png_ptr->free_me & PNG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->free_me &= ~PNG_FREE_PLTE; |
1205,52 → 871,6 |
png_ptr->free_me &= ~PNG_FREE_TRNS; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->free_me &= ~PNG_FREE_HIST; |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (png_ptr->gamma_16_table != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_table[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_table); |
} |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if (png_ptr->gamma_16_from_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_from_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_from_1); |
} |
if (png_ptr->gamma_16_to_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_to_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_to_1); |
} |
#endif |
#endif |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
inflateEnd(&png_ptr->zstream); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
1257,43 → 877,50 |
png_free(png_ptr, png_ptr->save_buffer); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
#ifdef PNG_TEXT_SUPPORTED |
png_free(png_ptr, png_ptr->current_text); |
#endif /* PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/* Save the important info out of the png_struct, in case it is |
* being used again. |
*/ |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(tmp_jmp, png_ptr->png_jmpbuf, png_sizeof(jmp_buf)); |
#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) &&\ |
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
png_free(png_ptr, png_ptr->chunk_list); |
#endif |
png_memset(png_ptr, 0, png_sizeof(png_struct)); |
/* NOTE: the 'setjmp' buffer may still be allocated and the memory and error |
* callbacks are still set at this point. They are required to complete the |
* destruction of the png_struct itself. |
*/ |
} |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
/* Free all memory used by the read */ |
void PNGAPI |
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, |
png_infopp end_info_ptr_ptr) |
{ |
png_structrp png_ptr = NULL; |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->png_jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); |
#endif |
png_debug(1, "in png_destroy_read_struct"); |
if (png_ptr_ptr != NULL) |
png_ptr = *png_ptr_ptr; |
if (png_ptr == NULL) |
return; |
/* libpng 1.6.0: use the API to destroy info structs to ensure consistent |
* behavior. Prior to 1.6.0 libpng did extra 'info' destruction in this API. |
* The extra was, apparently, unnecessary yet this hides memory leak bugs. |
*/ |
png_destroy_info_struct(png_ptr, end_info_ptr_ptr); |
png_destroy_info_struct(png_ptr, info_ptr_ptr); |
*png_ptr_ptr = NULL; |
png_read_destroy(png_ptr); |
png_destroy_png_struct(png_ptr); |
} |
void PNGAPI |
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) |
png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn) |
{ |
if (png_ptr == NULL) |
return; |
1305,13 → 932,13 |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
void PNGAPI |
png_read_png(png_structp png_ptr, png_infop info_ptr, |
png_read_png(png_structrp png_ptr, png_inforp info_ptr, |
int transforms, |
voidp params) |
{ |
int row; |
if (png_ptr == NULL) |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* png_read_info() gives us all of the information from the |
1318,14 → 945,28 |
* PNG file before the first IDAT (image data chunk). |
*/ |
png_read_info(png_ptr, info_ptr); |
if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) |
if (info_ptr->height > PNG_UINT_32_MAX/(sizeof (png_bytep))) |
png_error(png_ptr, "Image is too high to process with png_read_png()"); |
/* -------------- image transformations start here ------------------- */ |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
/* Tell libpng to strip 16 bit/color files down to 8 bits per color. |
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
/* Tell libpng to strip 16-bit/color files down to 8 bits per color. |
*/ |
if (transforms & PNG_TRANSFORM_SCALE_16) |
{ |
/* Added at libpng-1.5.4. "strip_16" produces the same result that it |
* did in earlier versions, while "scale_16" is now more accurate. |
*/ |
png_set_scale_16(png_ptr); |
} |
#endif |
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
/* If both SCALE and STRIP are required pngrtran will effectively cancel the |
* latter by doing SCALE first. This is ok and allows apps not to check for |
* which is supported to get the right answer. |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_16) |
png_set_strip_16(png_ptr); |
#endif |
1405,7 → 1046,7 |
#endif |
#ifdef PNG_READ_SWAP_SUPPORTED |
/* Swap bytes of 16 bit files to least significant byte first */ |
/* Swap bytes of 16-bit files to least significant byte first */ |
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
png_set_swap(png_ptr); |
#endif |
1424,8 → 1065,19 |
png_set_gray_to_rgb(png_ptr); |
#endif |
/* Added at libpng-1.5.4 */ |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
if (transforms & PNG_TRANSFORM_EXPAND_16) |
png_set_expand_16(png_ptr); |
#endif |
/* We don't handle adding filler bytes */ |
/* We use png_read_image and rely on that for interlace handling, but we also |
* call png_read_update_info therefore must turn on interlace handling now: |
*/ |
(void)png_set_interlace_handling(png_ptr); |
/* Optional call to gamma correct and add the background to the palette |
* and update info structure. REQUIRED if you are expecting libpng to |
* update the palette for you (i.e., you selected such a transform above). |
1440,7 → 1092,7 |
png_uint_32 iptr; |
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, |
info_ptr->height * png_sizeof(png_bytep)); |
info_ptr->height * (sizeof (png_bytep))); |
for (iptr=0; iptr<info_ptr->height; iptr++) |
info_ptr->row_pointers[iptr] = NULL; |
1463,4 → 1115,2886 |
} |
#endif /* PNG_INFO_IMAGE_SUPPORTED */ |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SIMPLIFIED_READ_SUPPORTED |
/* SIMPLIFIED READ |
* |
* This code currently relies on the sequential reader, though it could easily |
* be made to work with the progressive one. |
*/ |
/* Arguments to png_image_finish_read: */ |
/* Encoding of PNG data (used by the color-map code) */ |
/* TODO: change these, dang, ANSI-C reserves the 'E' namespace. */ |
# define E_NOTSET 0 /* File encoding not yet known */ |
# define E_sRGB 1 /* 8-bit encoded to sRGB gamma */ |
# define E_LINEAR 2 /* 16-bit linear: not encoded, NOT pre-multiplied! */ |
# define E_FILE 3 /* 8-bit encoded to file gamma, not sRGB or linear */ |
# define E_LINEAR8 4 /* 8-bit linear: only from a file value */ |
/* Color-map processing: after libpng has run on the PNG image further |
* processing may be needed to conver the data to color-map indicies. |
*/ |
#define PNG_CMAP_NONE 0 |
#define PNG_CMAP_GA 1 /* Process GA data to a color-map with alpha */ |
#define PNG_CMAP_TRANS 2 /* Process GA data to a background index */ |
#define PNG_CMAP_RGB 3 /* Process RGB data */ |
#define PNG_CMAP_RGB_ALPHA 4 /* Process RGBA data */ |
/* The following document where the background is for each processing case. */ |
#define PNG_CMAP_NONE_BACKGROUND 256 |
#define PNG_CMAP_GA_BACKGROUND 231 |
#define PNG_CMAP_TRANS_BACKGROUND 254 |
#define PNG_CMAP_RGB_BACKGROUND 256 |
#define PNG_CMAP_RGB_ALPHA_BACKGROUND 216 |
typedef struct |
{ |
/* Arguments: */ |
png_imagep image; |
png_voidp buffer; |
png_int_32 row_stride; |
png_voidp colormap; |
png_const_colorp background; |
/* Local variables: */ |
png_voidp local_row; |
png_voidp first_row; |
ptrdiff_t row_bytes; /* step between rows */ |
int file_encoding; /* E_ values above */ |
png_fixed_point gamma_to_linear; /* For E_FILE, reciprocal of gamma */ |
int colormap_processing; /* PNG_CMAP_ values above */ |
} png_image_read_control; |
/* Do all the *safe* initialization - 'safe' means that png_error won't be |
* called, so setting up the jmp_buf is not required. This means that anything |
* called from here must *not* call png_malloc - it has to call png_malloc_warn |
* instead so that control is returned safely back to this routine. |
*/ |
static int |
png_image_read_init(png_imagep image) |
{ |
if (image->opaque == NULL) |
{ |
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, image, |
png_safe_error, png_safe_warning); |
/* And set the rest of the structure to NULL to ensure that the various |
* fields are consistent. |
*/ |
memset(image, 0, (sizeof *image)); |
image->version = PNG_IMAGE_VERSION; |
if (png_ptr != NULL) |
{ |
png_infop info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr != NULL) |
{ |
png_controlp control = png_voidcast(png_controlp, |
png_malloc_warn(png_ptr, (sizeof *control))); |
if (control != NULL) |
{ |
memset(control, 0, (sizeof *control)); |
control->png_ptr = png_ptr; |
control->info_ptr = info_ptr; |
control->for_write = 0; |
image->opaque = control; |
return 1; |
} |
/* Error clean up */ |
png_destroy_info_struct(png_ptr, &info_ptr); |
} |
png_destroy_read_struct(&png_ptr, NULL, NULL); |
} |
return png_image_error(image, "png_image_read: out of memory"); |
} |
return png_image_error(image, "png_image_read: opaque pointer not NULL"); |
} |
/* Utility to find the base format of a PNG file from a png_struct. */ |
static png_uint_32 |
png_image_format(png_structrp png_ptr) |
{ |
png_uint_32 format = 0; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
format |= PNG_FORMAT_FLAG_COLOR; |
if (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
format |= PNG_FORMAT_FLAG_ALPHA; |
/* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS |
* sets the png_struct fields; that's all we are interested in here. The |
* precise interaction with an app call to png_set_tRNS and PNG file reading |
* is unclear. |
*/ |
else if (png_ptr->num_trans > 0) |
format |= PNG_FORMAT_FLAG_ALPHA; |
if (png_ptr->bit_depth == 16) |
format |= PNG_FORMAT_FLAG_LINEAR; |
if (png_ptr->color_type & PNG_COLOR_MASK_PALETTE) |
format |= PNG_FORMAT_FLAG_COLORMAP; |
return format; |
} |
/* Is the given gamma significantly different from sRGB? The test is the same |
* one used in pngrtran.c when deciding whether to do gamma correction. The |
* arithmetic optimizes the division by using the fact that the inverse of the |
* file sRGB gamma is 2.2 |
*/ |
static int |
png_gamma_not_sRGB(png_fixed_point g) |
{ |
if (g < PNG_FP_1) |
{ |
/* An uninitialized gamma is assumed to be sRGB for the simplified API. */ |
if (g == 0) |
return 0; |
return png_gamma_significant((g * 11 + 2)/5 /* i.e. *2.2, rounded */); |
} |
return 1; |
} |
/* Do the main body of a 'png_image_begin_read' function; read the PNG file |
* header and fill in all the information. This is executed in a safe context, |
* unlike the init routine above. |
*/ |
static int |
png_image_read_header(png_voidp argument) |
{ |
png_imagep image = png_voidcast(png_imagep, argument); |
png_structrp png_ptr = image->opaque->png_ptr; |
png_inforp info_ptr = image->opaque->info_ptr; |
png_set_benign_errors(png_ptr, 1/*warn*/); |
png_read_info(png_ptr, info_ptr); |
/* Do this the fast way; just read directly out of png_struct. */ |
image->width = png_ptr->width; |
image->height = png_ptr->height; |
{ |
png_uint_32 format = png_image_format(png_ptr); |
image->format = format; |
#ifdef PNG_COLORSPACE_SUPPORTED |
/* Does the colorspace match sRGB? If there is no color endpoint |
* (colorant) information assume yes, otherwise require the |
* 'ENDPOINTS_MATCHE_sRGB' colorspace flag to have been set. If the |
* colorspace has been determined to be invalid ignore it. |
*/ |
if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags |
& (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB| |
PNG_COLORSPACE_INVALID)) == PNG_COLORSPACE_HAVE_ENDPOINTS)) |
image->flags |= PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB; |
#endif |
} |
/* We need the maximum number of entries regardless of the format the |
* application sets here. |
*/ |
{ |
png_uint_32 cmap_entries; |
switch (png_ptr->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
cmap_entries = 1U << png_ptr->bit_depth; |
break; |
case PNG_COLOR_TYPE_PALETTE: |
cmap_entries = png_ptr->num_palette; |
break; |
default: |
cmap_entries = 256; |
break; |
} |
if (cmap_entries > 256) |
cmap_entries = 256; |
image->colormap_entries = cmap_entries; |
} |
return 1; |
} |
#ifdef PNG_STDIO_SUPPORTED |
int PNGAPI |
png_image_begin_read_from_stdio(png_imagep image, FILE* file) |
{ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
if (file != NULL) |
{ |
if (png_image_read_init(image)) |
{ |
/* This is slightly evil, but png_init_io doesn't do anything other |
* than this and we haven't changed the standard IO functions so |
* this saves a 'safe' function. |
*/ |
image->opaque->png_ptr->io_ptr = file; |
return png_safe_execute(image, png_image_read_header, image); |
} |
} |
else |
return png_image_error(image, |
"png_image_begin_read_from_stdio: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION"); |
return 0; |
} |
int PNGAPI |
png_image_begin_read_from_file(png_imagep image, const char *file_name) |
{ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
if (file_name != NULL) |
{ |
FILE *fp = fopen(file_name, "rb"); |
if (fp != NULL) |
{ |
if (png_image_read_init(image)) |
{ |
image->opaque->png_ptr->io_ptr = fp; |
image->opaque->owned_file = 1; |
return png_safe_execute(image, png_image_read_header, image); |
} |
/* Clean up: just the opened file. */ |
(void)fclose(fp); |
} |
else |
return png_image_error(image, strerror(errno)); |
} |
else |
return png_image_error(image, |
"png_image_begin_read_from_file: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION"); |
return 0; |
} |
#endif /* PNG_STDIO_SUPPORTED */ |
static void PNGCBAPI |
png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need) |
{ |
if (png_ptr != NULL) |
{ |
png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr); |
if (image != NULL) |
{ |
png_controlp cp = image->opaque; |
if (cp != NULL) |
{ |
png_const_bytep memory = cp->memory; |
png_size_t size = cp->size; |
if (memory != NULL && size >= need) |
{ |
memcpy(out, memory, need); |
cp->memory = memory + need; |
cp->size = size - need; |
return; |
} |
png_error(png_ptr, "read beyond end of data"); |
} |
} |
png_error(png_ptr, "invalid memory read"); |
} |
} |
int PNGAPI png_image_begin_read_from_memory(png_imagep image, |
png_const_voidp memory, png_size_t size) |
{ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
if (memory != NULL && size > 0) |
{ |
if (png_image_read_init(image)) |
{ |
/* Now set the IO functions to read from the memory buffer and |
* store it into io_ptr. Again do this in-place to avoid calling a |
* libpng function that requires error handling. |
*/ |
image->opaque->memory = png_voidcast(png_const_bytep, memory); |
image->opaque->size = size; |
image->opaque->png_ptr->io_ptr = image; |
image->opaque->png_ptr->read_data_fn = png_image_memory_read; |
return png_safe_execute(image, png_image_read_header, image); |
} |
} |
else |
return png_image_error(image, |
"png_image_begin_read_from_memory: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION"); |
return 0; |
} |
/* Utility function to skip chunks that are not used by the simplified image |
* read functions and an appropriate macro to call it. |
*/ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
static void |
png_image_skip_unused_chunks(png_structrp png_ptr) |
{ |
/* Prepare the reader to ignore all recognized chunks whose data will not |
* be used, i.e., all chunks recognized by libpng except for those |
* involved in basic image reading: |
* |
* IHDR, PLTE, IDAT, IEND |
* |
* Or image data handling: |
* |
* tRNS, bKGD, gAMA, cHRM, sRGB, iCCP and sBIT. |
* |
* This provides a small performance improvement and eliminates any |
* potential vulnerability to security problems in the unused chunks. |
*/ |
{ |
static PNG_CONST png_byte chunks_to_process[] = { |
98, 75, 71, 68, '\0', /* bKGD */ |
99, 72, 82, 77, '\0', /* cHRM */ |
103, 65, 77, 65, '\0', /* gAMA */ |
105, 67, 67, 80, '\0', /* iCCP */ |
115, 66, 73, 84, '\0', /* sBIT */ |
115, 82, 71, 66, '\0', /* sRGB */ |
}; |
/* Ignore unknown chunks and all other chunks except for the |
* IHDR, PLTE, tRNS, IDAT, and IEND chunks. |
*/ |
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER, |
NULL, -1); |
/* But do not ignore image data handling chunks */ |
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT, |
chunks_to_process, (sizeof chunks_to_process)/5); |
} |
} |
# define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p) |
#else |
# define PNG_SKIP_CHUNKS(p) ((void)0) |
#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */ |
/* The following macro gives the exact rounded answer for all values in the |
* range 0..255 (it actually divides by 51.2, but the rounding still generates |
* the correct numbers 0..5 |
*/ |
#define PNG_DIV51(v8) (((v8) * 5 + 130) >> 8) |
/* Utility functions to make particular color-maps */ |
static void |
set_file_encoding(png_image_read_control *display) |
{ |
png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma; |
if (png_gamma_significant(g)) |
{ |
if (png_gamma_not_sRGB(g)) |
{ |
display->file_encoding = E_FILE; |
display->gamma_to_linear = png_reciprocal(g); |
} |
else |
display->file_encoding = E_sRGB; |
} |
else |
display->file_encoding = E_LINEAR8; |
} |
static unsigned int |
decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding) |
{ |
if (encoding == E_FILE) /* double check */ |
encoding = display->file_encoding; |
if (encoding == E_NOTSET) /* must be the file encoding */ |
{ |
set_file_encoding(display); |
encoding = display->file_encoding; |
} |
switch (encoding) |
{ |
case E_FILE: |
value = png_gamma_16bit_correct(value*257, display->gamma_to_linear); |
break; |
case E_sRGB: |
value = png_sRGB_table[value]; |
break; |
case E_LINEAR: |
break; |
case E_LINEAR8: |
value *= 257; |
break; |
default: |
png_error(display->image->opaque->png_ptr, |
"unexpected encoding (internal error)"); |
break; |
} |
return value; |
} |
static png_uint_32 |
png_colormap_compose(png_image_read_control *display, |
png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha, |
png_uint_32 background, int encoding) |
{ |
/* The file value is composed on the background, the background has the given |
* encoding and so does the result, the file is encoded with E_FILE and the |
* file and alpha are 8-bit values. The (output) encoding will always be |
* E_LINEAR or E_sRGB. |
*/ |
png_uint_32 f = decode_gamma(display, foreground, foreground_encoding); |
png_uint_32 b = decode_gamma(display, background, encoding); |
/* The alpha is always an 8-bit value (it comes from the palette), the value |
* scaled by 255 is what PNG_sRGB_FROM_LINEAR requires. |
*/ |
f = f * alpha + b * (255-alpha); |
if (encoding == E_LINEAR) |
{ |
/* Scale to 65535; divide by 255, approximately (in fact this is extremely |
* accurate, it divides by 255.00000005937181414556, with no overflow.) |
*/ |
f *= 257; /* Now scaled by 65535 */ |
f += f >> 16; |
f = (f+32768) >> 16; |
} |
else /* E_sRGB */ |
f = PNG_sRGB_FROM_LINEAR(f); |
return f; |
} |
/* NOTE: E_LINEAR values to this routine must be 16-bit, but E_FILE values must |
* be 8-bit. |
*/ |
static void |
png_create_colormap_entry(png_image_read_control *display, |
png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue, |
png_uint_32 alpha, int encoding) |
{ |
png_imagep image = display->image; |
const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) ? |
E_LINEAR : E_sRGB; |
const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 && |
(red != green || green != blue); |
if (ip > 255) |
png_error(image->opaque->png_ptr, "color-map index out of range"); |
/* Update the cache with whether the file gamma is significantly different |
* from sRGB. |
*/ |
if (encoding == E_FILE) |
{ |
if (display->file_encoding == E_NOTSET) |
set_file_encoding(display); |
/* Note that the cached value may be E_FILE too, but if it is then the |
* gamma_to_linear member has been set. |
*/ |
encoding = display->file_encoding; |
} |
if (encoding == E_FILE) |
{ |
png_fixed_point g = display->gamma_to_linear; |
red = png_gamma_16bit_correct(red*257, g); |
green = png_gamma_16bit_correct(green*257, g); |
blue = png_gamma_16bit_correct(blue*257, g); |
if (convert_to_Y || output_encoding == E_LINEAR) |
{ |
alpha *= 257; |
encoding = E_LINEAR; |
} |
else |
{ |
red = PNG_sRGB_FROM_LINEAR(red * 255); |
green = PNG_sRGB_FROM_LINEAR(green * 255); |
blue = PNG_sRGB_FROM_LINEAR(blue * 255); |
encoding = E_sRGB; |
} |
} |
else if (encoding == E_LINEAR8) |
{ |
/* This encoding occurs quite frequently in test cases because PngSuite |
* includes a gAMA 1.0 chunk with most images. |
*/ |
red *= 257; |
green *= 257; |
blue *= 257; |
alpha *= 257; |
encoding = E_LINEAR; |
} |
else if (encoding == E_sRGB && (convert_to_Y || output_encoding == E_LINEAR)) |
{ |
/* The values are 8-bit sRGB values, but must be converted to 16-bit |
* linear. |
*/ |
red = png_sRGB_table[red]; |
green = png_sRGB_table[green]; |
blue = png_sRGB_table[blue]; |
alpha *= 257; |
encoding = E_LINEAR; |
} |
/* This is set if the color isn't gray but the output is. */ |
if (encoding == E_LINEAR) |
{ |
if (convert_to_Y) |
{ |
/* NOTE: these values are copied from png_do_rgb_to_gray */ |
png_uint_32 y = (png_uint_32)6968 * red + (png_uint_32)23434 * green + |
(png_uint_32)2366 * blue; |
if (output_encoding == E_LINEAR) |
y = (y + 16384) >> 15; |
else |
{ |
/* y is scaled by 32768, we need it scaled by 255: */ |
y = (y + 128) >> 8; |
y *= 255; |
y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7); |
encoding = E_sRGB; |
} |
blue = red = green = y; |
} |
else if (output_encoding == E_sRGB) |
{ |
red = PNG_sRGB_FROM_LINEAR(red * 255); |
green = PNG_sRGB_FROM_LINEAR(green * 255); |
blue = PNG_sRGB_FROM_LINEAR(blue * 255); |
alpha = PNG_DIV257(alpha); |
encoding = E_sRGB; |
} |
} |
if (encoding != output_encoding) |
png_error(image->opaque->png_ptr, "bad encoding (internal error)"); |
/* Store the value. */ |
{ |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 && |
(image->format & PNG_FORMAT_FLAG_ALPHA) != 0; |
# else |
# define afirst 0 |
# endif |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) ? 2 : 0; |
# else |
# define bgr 0 |
# endif |
if (output_encoding == E_LINEAR) |
{ |
png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap); |
entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format); |
/* The linear 16-bit values must be pre-multiplied by the alpha channel |
* value, if less than 65535 (this is, effectively, composite on black |
* if the alpha channel is removed.) |
*/ |
switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format)) |
{ |
case 4: |
entry[afirst ? 0 : 3] = (png_uint_16)alpha; |
/* FALL THROUGH */ |
case 3: |
if (alpha < 65535) |
{ |
if (alpha > 0) |
{ |
blue = (blue * alpha + 32767U)/65535U; |
green = (green * alpha + 32767U)/65535U; |
red = (red * alpha + 32767U)/65535U; |
} |
else |
red = green = blue = 0; |
} |
entry[afirst + (2 ^ bgr)] = (png_uint_16)blue; |
entry[afirst + 1] = (png_uint_16)green; |
entry[afirst + bgr] = (png_uint_16)red; |
break; |
case 2: |
entry[1 ^ afirst] = (png_uint_16)alpha; |
/* FALL THROUGH */ |
case 1: |
if (alpha < 65535) |
{ |
if (alpha > 0) |
green = (green * alpha + 32767U)/65535U; |
else |
green = 0; |
} |
entry[afirst] = (png_uint_16)green; |
break; |
default: |
break; |
} |
} |
else /* output encoding is E_sRGB */ |
{ |
png_bytep entry = png_voidcast(png_bytep, display->colormap); |
entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format); |
switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format)) |
{ |
case 4: |
entry[afirst ? 0 : 3] = (png_byte)alpha; |
case 3: |
entry[afirst + (2 ^ bgr)] = (png_byte)blue; |
entry[afirst + 1] = (png_byte)green; |
entry[afirst + bgr] = (png_byte)red; |
break; |
case 2: |
entry[1 ^ afirst] = (png_byte)alpha; |
case 1: |
entry[afirst] = (png_byte)green; |
break; |
default: |
break; |
} |
} |
# ifdef afirst |
# undef afirst |
# endif |
# ifdef bgr |
# undef bgr |
# endif |
} |
} |
static int |
make_gray_file_colormap(png_image_read_control *display) |
{ |
unsigned int i; |
for (i=0; i<256; ++i) |
png_create_colormap_entry(display, i, i, i, i, 255, E_FILE); |
return i; |
} |
static int |
make_gray_colormap(png_image_read_control *display) |
{ |
unsigned int i; |
for (i=0; i<256; ++i) |
png_create_colormap_entry(display, i, i, i, i, 255, E_sRGB); |
return i; |
} |
#define PNG_GRAY_COLORMAP_ENTRIES 256 |
static int |
make_ga_colormap(png_image_read_control *display) |
{ |
unsigned int i, a; |
/* Alpha is retained, the output will be a color-map with entries |
* selected by six levels of alpha. One transparent entry, 6 gray |
* levels for all the intermediate alpha values, leaving 230 entries |
* for the opaque grays. The color-map entries are the six values |
* [0..5]*51, the GA processing uses PNG_DIV51(value) to find the |
* relevant entry. |
* |
* if (alpha > 229) // opaque |
* { |
* // The 231 entries are selected to make the math below work: |
* base = 0; |
* entry = (231 * gray + 128) >> 8; |
* } |
* else if (alpha < 26) // transparent |
* { |
* base = 231; |
* entry = 0; |
* } |
* else // partially opaque |
* { |
* base = 226 + 6 * PNG_DIV51(alpha); |
* entry = PNG_DIV51(gray); |
* } |
*/ |
i = 0; |
while (i < 231) |
{ |
unsigned int gray = (i * 256 + 115) / 231; |
png_create_colormap_entry(display, i++, gray, gray, gray, 255, E_sRGB); |
} |
/* 255 is used here for the component values for consistency with the code |
* that undoes premultiplication in pngwrite.c. |
*/ |
png_create_colormap_entry(display, i++, 255, 255, 255, 0, E_sRGB); |
for (a=1; a<5; ++a) |
{ |
unsigned int g; |
for (g=0; g<6; ++g) |
png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51, |
E_sRGB); |
} |
return i; |
} |
#define PNG_GA_COLORMAP_ENTRIES 256 |
static int |
make_rgb_colormap(png_image_read_control *display) |
{ |
unsigned int i, r; |
/* Build a 6x6x6 opaque RGB cube */ |
for (i=r=0; r<6; ++r) |
{ |
unsigned int g; |
for (g=0; g<6; ++g) |
{ |
unsigned int b; |
for (b=0; b<6; ++b) |
png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255, |
E_sRGB); |
} |
} |
return i; |
} |
#define PNG_RGB_COLORMAP_ENTRIES 216 |
/* Return a palette index to the above palette given three 8-bit sRGB values. */ |
#define PNG_RGB_INDEX(r,g,b) \ |
((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b))) |
static int |
png_image_read_colormap(png_voidp argument) |
{ |
png_image_read_control *display = |
png_voidcast(png_image_read_control*, argument); |
const png_imagep image = display->image; |
const png_structrp png_ptr = image->opaque->png_ptr; |
const png_uint_32 output_format = image->format; |
const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) ? |
E_LINEAR : E_sRGB; |
unsigned int cmap_entries; |
unsigned int output_processing; /* Output processing option */ |
unsigned int data_encoding = E_NOTSET; /* Encoding libpng must produce */ |
/* Background information; the background color and the index of this color |
* in the color-map if it exists (else 256). |
*/ |
unsigned int background_index = 256; |
png_uint_32 back_r, back_g, back_b; |
/* Flags to accumulate things that need to be done to the input. */ |
int expand_tRNS = 0; |
/* Exclude the NYI feature of compositing onto a color-mapped buffer; it is |
* very difficult to do, the results look awful, and it is difficult to see |
* what possible use it is because the application can't control the |
* color-map. |
*/ |
if (((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0 || |
png_ptr->num_trans > 0) /* alpha in input */ && |
((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */) |
{ |
if (output_encoding == E_LINEAR) /* compose on black */ |
back_b = back_g = back_r = 0; |
else if (display->background == NULL /* no way to remove it */) |
png_error(png_ptr, |
"a background color must be supplied to remove alpha/transparency"); |
/* Get a copy of the background color (this avoids repeating the checks |
* below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the |
* output format. |
*/ |
else |
{ |
back_g = display->background->green; |
if (output_format & PNG_FORMAT_FLAG_COLOR) |
{ |
back_r = display->background->red; |
back_b = display->background->blue; |
} |
else |
back_b = back_r = back_g; |
} |
} |
else if (output_encoding == E_LINEAR) |
back_b = back_r = back_g = 65535; |
else |
back_b = back_r = back_g = 255; |
/* Default the input file gamma if required - this is necessary because |
* libpng assumes that if no gamma information is present the data is in the |
* output format, but the simplified API deduces the gamma from the input |
* format. |
*/ |
if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) == 0) |
{ |
/* Do this directly, not using the png_colorspace functions, to ensure |
* that it happens even if the colorspace is invalid (though probably if |
* it is the setting will be ignored) Note that the same thing can be |
* achieved at the application interface with png_set_gAMA. |
*/ |
if (png_ptr->bit_depth == 16 && |
(image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0) |
png_ptr->colorspace.gamma = PNG_GAMMA_LINEAR; |
else |
png_ptr->colorspace.gamma = PNG_GAMMA_sRGB_INVERSE; |
png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; |
} |
/* Decide what to do based on the PNG color type of the input data. The |
* utility function png_create_colormap_entry deals with most aspects of the |
* output transformations; this code works out how to produce bytes of |
* color-map entries from the original format. |
*/ |
switch (png_ptr->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
if (png_ptr->bit_depth <= 8) |
{ |
/* There at most 256 colors in the output, regardless of |
* transparency. |
*/ |
unsigned int step, i, val, trans = 256/*ignore*/, back_alpha = 0; |
cmap_entries = 1U << png_ptr->bit_depth; |
if (cmap_entries > image->colormap_entries) |
png_error(png_ptr, "gray[8] color-map: too few entries"); |
step = 255 / (cmap_entries - 1); |
output_processing = PNG_CMAP_NONE; |
/* If there is a tRNS chunk then this either selects a transparent |
* value or, if the output has no alpha, the background color. |
*/ |
if (png_ptr->num_trans > 0) |
{ |
trans = png_ptr->trans_color.gray; |
if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) |
back_alpha = output_encoding == E_LINEAR ? 65535 : 255; |
} |
/* png_create_colormap_entry just takes an RGBA and writes the |
* corresponding color-map entry using the format from 'image', |
* including the required conversion to sRGB or linear as |
* appropriate. The input values are always either sRGB (if the |
* gamma correction flag is 0) or 0..255 scaled file encoded values |
* (if the function must gamma correct them). |
*/ |
for (i=val=0; i<cmap_entries; ++i, val += step) |
{ |
/* 'i' is a file value. While this will result in duplicated |
* entries for 8-bit non-sRGB encoded files it is necessary to |
* have non-gamma corrected values to do tRNS handling. |
*/ |
if (i != trans) |
png_create_colormap_entry(display, i, val, val, val, 255, |
E_FILE/*8-bit with file gamma*/); |
/* Else this entry is transparent. The colors don't matter if |
* there is an alpha channel (back_alpha == 0), but it does no |
* harm to pass them in; the values are not set above so this |
* passes in white. |
* |
* NOTE: this preserves the full precision of the application |
* supplied background color when it is used. |
*/ |
else |
png_create_colormap_entry(display, i, back_r, back_g, back_b, |
back_alpha, output_encoding); |
} |
/* We need libpng to preserve the original encoding. */ |
data_encoding = E_FILE; |
/* The rows from libpng, while technically gray values, are now also |
* color-map indicies; however, they may need to be expanded to 1 |
* byte per pixel. This is what png_set_packing does (i.e., it |
* unpacks the bit values into bytes.) |
*/ |
if (png_ptr->bit_depth < 8) |
png_set_packing(png_ptr); |
} |
else /* bit depth is 16 */ |
{ |
/* The 16-bit input values can be converted directly to 8-bit gamma |
* encoded values; however, if a tRNS chunk is present 257 color-map |
* entries are required. This means that the extra entry requires |
* special processing; add an alpha channel, sacrifice gray level |
* 254 and convert transparent (alpha==0) entries to that. |
* |
* Use libpng to chop the data to 8 bits. Convert it to sRGB at the |
* same time to minimize quality loss. If a tRNS chunk is present |
* this means libpng must handle it too; otherwise it is impossible |
* to do the exact match on the 16-bit value. |
* |
* If the output has no alpha channel *and* the background color is |
* gray then it is possible to let libpng handle the substitution by |
* ensuring that the corresponding gray level matches the background |
* color exactly. |
*/ |
data_encoding = E_sRGB; |
if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "gray[16] color-map: too few entries"); |
cmap_entries = make_gray_colormap(display); |
if (png_ptr->num_trans > 0) |
{ |
unsigned int back_alpha; |
if (output_format & PNG_FORMAT_FLAG_ALPHA) |
back_alpha = 0; |
else |
{ |
if (back_r == back_g && back_g == back_b) |
{ |
/* Background is gray; no special processing will be |
* required. |
*/ |
png_color_16 c; |
png_uint_32 gray = back_g; |
if (output_encoding == E_LINEAR) |
{ |
gray = PNG_sRGB_FROM_LINEAR(gray * 255); |
/* And make sure the corresponding palette entry |
* matches. |
*/ |
png_create_colormap_entry(display, gray, back_g, back_g, |
back_g, 65535, E_LINEAR); |
} |
/* The background passed to libpng, however, must be the |
* sRGB value. |
*/ |
c.index = 0; /*unused*/ |
c.gray = c.red = c.green = c.blue = (png_uint_16)gray; |
/* NOTE: does this work without expanding tRNS to alpha? |
* It should be the color->gray case below apparently |
* doesn't. |
*/ |
png_set_background_fixed(png_ptr, &c, |
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, |
0/*gamma: not used*/); |
output_processing = PNG_CMAP_NONE; |
break; |
} |
back_alpha = output_encoding == E_LINEAR ? 65535 : 255; |
} |
/* output_processing means that the libpng-processed row will be |
* 8-bit GA and it has to be processing to single byte color-map |
* values. Entry 254 is replaced by either a completely |
* transparent entry or by the background color at full |
* precision (and the background color is not a simple gray leve |
* in this case.) |
*/ |
expand_tRNS = 1; |
output_processing = PNG_CMAP_TRANS; |
background_index = 254; |
/* And set (overwrite) color-map entry 254 to the actual |
* background color at full precision. |
*/ |
png_create_colormap_entry(display, 254, back_r, back_g, back_b, |
back_alpha, output_encoding); |
} |
else |
output_processing = PNG_CMAP_NONE; |
} |
break; |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
/* 8-bit or 16-bit PNG with two channels - gray and alpha. A minimum |
* of 65536 combinations. If, however, the alpha channel is to be |
* removed there are only 256 possibilities if the background is gray. |
* (Otherwise there is a subset of the 65536 possibilities defined by |
* the triangle between black, white and the background color.) |
* |
* Reduce 16-bit files to 8-bit and sRGB encode the result. No need to |
* worry about tRNS matching - tRNS is ignored if there is an alpha |
* channel. |
*/ |
data_encoding = E_sRGB; |
if (output_format & PNG_FORMAT_FLAG_ALPHA) |
{ |
if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "gray+alpha color-map: too few entries"); |
cmap_entries = make_ga_colormap(display); |
background_index = PNG_CMAP_GA_BACKGROUND; |
output_processing = PNG_CMAP_GA; |
} |
else /* alpha is removed */ |
{ |
/* Alpha must be removed as the PNG data is processed when the |
* background is a color because the G and A channels are |
* independent and the vector addition (non-parallel vectors) is a |
* 2-D problem. |
* |
* This can be reduced to the same algorithm as above by making a |
* colormap containing gray levels (for the opaque grays), a |
* background entry (for a transparent pixel) and a set of four six |
* level color values, one set for each intermediate alpha value. |
* See the comments in make_ga_colormap for how this works in the |
* per-pixel processing. |
* |
* If the background is gray, however, we only need a 256 entry gray |
* level color map. It is sufficient to make the entry generated |
* for the background color be exactly the color specified. |
*/ |
if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0 || |
(back_r == back_g && back_g == back_b)) |
{ |
/* Background is gray; no special processing will be required. */ |
png_color_16 c; |
png_uint_32 gray = back_g; |
if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "gray-alpha color-map: too few entries"); |
cmap_entries = make_gray_colormap(display); |
if (output_encoding == E_LINEAR) |
{ |
gray = PNG_sRGB_FROM_LINEAR(gray * 255); |
/* And make sure the corresponding palette entry matches. */ |
png_create_colormap_entry(display, gray, back_g, back_g, |
back_g, 65535, E_LINEAR); |
} |
/* The background passed to libpng, however, must be the sRGB |
* value. |
*/ |
c.index = 0; /*unused*/ |
c.gray = c.red = c.green = c.blue = (png_uint_16)gray; |
png_set_background_fixed(png_ptr, &c, |
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, |
0/*gamma: not used*/); |
output_processing = PNG_CMAP_NONE; |
} |
else |
{ |
png_uint_32 i, a; |
/* This is the same as png_make_ga_colormap, above, except that |
* the entries are all opaque. |
*/ |
if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "ga-alpha color-map: too few entries"); |
i = 0; |
while (i < 231) |
{ |
png_uint_32 gray = (i * 256 + 115) / 231; |
png_create_colormap_entry(display, i++, gray, gray, gray, |
255, E_sRGB); |
} |
/* NOTE: this preserves the full precision of the application |
* background color. |
*/ |
background_index = i; |
png_create_colormap_entry(display, i++, back_r, back_g, back_b, |
output_encoding == E_LINEAR ? 65535U : 255U, output_encoding); |
/* For non-opaque input composite on the sRGB background - this |
* requires inverting the encoding for each component. The input |
* is still converted to the sRGB encoding because this is a |
* reasonable approximate to the logarithmic curve of human |
* visual sensitivity, at least over the narrow range which PNG |
* represents. Consequently 'G' is always sRGB encoded, while |
* 'A' is linear. We need the linear background colors. |
*/ |
if (output_encoding == E_sRGB) /* else already linear */ |
{ |
/* This may produce a value not exactly matching the |
* background, but that's ok because these numbers are only |
* used when alpha != 0 |
*/ |
back_r = png_sRGB_table[back_r]; |
back_g = png_sRGB_table[back_g]; |
back_b = png_sRGB_table[back_b]; |
} |
for (a=1; a<5; ++a) |
{ |
unsigned int g; |
/* PNG_sRGB_FROM_LINEAR expects a 16-bit linear value scaled |
* by an 8-bit alpha value (0..255). |
*/ |
png_uint_32 alpha = 51 * a; |
png_uint_32 back_rx = (255-alpha) * back_r; |
png_uint_32 back_gx = (255-alpha) * back_g; |
png_uint_32 back_bx = (255-alpha) * back_b; |
for (g=0; g<6; ++g) |
{ |
png_uint_32 gray = png_sRGB_table[g*51] * alpha; |
png_create_colormap_entry(display, i++, |
PNG_sRGB_FROM_LINEAR(gray + back_rx), |
PNG_sRGB_FROM_LINEAR(gray + back_gx), |
PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, E_sRGB); |
} |
} |
cmap_entries = i; |
output_processing = PNG_CMAP_GA; |
} |
} |
break; |
case PNG_COLOR_TYPE_RGB: |
case PNG_COLOR_TYPE_RGB_ALPHA: |
/* Exclude the case where the output is gray; we can always handle this |
* with the cases above. |
*/ |
if ((output_format & PNG_FORMAT_FLAG_COLOR) == 0) |
{ |
/* The color-map will be grayscale, so we may as well convert the |
* input RGB values to a simple grayscale and use the grayscale |
* code above. |
* |
* NOTE: calling this apparently damages the recognition of the |
* transparent color in background color handling; call |
* png_set_tRNS_to_alpha before png_set_background_fixed. |
*/ |
png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1, |
-1); |
data_encoding = E_sRGB; |
/* The output will now be one or two 8-bit gray or gray+alpha |
* channels. The more complex case arises when the input has alpha. |
*/ |
if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
png_ptr->num_trans > 0) && |
(output_format & PNG_FORMAT_FLAG_ALPHA) != 0) |
{ |
/* Both input and output have an alpha channel, so no background |
* processing is required; just map the GA bytes to the right |
* color-map entry. |
*/ |
expand_tRNS = 1; |
if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "rgb[ga] color-map: too few entries"); |
cmap_entries = make_ga_colormap(display); |
background_index = PNG_CMAP_GA_BACKGROUND; |
output_processing = PNG_CMAP_GA; |
} |
else |
{ |
/* Either the input or the output has no alpha channel, so there |
* will be no non-opaque pixels in the color-map; it will just be |
* grayscale. |
*/ |
if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "rgb[gray] color-map: too few entries"); |
/* Ideally this code would use libpng to do the gamma correction, |
* but if an input alpha channel is to be removed we will hit the |
* libpng bug in gamma+compose+rgb-to-gray (the double gamma |
* correction bug). Fix this by dropping the gamma correction in |
* this case and doing it in the palette; this will result in |
* duplicate palette entries, but that's better than the |
* alternative of double gamma correction. |
*/ |
if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
png_ptr->num_trans > 0) && |
png_gamma_not_sRGB(png_ptr->colorspace.gamma)) |
{ |
cmap_entries = make_gray_file_colormap(display); |
data_encoding = E_FILE; |
} |
else |
cmap_entries = make_gray_colormap(display); |
/* But if the input has alpha or transparency it must be removed |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
png_ptr->num_trans > 0) |
{ |
png_color_16 c; |
png_uint_32 gray = back_g; |
/* We need to ensure that the application background exists in |
* the colormap and that completely transparent pixels map to |
* it. Achieve this simply by ensuring that the entry |
* selected for the background really is the background color. |
*/ |
if (data_encoding == E_FILE) /* from the fixup above */ |
{ |
/* The app supplied a gray which is in output_encoding, we |
* need to convert it to a value of the input (E_FILE) |
* encoding then set this palette entry to the required |
* output encoding. |
*/ |
if (output_encoding == E_sRGB) |
gray = png_sRGB_table[gray]; /* now E_LINEAR */ |
gray = PNG_DIV257(png_gamma_16bit_correct(gray, |
png_ptr->colorspace.gamma)); /* now E_FILE */ |
/* And make sure the corresponding palette entry contains |
* exactly the required sRGB value. |
*/ |
png_create_colormap_entry(display, gray, back_g, back_g, |
back_g, 0/*unused*/, output_encoding); |
} |
else if (output_encoding == E_LINEAR) |
{ |
gray = PNG_sRGB_FROM_LINEAR(gray * 255); |
/* And make sure the corresponding palette entry matches. |
*/ |
png_create_colormap_entry(display, gray, back_g, back_g, |
back_g, 0/*unused*/, E_LINEAR); |
} |
/* The background passed to libpng, however, must be the |
* output (normally sRGB) value. |
*/ |
c.index = 0; /*unused*/ |
c.gray = c.red = c.green = c.blue = (png_uint_16)gray; |
/* NOTE: the following is apparently a bug in libpng. Without |
* it the transparent color recognition in |
* png_set_background_fixed seems to go wrong. |
*/ |
expand_tRNS = 1; |
png_set_background_fixed(png_ptr, &c, |
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, |
0/*gamma: not used*/); |
} |
output_processing = PNG_CMAP_NONE; |
} |
} |
else /* output is color */ |
{ |
/* We could use png_quantize here so long as there is no transparent |
* color or alpha; png_quantize ignores alpha. Easier overall just |
* to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube. |
* Consequently we always want libpng to produce sRGB data. |
*/ |
data_encoding = E_sRGB; |
/* Is there any transparency or alpha? */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
png_ptr->num_trans > 0) |
{ |
/* Is there alpha in the output too? If so all four channels are |
* processed into a special RGB cube with alpha support. |
*/ |
if (output_format & PNG_FORMAT_FLAG_ALPHA) |
{ |
png_uint_32 r; |
if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries) |
png_error(png_ptr, "rgb+alpha color-map: too few entries"); |
cmap_entries = make_rgb_colormap(display); |
/* Add a transparent entry. */ |
png_create_colormap_entry(display, cmap_entries, 255, 255, |
255, 0, E_sRGB); |
/* This is stored as the background index for the processing |
* algorithm. |
*/ |
background_index = cmap_entries++; |
/* Add 27 r,g,b entries each with alpha 0.5. */ |
for (r=0; r<256; r = (r << 1) | 0x7f) |
{ |
png_uint_32 g; |
for (g=0; g<256; g = (g << 1) | 0x7f) |
{ |
png_uint_32 b; |
/* This generates components with the values 0, 127 and |
* 255 |
*/ |
for (b=0; b<256; b = (b << 1) | 0x7f) |
png_create_colormap_entry(display, cmap_entries++, |
r, g, b, 128, E_sRGB); |
} |
} |
expand_tRNS = 1; |
output_processing = PNG_CMAP_RGB_ALPHA; |
} |
else |
{ |
/* Alpha/transparency must be removed. The background must |
* exist in the color map (achieved by setting adding it after |
* the 666 color-map). If the standard processing code will |
* pick up this entry automatically that's all that is |
* required; libpng can be called to do the background |
* processing. |
*/ |
unsigned int sample_size = |
PNG_IMAGE_SAMPLE_SIZE(output_format); |
png_uint_32 r, g, b; /* sRGB background */ |
if (PNG_RGB_COLORMAP_ENTRIES+1+27 > image->colormap_entries) |
png_error(png_ptr, "rgb-alpha color-map: too few entries"); |
cmap_entries = make_rgb_colormap(display); |
png_create_colormap_entry(display, cmap_entries, back_r, |
back_g, back_b, 0/*unused*/, output_encoding); |
if (output_encoding == E_LINEAR) |
{ |
r = PNG_sRGB_FROM_LINEAR(back_r * 255); |
g = PNG_sRGB_FROM_LINEAR(back_g * 255); |
b = PNG_sRGB_FROM_LINEAR(back_b * 255); |
} |
else |
{ |
r = back_r; |
g = back_g; |
b = back_g; |
} |
/* Compare the newly-created color-map entry with the one the |
* PNG_CMAP_RGB algorithm will use. If the two entries don't |
* match, add the new one and set this as the background |
* index. |
*/ |
if (memcmp((png_const_bytep)display->colormap + |
sample_size * cmap_entries, |
(png_const_bytep)display->colormap + |
sample_size * PNG_RGB_INDEX(r,g,b), |
sample_size) != 0) |
{ |
/* The background color must be added. */ |
background_index = cmap_entries++; |
/* Add 27 r,g,b entries each with created by composing with |
* the background at alpha 0.5. |
*/ |
for (r=0; r<256; r = (r << 1) | 0x7f) |
{ |
for (g=0; g<256; g = (g << 1) | 0x7f) |
{ |
/* This generates components with the values 0, 127 |
* and 255 |
*/ |
for (b=0; b<256; b = (b << 1) | 0x7f) |
png_create_colormap_entry(display, cmap_entries++, |
png_colormap_compose(display, r, E_sRGB, 128, |
back_r, output_encoding), |
png_colormap_compose(display, g, E_sRGB, 128, |
back_g, output_encoding), |
png_colormap_compose(display, b, E_sRGB, 128, |
back_b, output_encoding), |
0/*unused*/, output_encoding); |
} |
} |
expand_tRNS = 1; |
output_processing = PNG_CMAP_RGB_ALPHA; |
} |
else /* background color is in the standard color-map */ |
{ |
png_color_16 c; |
c.index = 0; /*unused*/ |
c.red = (png_uint_16)back_r; |
c.gray = c.green = (png_uint_16)back_g; |
c.blue = (png_uint_16)back_b; |
png_set_background_fixed(png_ptr, &c, |
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, |
0/*gamma: not used*/); |
output_processing = PNG_CMAP_RGB; |
} |
} |
} |
else /* no alpha or transparency in the input */ |
{ |
/* Alpha in the output is irrelevant, simply map the opaque input |
* pixels to the 6x6x6 color-map. |
*/ |
if (PNG_RGB_COLORMAP_ENTRIES > image->colormap_entries) |
png_error(png_ptr, "rgb color-map: too few entries"); |
cmap_entries = make_rgb_colormap(display); |
output_processing = PNG_CMAP_RGB; |
} |
} |
break; |
case PNG_COLOR_TYPE_PALETTE: |
/* It's already got a color-map. It may be necessary to eliminate the |
* tRNS entries though. |
*/ |
{ |
unsigned int num_trans = png_ptr->num_trans; |
png_const_bytep trans = num_trans > 0 ? png_ptr->trans_alpha : NULL; |
png_const_colorp colormap = png_ptr->palette; |
const int do_background = trans != NULL && |
(output_format & PNG_FORMAT_FLAG_ALPHA) == 0; |
unsigned int i; |
/* Just in case: */ |
if (trans == NULL) |
num_trans = 0; |
output_processing = PNG_CMAP_NONE; |
data_encoding = E_FILE; /* Don't change from color-map indicies */ |
cmap_entries = png_ptr->num_palette; |
if (cmap_entries > 256) |
cmap_entries = 256; |
if (cmap_entries > image->colormap_entries) |
png_error(png_ptr, "palette color-map: too few entries"); |
for (i=0; i < cmap_entries; ++i) |
{ |
if (do_background && i < num_trans && trans[i] < 255) |
{ |
if (trans[i] == 0) |
png_create_colormap_entry(display, i, back_r, back_g, |
back_b, 0, output_encoding); |
else |
{ |
/* Must compose the PNG file color in the color-map entry |
* on the sRGB color in 'back'. |
*/ |
png_create_colormap_entry(display, i, |
png_colormap_compose(display, colormap[i].red, E_FILE, |
trans[i], back_r, output_encoding), |
png_colormap_compose(display, colormap[i].green, E_FILE, |
trans[i], back_g, output_encoding), |
png_colormap_compose(display, colormap[i].blue, E_FILE, |
trans[i], back_b, output_encoding), |
output_encoding == E_LINEAR ? trans[i] * 257U : |
trans[i], |
output_encoding); |
} |
} |
else |
png_create_colormap_entry(display, i, colormap[i].red, |
colormap[i].green, colormap[i].blue, |
i < num_trans ? trans[i] : 255U, E_FILE/*8-bit*/); |
} |
/* The PNG data may have indicies packed in fewer than 8 bits, it |
* must be expanded if so. |
*/ |
if (png_ptr->bit_depth < 8) |
png_set_packing(png_ptr); |
} |
break; |
default: |
png_error(png_ptr, "invalid PNG color type"); |
/*NOT REACHED*/ |
break; |
} |
/* Now deal with the output processing */ |
if (expand_tRNS && png_ptr->num_trans > 0 && |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0) |
png_set_tRNS_to_alpha(png_ptr); |
switch (data_encoding) |
{ |
default: |
png_error(png_ptr, "bad data option (internal error)"); |
break; |
case E_sRGB: |
/* Change to 8-bit sRGB */ |
png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB); |
/* FALL THROUGH */ |
case E_FILE: |
if (png_ptr->bit_depth > 8) |
png_set_scale_16(png_ptr); |
break; |
} |
if (cmap_entries > 256 || cmap_entries > image->colormap_entries) |
png_error(png_ptr, "color map overflow (BAD internal error)"); |
image->colormap_entries = cmap_entries; |
/* Double check using the recorded background index */ |
switch (output_processing) |
{ |
case PNG_CMAP_NONE: |
if (background_index != PNG_CMAP_NONE_BACKGROUND) |
goto bad_background; |
break; |
case PNG_CMAP_GA: |
if (background_index != PNG_CMAP_GA_BACKGROUND) |
goto bad_background; |
break; |
case PNG_CMAP_TRANS: |
if (background_index >= cmap_entries || |
background_index != PNG_CMAP_TRANS_BACKGROUND) |
goto bad_background; |
break; |
case PNG_CMAP_RGB: |
if (background_index != PNG_CMAP_RGB_BACKGROUND) |
goto bad_background; |
break; |
case PNG_CMAP_RGB_ALPHA: |
if (background_index != PNG_CMAP_RGB_ALPHA_BACKGROUND) |
goto bad_background; |
break; |
default: |
png_error(png_ptr, "bad processing option (internal error)"); |
bad_background: |
png_error(png_ptr, "bad background index (internal error)"); |
} |
display->colormap_processing = output_processing; |
return 1/*ok*/; |
} |
/* The final part of the color-map read called from png_image_finish_read. */ |
static int |
png_image_read_and_map(png_voidp argument) |
{ |
png_image_read_control *display = png_voidcast(png_image_read_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
int passes; |
/* Called when the libpng data must be transformed into the color-mapped |
* form. There is a local row buffer in display->local and this routine must |
* do the interlace handling. |
*/ |
switch (png_ptr->interlaced) |
{ |
case PNG_INTERLACE_NONE: |
passes = 1; |
break; |
case PNG_INTERLACE_ADAM7: |
passes = PNG_INTERLACE_ADAM7_PASSES; |
break; |
default: |
passes = 0; |
png_error(png_ptr, "unknown interlace type"); |
} |
{ |
png_uint_32 height = image->height; |
png_uint_32 width = image->width; |
int proc = display->colormap_processing; |
png_bytep first_row = png_voidcast(png_bytep, display->first_row); |
ptrdiff_t step_row = display->row_bytes; |
int pass; |
for (pass = 0; pass < passes; ++pass) |
{ |
unsigned int startx, stepx, stepy; |
png_uint_32 y; |
if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) |
{ |
/* The row may be empty for a short image: */ |
if (PNG_PASS_COLS(width, pass) == 0) |
continue; |
startx = PNG_PASS_START_COL(pass); |
stepx = PNG_PASS_COL_OFFSET(pass); |
y = PNG_PASS_START_ROW(pass); |
stepy = PNG_PASS_ROW_OFFSET(pass); |
} |
else |
{ |
y = 0; |
startx = 0; |
stepx = stepy = 1; |
} |
for (; y<height; y += stepy) |
{ |
png_bytep inrow = png_voidcast(png_bytep, display->local_row); |
png_bytep outrow = first_row + y * step_row; |
png_const_bytep end_row = outrow + width; |
/* Read read the libpng data into the temporary buffer. */ |
png_read_row(png_ptr, inrow, NULL); |
/* Now process the row according to the processing option, note |
* that the caller verifies that the format of the libpng output |
* data is as required. |
*/ |
outrow += startx; |
switch (proc) |
{ |
case PNG_CMAP_GA: |
for (; outrow < end_row; outrow += stepx) |
{ |
/* The data is always in the PNG order */ |
unsigned int gray = *inrow++; |
unsigned int alpha = *inrow++; |
unsigned int entry; |
/* NOTE: this code is copied as a comment in |
* make_ga_colormap above. Please update the |
* comment if you change this code! |
*/ |
if (alpha > 229) /* opaque */ |
{ |
entry = (231 * gray + 128) >> 8; |
} |
else if (alpha < 26) /* transparent */ |
{ |
entry = 231; |
} |
else /* partially opaque */ |
{ |
entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray); |
} |
*outrow = (png_byte)entry; |
} |
break; |
case PNG_CMAP_TRANS: |
for (; outrow < end_row; outrow += stepx) |
{ |
png_byte gray = *inrow++; |
png_byte alpha = *inrow++; |
if (alpha == 0) |
*outrow = PNG_CMAP_TRANS_BACKGROUND; |
else if (gray != PNG_CMAP_TRANS_BACKGROUND) |
*outrow = gray; |
else |
*outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1); |
} |
break; |
case PNG_CMAP_RGB: |
for (; outrow < end_row; outrow += stepx) |
{ |
*outrow = PNG_RGB_INDEX(inrow[0], inrow[1], inrow[2]); |
inrow += 3; |
} |
break; |
case PNG_CMAP_RGB_ALPHA: |
for (; outrow < end_row; outrow += stepx) |
{ |
unsigned int alpha = inrow[3]; |
/* Because the alpha entries only hold alpha==0.5 values |
* split the processing at alpha==0.25 (64) and 0.75 |
* (196). |
*/ |
if (alpha >= 196) |
*outrow = PNG_RGB_INDEX(inrow[0], inrow[1], |
inrow[2]); |
else if (alpha < 64) |
*outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND; |
else |
{ |
/* Likewise there are three entries for each of r, g |
* and b. We could select the entry by popcount on |
* the top two bits on those architectures that |
* support it, this is what the code below does, |
* crudely. |
*/ |
unsigned int back_i = PNG_CMAP_RGB_ALPHA_BACKGROUND+1; |
/* Here are how the values map: |
* |
* 0x00 .. 0x3f -> 0 |
* 0x40 .. 0xbf -> 1 |
* 0xc0 .. 0xff -> 2 |
* |
* So, as above with the explicit alpha checks, the |
* breakpoints are at 64 and 196. |
*/ |
if (inrow[0] & 0x80) back_i += 9; /* red */ |
if (inrow[0] & 0x40) back_i += 9; |
if (inrow[0] & 0x80) back_i += 3; /* green */ |
if (inrow[0] & 0x40) back_i += 3; |
if (inrow[0] & 0x80) back_i += 1; /* blue */ |
if (inrow[0] & 0x40) back_i += 1; |
*outrow = (png_byte)back_i; |
} |
inrow += 4; |
} |
break; |
default: |
break; |
} |
} |
} |
} |
return 1; |
} |
static int |
png_image_read_colormapped(png_voidp argument) |
{ |
png_image_read_control *display = png_voidcast(png_image_read_control*, |
argument); |
png_imagep image = display->image; |
png_controlp control = image->opaque; |
png_structrp png_ptr = control->png_ptr; |
png_inforp info_ptr = control->info_ptr; |
int passes = 0; /* As a flag */ |
PNG_SKIP_CHUNKS(png_ptr); |
/* Update the 'info' structure and make sure the result is as required; first |
* make sure to turn on the interlace handling if it will be required |
* (because it can't be turned on *after* the call to png_read_update_info!) |
*/ |
if (display->colormap_processing == PNG_CMAP_NONE) |
passes = png_set_interlace_handling(png_ptr); |
png_read_update_info(png_ptr, info_ptr); |
/* The expected output can be deduced from the colormap_processing option. */ |
switch (display->colormap_processing) |
{ |
case PNG_CMAP_NONE: |
/* Output must be one channel and one byte per pixel, the output |
* encoding can be anything. |
*/ |
if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE || |
info_ptr->color_type == PNG_COLOR_TYPE_GRAY) && |
info_ptr->bit_depth == 8) |
break; |
goto bad_output; |
case PNG_CMAP_TRANS: |
case PNG_CMAP_GA: |
/* Output must be two channels and the 'G' one must be sRGB, the latter |
* can be checked with an exact number because it should have been set |
* to this number above! |
*/ |
if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
info_ptr->bit_depth == 8 && |
png_ptr->screen_gamma == PNG_GAMMA_sRGB && |
image->colormap_entries == 256) |
break; |
goto bad_output; |
case PNG_CMAP_RGB: |
/* Output must be 8-bit sRGB encoded RGB */ |
if (info_ptr->color_type == PNG_COLOR_TYPE_RGB && |
info_ptr->bit_depth == 8 && |
png_ptr->screen_gamma == PNG_GAMMA_sRGB && |
image->colormap_entries == 216) |
break; |
goto bad_output; |
case PNG_CMAP_RGB_ALPHA: |
/* Output must be 8-bit sRGB encoded RGBA */ |
if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
info_ptr->bit_depth == 8 && |
png_ptr->screen_gamma == PNG_GAMMA_sRGB && |
image->colormap_entries == 244 /* 216 + 1 + 27 */) |
break; |
/* goto bad_output; */ |
/* FALL THROUGH */ |
default: |
bad_output: |
png_error(png_ptr, "bad color-map processing (internal error)"); |
} |
/* Now read the rows. Do this here if it is possible to read directly into |
* the output buffer, otherwise allocate a local row buffer of the maximum |
* size libpng requires and call the relevant processing routine safely. |
*/ |
{ |
png_voidp first_row = display->buffer; |
ptrdiff_t row_bytes = display->row_stride; |
/* The following expression is designed to work correctly whether it gives |
* a signed or an unsigned result. |
*/ |
if (row_bytes < 0) |
{ |
char *ptr = png_voidcast(char*, first_row); |
ptr += (image->height-1) * (-row_bytes); |
first_row = png_voidcast(png_voidp, ptr); |
} |
display->first_row = first_row; |
display->row_bytes = row_bytes; |
} |
if (passes == 0) |
{ |
int result; |
png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); |
display->local_row = row; |
result = png_safe_execute(image, png_image_read_and_map, display); |
display->local_row = NULL; |
png_free(png_ptr, row); |
return result; |
} |
else |
{ |
png_alloc_size_t row_bytes = display->row_bytes; |
while (--passes >= 0) |
{ |
png_uint_32 y = image->height; |
png_bytep row = png_voidcast(png_bytep, display->first_row); |
while (y-- > 0) |
{ |
png_read_row(png_ptr, row, NULL); |
row += row_bytes; |
} |
} |
return 1; |
} |
} |
/* Just the row reading part of png_image_read. */ |
static int |
png_image_read_composite(png_voidp argument) |
{ |
png_image_read_control *display = png_voidcast(png_image_read_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
int passes; |
switch (png_ptr->interlaced) |
{ |
case PNG_INTERLACE_NONE: |
passes = 1; |
break; |
case PNG_INTERLACE_ADAM7: |
passes = PNG_INTERLACE_ADAM7_PASSES; |
break; |
default: |
passes = 0; |
png_error(png_ptr, "unknown interlace type"); |
} |
{ |
png_uint_32 height = image->height; |
png_uint_32 width = image->width; |
ptrdiff_t step_row = display->row_bytes; |
unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; |
int pass; |
for (pass = 0; pass < passes; ++pass) |
{ |
unsigned int startx, stepx, stepy; |
png_uint_32 y; |
if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) |
{ |
/* The row may be empty for a short image: */ |
if (PNG_PASS_COLS(width, pass) == 0) |
continue; |
startx = PNG_PASS_START_COL(pass) * channels; |
stepx = PNG_PASS_COL_OFFSET(pass) * channels; |
y = PNG_PASS_START_ROW(pass); |
stepy = PNG_PASS_ROW_OFFSET(pass); |
} |
else |
{ |
y = 0; |
startx = 0; |
stepx = channels; |
stepy = 1; |
} |
for (; y<height; y += stepy) |
{ |
png_bytep inrow = png_voidcast(png_bytep, display->local_row); |
png_bytep outrow; |
png_const_bytep end_row; |
/* Read the row, which is packed: */ |
png_read_row(png_ptr, inrow, NULL); |
outrow = png_voidcast(png_bytep, display->first_row); |
outrow += y * step_row; |
end_row = outrow + width * channels; |
/* Now do the composition on each pixel in this row. */ |
outrow += startx; |
for (; outrow < end_row; outrow += stepx) |
{ |
png_byte alpha = inrow[channels]; |
if (alpha > 0) /* else no change to the output */ |
{ |
unsigned int c; |
for (c=0; c<channels; ++c) |
{ |
png_uint_32 component = inrow[c]; |
if (alpha < 255) /* else just use component */ |
{ |
/* This is PNG_OPTIMIZED_ALPHA, the component value |
* is a linear 8-bit value. Combine this with the |
* current outrow[c] value which is sRGB encoded. |
* Arithmetic here is 16-bits to preserve the output |
* values correctly. |
*/ |
component *= 257*255; /* =65535 */ |
component += (255-alpha)*png_sRGB_table[outrow[c]]; |
/* So 'component' is scaled by 255*65535 and is |
* therefore appropriate for the sRGB to linear |
* conversion table. |
*/ |
component = PNG_sRGB_FROM_LINEAR(component); |
} |
outrow[c] = (png_byte)component; |
} |
} |
inrow += channels+1; /* components and alpha channel */ |
} |
} |
} |
} |
return 1; |
} |
/* The do_local_background case; called when all the following transforms are to |
* be done: |
* |
* PNG_RGB_TO_GRAY |
* PNG_COMPOSITE |
* PNG_GAMMA |
* |
* This is a work-round for the fact that both the PNG_RGB_TO_GRAY and |
* PNG_COMPOSITE code performs gamma correction, so we get double gamma |
* correction. The fix-up is to prevent the PNG_COMPOSITE operation happening |
* inside libpng, so this routine sees an 8 or 16-bit gray+alpha row and handles |
* the removal or pre-multiplication of the alpha channel. |
*/ |
static int |
png_image_read_background(png_voidp argument) |
{ |
png_image_read_control *display = png_voidcast(png_image_read_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
png_inforp info_ptr = image->opaque->info_ptr; |
png_uint_32 height = image->height; |
png_uint_32 width = image->width; |
int pass, passes; |
/* Double check the convoluted logic below. We expect to get here with |
* libpng doing rgb to gray and gamma correction but background processing |
* left to the png_image_read_background function. The rows libpng produce |
* might be 8 or 16-bit but should always have two channels; gray plus alpha. |
*/ |
if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == 0) |
png_error(png_ptr, "lost rgb to gray"); |
if ((png_ptr->transformations & PNG_COMPOSE) != 0) |
png_error(png_ptr, "unexpected compose"); |
if (png_get_channels(png_ptr, info_ptr) != 2) |
png_error(png_ptr, "lost/gained channels"); |
/* Expect the 8-bit case to always remove the alpha channel */ |
if ((image->format & PNG_FORMAT_FLAG_LINEAR) == 0 && |
(image->format & PNG_FORMAT_FLAG_ALPHA) != 0) |
png_error(png_ptr, "unexpected 8-bit transformation"); |
switch (png_ptr->interlaced) |
{ |
case PNG_INTERLACE_NONE: |
passes = 1; |
break; |
case PNG_INTERLACE_ADAM7: |
passes = PNG_INTERLACE_ADAM7_PASSES; |
break; |
default: |
passes = 0; |
png_error(png_ptr, "unknown interlace type"); |
} |
switch (png_get_bit_depth(png_ptr, info_ptr)) |
{ |
default: |
png_error(png_ptr, "unexpected bit depth"); |
break; |
case 8: |
/* 8-bit sRGB gray values with an alpha channel; the alpha channel is |
* to be removed by composing on a background: either the row if |
* display->background is NULL or display->background->green if not. |
* Unlike the code above ALPHA_OPTIMIZED has *not* been done. |
*/ |
{ |
png_bytep first_row = png_voidcast(png_bytep, display->first_row); |
ptrdiff_t step_row = display->row_bytes; |
for (pass = 0; pass < passes; ++pass) |
{ |
png_bytep row = png_voidcast(png_bytep, |
display->first_row); |
unsigned int startx, stepx, stepy; |
png_uint_32 y; |
if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) |
{ |
/* The row may be empty for a short image: */ |
if (PNG_PASS_COLS(width, pass) == 0) |
continue; |
startx = PNG_PASS_START_COL(pass); |
stepx = PNG_PASS_COL_OFFSET(pass); |
y = PNG_PASS_START_ROW(pass); |
stepy = PNG_PASS_ROW_OFFSET(pass); |
} |
else |
{ |
y = 0; |
startx = 0; |
stepx = stepy = 1; |
} |
if (display->background == NULL) |
{ |
for (; y<height; y += stepy) |
{ |
png_bytep inrow = png_voidcast(png_bytep, |
display->local_row); |
png_bytep outrow = first_row + y * step_row; |
png_const_bytep end_row = outrow + width; |
/* Read the row, which is packed: */ |
png_read_row(png_ptr, inrow, NULL); |
/* Now do the composition on each pixel in this row. */ |
outrow += startx; |
for (; outrow < end_row; outrow += stepx) |
{ |
png_byte alpha = inrow[1]; |
if (alpha > 0) /* else no change to the output */ |
{ |
png_uint_32 component = inrow[0]; |
if (alpha < 255) /* else just use component */ |
{ |
/* Since PNG_OPTIMIZED_ALPHA was not set it is |
* necessary to invert the sRGB transfer |
* function and multiply the alpha out. |
*/ |
component = png_sRGB_table[component] * alpha; |
component += png_sRGB_table[outrow[0]] * |
(255-alpha); |
component = PNG_sRGB_FROM_LINEAR(component); |
} |
outrow[0] = (png_byte)component; |
} |
inrow += 2; /* gray and alpha channel */ |
} |
} |
} |
else /* constant background value */ |
{ |
png_byte background8 = display->background->green; |
png_uint_16 background = png_sRGB_table[background8]; |
for (; y<height; y += stepy) |
{ |
png_bytep inrow = png_voidcast(png_bytep, |
display->local_row); |
png_bytep outrow = first_row + y * step_row; |
png_const_bytep end_row = outrow + width; |
/* Read the row, which is packed: */ |
png_read_row(png_ptr, inrow, NULL); |
/* Now do the composition on each pixel in this row. */ |
outrow += startx; |
for (; outrow < end_row; outrow += stepx) |
{ |
png_byte alpha = inrow[1]; |
if (alpha > 0) /* else use background */ |
{ |
png_uint_32 component = inrow[0]; |
if (alpha < 255) /* else just use component */ |
{ |
component = png_sRGB_table[component] * alpha; |
component += background * (255-alpha); |
component = PNG_sRGB_FROM_LINEAR(component); |
} |
outrow[0] = (png_byte)component; |
} |
else |
outrow[0] = background8; |
inrow += 2; /* gray and alpha channel */ |
} |
row += display->row_bytes; |
} |
} |
} |
} |
break; |
case 16: |
/* 16-bit linear with pre-multiplied alpha; the pre-multiplication must |
* still be done and, maybe, the alpha channel removed. This code also |
* handles the alpha-first option. |
*/ |
{ |
png_uint_16p first_row = png_voidcast(png_uint_16p, |
display->first_row); |
/* The division by two is safe because the caller passed in a |
* stride which was multiplied by 2 (below) to get row_bytes. |
*/ |
ptrdiff_t step_row = display->row_bytes / 2; |
int preserve_alpha = (image->format & PNG_FORMAT_FLAG_ALPHA) != 0; |
unsigned int outchannels = 1+preserve_alpha; |
int swap_alpha = 0; |
if (preserve_alpha && (image->format & PNG_FORMAT_FLAG_AFIRST)) |
swap_alpha = 1; |
for (pass = 0; pass < passes; ++pass) |
{ |
unsigned int startx, stepx, stepy; |
png_uint_32 y; |
/* The 'x' start and step are adjusted to output components here. |
*/ |
if (png_ptr->interlaced == PNG_INTERLACE_ADAM7) |
{ |
/* The row may be empty for a short image: */ |
if (PNG_PASS_COLS(width, pass) == 0) |
continue; |
startx = PNG_PASS_START_COL(pass) * outchannels; |
stepx = PNG_PASS_COL_OFFSET(pass) * outchannels; |
y = PNG_PASS_START_ROW(pass); |
stepy = PNG_PASS_ROW_OFFSET(pass); |
} |
else |
{ |
y = 0; |
startx = 0; |
stepx = outchannels; |
stepy = 1; |
} |
for (; y<height; y += stepy) |
{ |
png_const_uint_16p inrow; |
png_uint_16p outrow = first_row + y*step_row; |
png_uint_16p end_row = outrow + width * outchannels; |
/* Read the row, which is packed: */ |
png_read_row(png_ptr, png_voidcast(png_bytep, |
display->local_row), NULL); |
inrow = png_voidcast(png_const_uint_16p, display->local_row); |
/* Now do the pre-multiplication on each pixel in this row. |
*/ |
outrow += startx; |
for (; outrow < end_row; outrow += stepx) |
{ |
png_uint_32 component = inrow[0]; |
png_uint_16 alpha = inrow[1]; |
if (alpha > 0) /* else 0 */ |
{ |
if (alpha < 65535) /* else just use component */ |
{ |
component *= alpha; |
component += 32767; |
component /= 65535; |
} |
} |
else |
component = 0; |
outrow[swap_alpha] = (png_uint_16)component; |
if (preserve_alpha) |
outrow[1 ^ swap_alpha] = alpha; |
inrow += 2; /* components and alpha channel */ |
} |
} |
} |
} |
break; |
} |
return 1; |
} |
/* The guts of png_image_finish_read as a png_safe_execute callback. */ |
static int |
png_image_read_direct(png_voidp argument) |
{ |
png_image_read_control *display = png_voidcast(png_image_read_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
png_inforp info_ptr = image->opaque->info_ptr; |
png_uint_32 format = image->format; |
int linear = (format & PNG_FORMAT_FLAG_LINEAR) != 0; |
int do_local_compose = 0; |
int do_local_background = 0; /* to avoid double gamma correction bug */ |
int passes = 0; |
/* Add transforms to ensure the correct output format is produced then check |
* that the required implementation support is there. Always expand; always |
* need 8 bits minimum, no palette and expanded tRNS. |
*/ |
png_set_expand(png_ptr); |
/* Now check the format to see if it was modified. */ |
{ |
png_uint_32 base_format = png_image_format(png_ptr) & |
~PNG_FORMAT_FLAG_COLORMAP /* removed by png_set_expand */; |
png_uint_32 change = format ^ base_format; |
png_fixed_point output_gamma; |
int mode; /* alpha mode */ |
/* Do this first so that we have a record if rgb to gray is happening. */ |
if (change & PNG_FORMAT_FLAG_COLOR) |
{ |
/* gray<->color transformation required. */ |
if (format & PNG_FORMAT_FLAG_COLOR) |
png_set_gray_to_rgb(png_ptr); |
else |
{ |
/* libpng can't do both rgb to gray and |
* background/pre-multiplication if there is also significant gamma |
* correction, because both operations require linear colors and |
* the code only supports one transform doing the gamma correction. |
* Handle this by doing the pre-multiplication or background |
* operation in this code, if necessary. |
* |
* TODO: fix this by rewriting pngrtran.c (!) |
* |
* For the moment (given that fixing this in pngrtran.c is an |
* enormous change) 'do_local_background' is used to indicate that |
* the problem exists. |
*/ |
if (base_format & PNG_FORMAT_FLAG_ALPHA) |
do_local_background = 1/*maybe*/; |
png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, |
PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT); |
} |
change &= ~PNG_FORMAT_FLAG_COLOR; |
} |
/* Set the gamma appropriately, linear for 16-bit input, sRGB otherwise. |
*/ |
{ |
png_fixed_point input_gamma_default; |
if ((base_format & PNG_FORMAT_FLAG_LINEAR) && |
(image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0) |
input_gamma_default = PNG_GAMMA_LINEAR; |
else |
input_gamma_default = PNG_DEFAULT_sRGB; |
/* Call png_set_alpha_mode to set the default for the input gamma; the |
* output gamma is set by a second call below. |
*/ |
png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, input_gamma_default); |
} |
if (linear) |
{ |
/* If there *is* an alpha channel in the input it must be multiplied |
* out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG. |
*/ |
if (base_format & PNG_FORMAT_FLAG_ALPHA) |
mode = PNG_ALPHA_STANDARD; /* associated alpha */ |
else |
mode = PNG_ALPHA_PNG; |
output_gamma = PNG_GAMMA_LINEAR; |
} |
else |
{ |
mode = PNG_ALPHA_PNG; |
output_gamma = PNG_DEFAULT_sRGB; |
} |
/* If 'do_local_background' is set check for the presence of gamma |
* correction; this is part of the work-round for the libpng bug |
* described above. |
* |
* TODO: fix libpng and remove this. |
*/ |
if (do_local_background) |
{ |
png_fixed_point gtest; |
/* This is 'png_gamma_threshold' from pngrtran.c; the test used for |
* gamma correction, the screen gamma hasn't been set on png_struct |
* yet; it's set below. png_struct::gamma, however, is set to the |
* final value. |
*/ |
if (png_muldiv(>est, output_gamma, png_ptr->colorspace.gamma, |
PNG_FP_1) && !png_gamma_significant(gtest)) |
do_local_background = 0; |
else if (mode == PNG_ALPHA_STANDARD) |
{ |
do_local_background = 2/*required*/; |
mode = PNG_ALPHA_PNG; /* prevent libpng doing it */ |
} |
/* else leave as 1 for the checks below */ |
} |
/* If the bit-depth changes then handle that here. */ |
if (change & PNG_FORMAT_FLAG_LINEAR) |
{ |
if (linear /*16-bit output*/) |
png_set_expand_16(png_ptr); |
else /* 8-bit output */ |
png_set_scale_16(png_ptr); |
change &= ~PNG_FORMAT_FLAG_LINEAR; |
} |
/* Now the background/alpha channel changes. */ |
if (change & PNG_FORMAT_FLAG_ALPHA) |
{ |
/* Removing an alpha channel requires composition for the 8-bit |
* formats; for the 16-bit it is already done, above, by the |
* pre-multiplication and the channel just needs to be stripped. |
*/ |
if (base_format & PNG_FORMAT_FLAG_ALPHA) |
{ |
/* If RGB->gray is happening the alpha channel must be left and the |
* operation completed locally. |
* |
* TODO: fix libpng and remove this. |
*/ |
if (do_local_background) |
do_local_background = 2/*required*/; |
/* 16-bit output: just remove the channel */ |
else if (linear) /* compose on black (well, pre-multiply) */ |
png_set_strip_alpha(png_ptr); |
/* 8-bit output: do an appropriate compose */ |
else if (display->background != NULL) |
{ |
png_color_16 c; |
c.index = 0; /*unused*/ |
c.red = display->background->red; |
c.green = display->background->green; |
c.blue = display->background->blue; |
c.gray = display->background->green; |
/* This is always an 8-bit sRGB value, using the 'green' channel |
* for gray is much better than calculating the luminance here; |
* we can get off-by-one errors in that calculation relative to |
* the app expectations and that will show up in transparent |
* pixels. |
*/ |
png_set_background_fixed(png_ptr, &c, |
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, |
0/*gamma: not used*/); |
} |
else /* compose on row: implemented below. */ |
{ |
do_local_compose = 1; |
/* This leaves the alpha channel in the output, so it has to be |
* removed by the code below. Set the encoding to the 'OPTIMIZE' |
* one so the code only has to hack on the pixels that require |
* composition. |
*/ |
mode = PNG_ALPHA_OPTIMIZED; |
} |
} |
else /* output needs an alpha channel */ |
{ |
/* This is tricky because it happens before the swap operation has |
* been accomplished; however, the swap does *not* swap the added |
* alpha channel (weird API), so it must be added in the correct |
* place. |
*/ |
png_uint_32 filler; /* opaque filler */ |
int where; |
if (linear) |
filler = 65535; |
else |
filler = 255; |
# ifdef PNG_FORMAT_AFIRST_SUPPORTED |
if (format & PNG_FORMAT_FLAG_AFIRST) |
{ |
where = PNG_FILLER_BEFORE; |
change &= ~PNG_FORMAT_FLAG_AFIRST; |
} |
else |
# endif |
where = PNG_FILLER_AFTER; |
png_set_add_alpha(png_ptr, filler, where); |
} |
/* This stops the (irrelevant) call to swap_alpha below. */ |
change &= ~PNG_FORMAT_FLAG_ALPHA; |
} |
/* Now set the alpha mode correctly; this is always done, even if there is |
* no alpha channel in either the input or the output because it correctly |
* sets the output gamma. |
*/ |
png_set_alpha_mode_fixed(png_ptr, mode, output_gamma); |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
if (change & PNG_FORMAT_FLAG_BGR) |
{ |
/* Check only the output format; PNG is never BGR; don't do this if |
* the output is gray, but fix up the 'format' value in that case. |
*/ |
if (format & PNG_FORMAT_FLAG_COLOR) |
png_set_bgr(png_ptr); |
else |
format &= ~PNG_FORMAT_FLAG_BGR; |
change &= ~PNG_FORMAT_FLAG_BGR; |
} |
# endif |
# ifdef PNG_FORMAT_AFIRST_SUPPORTED |
if (change & PNG_FORMAT_FLAG_AFIRST) |
{ |
/* Only relevant if there is an alpha channel - it's particularly |
* important to handle this correctly because do_local_compose may |
* be set above and then libpng will keep the alpha channel for this |
* code to remove. |
*/ |
if (format & PNG_FORMAT_FLAG_ALPHA) |
{ |
/* Disable this if doing a local background, |
* TODO: remove this when local background is no longer required. |
*/ |
if (do_local_background != 2) |
png_set_swap_alpha(png_ptr); |
} |
else |
format &= ~PNG_FORMAT_FLAG_AFIRST; |
change &= ~PNG_FORMAT_FLAG_AFIRST; |
} |
# endif |
/* If the *output* is 16-bit then we need to check for a byte-swap on this |
* architecture. |
*/ |
if (linear) |
{ |
PNG_CONST png_uint_16 le = 0x0001; |
if (*(png_const_bytep)&le) |
png_set_swap(png_ptr); |
} |
/* If change is not now 0 some transformation is missing - error out. */ |
if (change) |
png_error(png_ptr, "png_read_image: unsupported transformation"); |
} |
PNG_SKIP_CHUNKS(png_ptr); |
/* Update the 'info' structure and make sure the result is as required; first |
* make sure to turn on the interlace handling if it will be required |
* (because it can't be turned on *after* the call to png_read_update_info!) |
* |
* TODO: remove the do_local_background fixup below. |
*/ |
if (!do_local_compose && do_local_background != 2) |
passes = png_set_interlace_handling(png_ptr); |
png_read_update_info(png_ptr, info_ptr); |
{ |
png_uint_32 info_format = 0; |
if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) |
info_format |= PNG_FORMAT_FLAG_COLOR; |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
/* do_local_compose removes this channel below. */ |
if (!do_local_compose) |
{ |
/* do_local_background does the same if required. */ |
if (do_local_background != 2 || |
(format & PNG_FORMAT_FLAG_ALPHA) != 0) |
info_format |= PNG_FORMAT_FLAG_ALPHA; |
} |
} |
else if (do_local_compose) /* internal error */ |
png_error(png_ptr, "png_image_read: alpha channel lost"); |
if (info_ptr->bit_depth == 16) |
info_format |= PNG_FORMAT_FLAG_LINEAR; |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
if (png_ptr->transformations & PNG_BGR) |
info_format |= PNG_FORMAT_FLAG_BGR; |
# endif |
# ifdef PNG_FORMAT_AFIRST_SUPPORTED |
if (do_local_background == 2) |
{ |
if (format & PNG_FORMAT_FLAG_AFIRST) |
info_format |= PNG_FORMAT_FLAG_AFIRST; |
} |
if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0 || |
((png_ptr->transformations & PNG_ADD_ALPHA) != 0 && |
(png_ptr->flags & PNG_FLAG_FILLER_AFTER) == 0)) |
{ |
if (do_local_background == 2) |
png_error(png_ptr, "unexpected alpha swap transformation"); |
info_format |= PNG_FORMAT_FLAG_AFIRST; |
} |
# endif |
/* This is actually an internal error. */ |
if (info_format != format) |
png_error(png_ptr, "png_read_image: invalid transformations"); |
} |
/* Now read the rows. If do_local_compose is set then it is necessary to use |
* a local row buffer. The output will be GA, RGBA or BGRA and must be |
* converted to G, RGB or BGR as appropriate. The 'local_row' member of the |
* display acts as a flag. |
*/ |
{ |
png_voidp first_row = display->buffer; |
ptrdiff_t row_bytes = display->row_stride; |
if (linear) |
row_bytes *= 2; |
/* The following expression is designed to work correctly whether it gives |
* a signed or an unsigned result. |
*/ |
if (row_bytes < 0) |
{ |
char *ptr = png_voidcast(char*, first_row); |
ptr += (image->height-1) * (-row_bytes); |
first_row = png_voidcast(png_voidp, ptr); |
} |
display->first_row = first_row; |
display->row_bytes = row_bytes; |
} |
if (do_local_compose) |
{ |
int result; |
png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); |
display->local_row = row; |
result = png_safe_execute(image, png_image_read_composite, display); |
display->local_row = NULL; |
png_free(png_ptr, row); |
return result; |
} |
else if (do_local_background == 2) |
{ |
int result; |
png_voidp row = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); |
display->local_row = row; |
result = png_safe_execute(image, png_image_read_background, display); |
display->local_row = NULL; |
png_free(png_ptr, row); |
return result; |
} |
else |
{ |
png_alloc_size_t row_bytes = display->row_bytes; |
while (--passes >= 0) |
{ |
png_uint_32 y = image->height; |
png_bytep row = png_voidcast(png_bytep, display->first_row); |
while (y-- > 0) |
{ |
png_read_row(png_ptr, row, NULL); |
row += row_bytes; |
} |
} |
return 1; |
} |
} |
int PNGAPI |
png_image_finish_read(png_imagep image, png_const_colorp background, |
void *buffer, png_int_32 row_stride, void *colormap) |
{ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
png_uint_32 check; |
if (row_stride == 0) |
row_stride = PNG_IMAGE_ROW_STRIDE(*image); |
if (row_stride < 0) |
check = -row_stride; |
else |
check = row_stride; |
if (image->opaque != NULL && buffer != NULL && |
check >= PNG_IMAGE_ROW_STRIDE(*image)) |
{ |
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 || |
(image->colormap_entries > 0 && colormap != NULL)) |
{ |
int result; |
png_image_read_control display; |
memset(&display, 0, (sizeof display)); |
display.image = image; |
display.buffer = buffer; |
display.row_stride = row_stride; |
display.colormap = colormap; |
display.background = background; |
display.local_row = NULL; |
/* Choose the correct 'end' routine; for the color-map case all the |
* setup has already been done. |
*/ |
if (image->format & PNG_FORMAT_FLAG_COLORMAP) |
result = |
png_safe_execute(image, png_image_read_colormap, &display) && |
png_safe_execute(image, png_image_read_colormapped, &display); |
else |
result = |
png_safe_execute(image, png_image_read_direct, &display); |
png_image_free(image); |
return result; |
} |
else |
return png_image_error(image, |
"png_image_finish_read[color-map]: no color-map"); |
} |
else |
return png_image_error(image, |
"png_image_finish_read: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_finish_read: damaged PNG_IMAGE_VERSION"); |
return 0; |
} |
#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngrio.c |
---|
1,8 → 1,8 |
/* pngrio.c - functions for data input |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.0 [February 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
29,7 → 29,7 |
* to read more then 64K on a 16 bit machine. |
*/ |
void /* PRIVATE */ |
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length) |
{ |
png_debug1(4, "reading %d bytes", (int)length); |
46,7 → 46,6 |
* read_data function and use it at run time with png_set_read_fn(), rather |
* than changing the library. |
*/ |
# ifndef USE_FAR_KEYWORD |
void PNGCBAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
58,69 → 57,12 |
/* fread() returns 0 on error, so it is OK to store this in a png_size_t |
* instead of an int, which is what fread() actually returns. |
*/ |
check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr); |
check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr)); |
if (check != length) |
png_error(png_ptr, "Read Error"); |
} |
# else |
/* This is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void PNGCBAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
if (png_ptr == NULL) |
return; |
/* Check if data really is near. If so, use usual code. */ |
n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)n_data == data) |
{ |
check = fread(n_data, 1, length, io_ptr); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
err = fread(buf, 1, read, io_ptr); |
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
if (err != read) |
break; |
else |
check += err; |
data += read; |
remaining -= read; |
} |
while (remaining != 0); |
} |
if ((png_uint_32)check != (png_uint_32)length) |
png_error(png_ptr, "read Error"); |
} |
# endif |
#endif |
/* This function allows the application to supply a new input function |
* for libpng if standard C streams aren't being used. |
142,7 → 84,7 |
* be used. |
*/ |
void PNGAPI |
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, |
png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn) |
{ |
if (png_ptr == NULL) |
/programs/develop/libraries/libpng/pngrtran.c |
---|
1,8 → 1,8 |
/* pngrtran.c - transforms the data in a row for PNG readers |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.4 [September 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
22,7 → 22,7 |
/* Set the action on getting a CRC error for an ancillary or critical chunk. */ |
void PNGAPI |
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) |
png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action) |
{ |
png_debug(1, "in png_set_crc_action"); |
88,16 → 88,46 |
} |
} |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
/* Is it OK to set a transformation now? Only if png_start_read_image or |
* png_read_update_info have not been called. It is not necessary for the IHDR |
* to have been read in all cases, the parameter allows for this check too. |
*/ |
static int |
png_rtran_ok(png_structrp png_ptr, int need_IHDR) |
{ |
if (png_ptr != NULL) |
{ |
if (png_ptr->flags & PNG_FLAG_ROW_INIT) |
png_app_error(png_ptr, |
"invalid after png_start_read_image or png_read_update_info"); |
else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0) |
png_app_error(png_ptr, "invalid before the PNG header has been read"); |
else |
{ |
/* Turn on failure to initialize correctly for all transforms. */ |
png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED; |
return 1; /* Ok */ |
} |
} |
return 0; /* no png_error possible! */ |
} |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* Handle alpha and tRNS via a background color */ |
void PNGFAPI |
png_set_background_fixed(png_structp png_ptr, |
png_set_background_fixed(png_structrp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, png_fixed_point background_gamma) |
{ |
png_debug(1, "in png_set_background_fixed"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0) || background_color == NULL) |
return; |
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) |
106,17 → 136,22 |
return; |
} |
png_ptr->transformations |= PNG_BACKGROUND; |
png_memcpy(&(png_ptr->background), background_color, |
png_sizeof(png_color_16)); |
png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA; |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
png_ptr->background = *background_color; |
png_ptr->background_gamma = background_gamma; |
png_ptr->background_gamma_type = (png_byte)(background_gamma_code); |
png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); |
if (need_expand) |
png_ptr->transformations |= PNG_BACKGROUND_EXPAND; |
else |
png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_background(png_structp png_ptr, |
png_set_background(png_structrp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma) |
{ |
126,14 → 161,31 |
# endif /* FLOATING_POINT */ |
#endif /* READ_BACKGROUND */ |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
/* Strip 16 bit depth files to 8 bit depth */ |
/* Scale 16-bit depth files to 8-bit depth. If both of these are set then the |
* one that pngrtran does first (scale) happens. This is necessary to allow the |
* TRANSFORM and API behavior to be somewhat consistent, and it's simpler. |
*/ |
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
void PNGAPI |
png_set_strip_16(png_structp png_ptr) |
png_set_scale_16(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_scale_16"); |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= PNG_SCALE_16_TO_8; |
} |
#endif |
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
/* Chop 16-bit depth files to 8-bit depth */ |
void PNGAPI |
png_set_strip_16(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_strip_16"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= PNG_16_TO_8; |
142,19 → 194,203 |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
void PNGAPI |
png_set_strip_alpha(png_structp png_ptr) |
png_set_strip_alpha(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_strip_alpha"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
png_ptr->transformations |= PNG_STRIP_ALPHA; |
} |
#endif |
#if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) |
static png_fixed_point |
translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma, |
int is_screen) |
{ |
/* Check for flag values. The main reason for having the old Mac value as a |
* flag is that it is pretty near impossible to work out what the correct |
* value is from Apple documentation - a working Mac system is needed to |
* discover the value! |
*/ |
if (output_gamma == PNG_DEFAULT_sRGB || |
output_gamma == PNG_FP_1 / PNG_DEFAULT_sRGB) |
{ |
/* If there is no sRGB support this just sets the gamma to the standard |
* sRGB value. (This is a side effect of using this function!) |
*/ |
# ifdef PNG_READ_sRGB_SUPPORTED |
png_ptr->flags |= PNG_FLAG_ASSUME_sRGB; |
# else |
PNG_UNUSED(png_ptr) |
# endif |
if (is_screen) |
output_gamma = PNG_GAMMA_sRGB; |
else |
output_gamma = PNG_GAMMA_sRGB_INVERSE; |
} |
else if (output_gamma == PNG_GAMMA_MAC_18 || |
output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18) |
{ |
if (is_screen) |
output_gamma = PNG_GAMMA_MAC_OLD; |
else |
output_gamma = PNG_GAMMA_MAC_INVERSE; |
} |
return output_gamma; |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
static png_fixed_point |
convert_gamma_value(png_structrp png_ptr, double output_gamma) |
{ |
/* The following silently ignores cases where fixed point (times 100,000) |
* gamma values are passed to the floating point API. This is safe and it |
* means the fixed point constants work just fine with the floating point |
* API. The alternative would just lead to undetected errors and spurious |
* bug reports. Negative values fail inside the _fixed API unless they |
* correspond to the flag values. |
*/ |
if (output_gamma > 0 && output_gamma < 128) |
output_gamma *= PNG_FP_1; |
/* This preserves -1 and -2 exactly: */ |
output_gamma = floor(output_gamma + .5); |
if (output_gamma > PNG_FP_MAX || output_gamma < PNG_FP_MIN) |
png_fixed_error(png_ptr, "gamma value"); |
return (png_fixed_point)output_gamma; |
} |
# endif |
#endif /* READ_ALPHA_MODE || READ_GAMMA */ |
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
void PNGFAPI |
png_set_alpha_mode_fixed(png_structrp png_ptr, int mode, |
png_fixed_point output_gamma) |
{ |
int compose = 0; |
png_fixed_point file_gamma; |
png_debug(1, "in png_set_alpha_mode"); |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/); |
/* Validate the value to ensure it is in a reasonable range. The value |
* is expected to be 1 or greater, but this range test allows for some |
* viewing correction values. The intent is to weed out users of this API |
* who use the inverse of the gamma value accidentally! Since some of these |
* values are reasonable this may have to be changed. |
*/ |
if (output_gamma < 70000 || output_gamma > 300000) |
png_error(png_ptr, "output gamma out of expected range"); |
/* The default file gamma is the inverse of the output gamma; the output |
* gamma may be changed below so get the file value first: |
*/ |
file_gamma = png_reciprocal(output_gamma); |
/* There are really 8 possibilities here, composed of any combination |
* of: |
* |
* premultiply the color channels |
* do not encode non-opaque pixels |
* encode the alpha as well as the color channels |
* |
* The differences disappear if the input/output ('screen') gamma is 1.0, |
* because then the encoding is a no-op and there is only the choice of |
* premultiplying the color channels or not. |
* |
* png_set_alpha_mode and png_set_background interact because both use |
* png_compose to do the work. Calling both is only useful when |
* png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along |
* with a default gamma value. Otherwise PNG_COMPOSE must not be set. |
*/ |
switch (mode) |
{ |
case PNG_ALPHA_PNG: /* default: png standard */ |
/* No compose, but it may be set by png_set_background! */ |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
break; |
case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */ |
compose = 1; |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
/* The output is linear: */ |
output_gamma = PNG_FP_1; |
break; |
case PNG_ALPHA_OPTIMIZED: /* associated, non-opaque pixels linear */ |
compose = 1; |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA; |
/* output_gamma records the encoding of opaque pixels! */ |
break; |
case PNG_ALPHA_BROKEN: /* associated, non-linear, alpha encoded */ |
compose = 1; |
png_ptr->transformations |= PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
break; |
default: |
png_error(png_ptr, "invalid alpha mode"); |
} |
/* Only set the default gamma if the file gamma has not been set (this has |
* the side effect that the gamma in a second call to png_set_alpha_mode will |
* be ignored.) |
*/ |
if (png_ptr->colorspace.gamma == 0) |
{ |
png_ptr->colorspace.gamma = file_gamma; |
png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; |
} |
/* But always set the output gamma: */ |
png_ptr->screen_gamma = output_gamma; |
/* Finally, if pre-multiplying, set the background fields to achieve the |
* desired result. |
*/ |
if (compose) |
{ |
/* And obtain alpha pre-multiplication by composing on black: */ |
memset(&png_ptr->background, 0, (sizeof png_ptr->background)); |
png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */ |
png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE; |
png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; |
if (png_ptr->transformations & PNG_COMPOSE) |
png_error(png_ptr, |
"conflicting calls to set alpha mode and background"); |
png_ptr->transformations |= PNG_COMPOSE; |
} |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_alpha_mode(png_structrp png_ptr, int mode, double output_gamma) |
{ |
png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr, |
output_gamma)); |
} |
# endif |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
/* Dither file to 8 bit. Supply a palette, the current number |
/* Dither file to 8-bit. Supply a palette, the current number |
* of elements in the palette, the maximum number of elements |
* allowed, and a histogram if possible. If the current number |
* of colors is greater then the maximum number, the palette will be |
165,21 → 401,21 |
typedef struct png_dsort_struct |
{ |
struct png_dsort_struct FAR * next; |
struct png_dsort_struct * next; |
png_byte left; |
png_byte right; |
} png_dsort; |
typedef png_dsort FAR * png_dsortp; |
typedef png_dsort FAR * FAR * png_dsortpp; |
typedef png_dsort * png_dsortp; |
typedef png_dsort * * png_dsortpp; |
void PNGAPI |
png_set_quantize(png_structp png_ptr, png_colorp palette, |
png_set_quantize(png_structrp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_const_uint_16p histogram, |
int full_quantize) |
{ |
png_debug(1, "in png_set_quantize"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= PNG_QUANTIZE; |
189,7 → 425,7 |
int i; |
png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
(png_uint_32)(num_palette * (sizeof (png_byte)))); |
for (i = 0; i < num_palette; i++) |
png_ptr->quantize_index[i] = (png_byte)i; |
} |
206,7 → 442,7 |
/* Initialize an array to sort colors */ |
png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
(png_uint_32)(num_palette * (sizeof (png_byte)))); |
/* Initialize the quantize_sort array */ |
for (i = 0; i < num_palette; i++) |
340,9 → 576,9 |
/* Initialize palette index arrays */ |
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
(png_uint_32)(num_palette * (sizeof (png_byte)))); |
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
(png_uint_32)(num_palette * (sizeof (png_byte)))); |
/* Initialize the sort array */ |
for (i = 0; i < num_palette; i++) |
352,7 → 588,7 |
} |
hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 * |
png_sizeof(png_dsortp))); |
(sizeof (png_dsortp)))); |
num_new_palette = num_palette; |
382,7 → 618,7 |
{ |
t = (png_dsortp)png_malloc_warn(png_ptr, |
(png_uint_32)(png_sizeof(png_dsort))); |
(png_uint_32)(sizeof (png_dsort))); |
if (t == NULL) |
break; |
507,12 → 743,12 |
png_size_t num_entries = ((png_size_t)1 << total_bits); |
png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr, |
(png_uint_32)(num_entries * png_sizeof(png_byte))); |
(png_uint_32)(num_entries * (sizeof (png_byte)))); |
distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * |
png_sizeof(png_byte))); |
(sizeof (png_byte)))); |
png_memset(distance, 0xff, num_entries * png_sizeof(png_byte)); |
memset(distance, 0xff, num_entries * (sizeof (png_byte))); |
for (i = 0; i < num_palette; i++) |
{ |
560,54 → 796,51 |
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Transform the image from the file_gamma to the screen_gamma. We |
* only do transformations on images where the file_gamma and screen_gamma |
* are not close reciprocals, otherwise it slows things down slightly, and |
* also needlessly introduces small errors. |
* |
* We will turn off gamma transformation later if no semitransparent entries |
* are present in the tRNS array for palette images. We can't do it here |
* because we don't necessarily have the tRNS chunk yet. |
*/ |
static int /* PRIVATE */ |
png_gamma_threshold(png_fixed_point scrn_gamma, png_fixed_point file_gamma) |
{ |
/* PNG_GAMMA_THRESHOLD is the threshold for performing gamma |
* correction as a difference of the overall transform from 1.0 |
* |
* We want to compare the threshold with s*f - 1, if we get |
* overflow here it is because of wacky gamma values so we |
* turn on processing anyway. |
*/ |
png_fixed_point gtest; |
return !png_muldiv(>est, scrn_gamma, file_gamma, PNG_FP_1) || |
png_gamma_significant(gtest); |
} |
void PNGFAPI |
png_set_gamma_fixed(png_structp png_ptr, png_fixed_point scrn_gamma, |
png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma, |
png_fixed_point file_gamma) |
{ |
png_debug(1, "in png_set_gamma_fixed"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || |
png_gamma_threshold(scrn_gamma, file_gamma)) |
png_ptr->transformations |= PNG_GAMMA; |
png_ptr->gamma = file_gamma; |
/* New in libpng-1.5.4 - reserve particular negative values as flags. */ |
scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/); |
file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/); |
/* Checking the gamma values for being >0 was added in 1.5.4 along with the |
* premultiplied alpha support; this actually hides an undocumented feature |
* of the previous implementation which allowed gamma processing to be |
* disabled in background handling. There is no evidence (so far) that this |
* was being used; however, png_set_background itself accepted and must still |
* accept '0' for the gamma value it takes, because it isn't always used. |
* |
* Since this is an API change (albeit a very minor one that removes an |
* undocumented API feature) the following checks were only enabled in |
* libpng-1.6.0. |
*/ |
if (file_gamma <= 0) |
png_error(png_ptr, "invalid file gamma in png_set_gamma"); |
if (scrn_gamma <= 0) |
png_error(png_ptr, "invalid screen gamma in png_set_gamma"); |
/* Set the gamma values unconditionally - this overrides the value in the PNG |
* file if a gAMA chunk was present. png_set_alpha_mode provides a |
* different, easier, way to default the file gamma. |
*/ |
png_ptr->colorspace.gamma = file_gamma; |
png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; |
png_ptr->screen_gamma = scrn_gamma; |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) |
png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma) |
{ |
png_set_gamma_fixed(png_ptr, |
png_fixed(png_ptr, scrn_gamma, "png_set_gamma screen gamma"), |
png_fixed(png_ptr, file_gamma, "png_set_gamma file gamma")); |
png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma), |
convert_gamma_value(png_ptr, file_gamma)); |
} |
# endif /* FLOATING_POINT_SUPPORTED */ |
#endif /* READ_GAMMA */ |
618,15 → 851,14 |
* to alpha channels. |
*/ |
void PNGAPI |
png_set_expand(png_structp png_ptr) |
png_set_expand(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_expand"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* GRR 19990627: the following three functions currently are identical |
649,80 → 881,95 |
/* Expand paletted images to RGB. */ |
void PNGAPI |
png_set_palette_to_rgb(png_structp png_ptr) |
png_set_palette_to_rgb(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_palette_to_rgb"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* Expand grayscale images of less than 8-bit depth to 8 bits. */ |
void PNGAPI |
png_set_expand_gray_1_2_4_to_8(png_structp png_ptr) |
png_set_expand_gray_1_2_4_to_8(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_expand_gray_1_2_4_to_8"); |
if (png_ptr == NULL) |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= PNG_EXPAND; |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* Expand tRNS chunks to alpha channels. */ |
void PNGAPI |
png_set_tRNS_to_alpha(png_structp png_ptr) |
png_set_tRNS_to_alpha(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_tRNS_to_alpha"); |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
/* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise |
* it may not work correctly.) |
*/ |
void PNGAPI |
png_set_expand_16(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_expand_16"); |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS); |
} |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
void PNGAPI |
png_set_gray_to_rgb(png_structp png_ptr) |
png_set_gray_to_rgb(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_gray_to_rgb"); |
if (png_ptr != NULL) |
{ |
if (!png_rtran_ok(png_ptr, 0)) |
return; |
/* Because rgb must be 8 bits or more: */ |
png_set_expand_gray_1_2_4_to_8(png_ptr); |
png_ptr->transformations |= PNG_GRAY_TO_RGB; |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
} |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
void PNGFAPI |
png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, |
png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action, |
png_fixed_point red, png_fixed_point green) |
{ |
png_debug(1, "in png_set_rgb_to_gray"); |
if (png_ptr == NULL) |
/* Need the IHDR here because of the check on color_type below. */ |
/* TODO: fix this */ |
if (!png_rtran_ok(png_ptr, 1)) |
return; |
switch(error_action) |
{ |
case 1: |
case PNG_ERROR_ACTION_NONE: |
png_ptr->transformations |= PNG_RGB_TO_GRAY; |
break; |
case 2: |
case PNG_ERROR_ACTION_WARN: |
png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; |
break; |
case 3: |
case PNG_ERROR_ACTION_ERROR: |
png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; |
break; |
730,44 → 977,61 |
png_error(png_ptr, "invalid error action to rgb_to_gray"); |
break; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#ifdef PNG_READ_EXPAND_SUPPORTED |
png_ptr->transformations |= PNG_EXPAND; |
#else |
{ |
png_warning(png_ptr, |
/* Make this an error in 1.6 because otherwise the application may assume |
* that it just worked and get a memory overwrite. |
*/ |
png_error(png_ptr, |
"Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED"); |
png_ptr->transformations &= ~PNG_RGB_TO_GRAY; |
/* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */ |
} |
#endif |
{ |
if (red >= 0 && green >= 0 && red + green <= PNG_FP_1) |
{ |
png_uint_16 red_int, green_int; |
if (red < 0 || green < 0) |
{ |
red_int = 6968; /* .212671 * 32768 + .5 */ |
green_int = 23434; /* .715160 * 32768 + .5 */ |
} |
else if (red + green < 100000L) |
{ |
red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); |
green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); |
/* NOTE: this calculation does not round, but this behavior is retained |
* for consistency, the inaccuracy is very small. The code here always |
* overwrites the coefficients, regardless of whether they have been |
* defaulted or set already. |
*/ |
red_int = (png_uint_16)(((png_uint_32)red*32768)/100000); |
green_int = (png_uint_16)(((png_uint_32)green*32768)/100000); |
png_ptr->rgb_to_gray_red_coeff = red_int; |
png_ptr->rgb_to_gray_green_coeff = green_int; |
png_ptr->rgb_to_gray_coefficients_set = 1; |
} |
else |
{ |
png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); |
red_int = 6968; |
green_int = 23434; |
} |
if (red >= 0 && green >= 0) |
png_app_warning(png_ptr, |
"ignoring out of range rgb_to_gray coefficients"); |
png_ptr->rgb_to_gray_red_coeff = red_int; |
png_ptr->rgb_to_gray_green_coeff = green_int; |
png_ptr->rgb_to_gray_blue_coeff = |
(png_uint_16)(32768 - red_int - green_int); |
/* Use the defaults, from the cHRM chunk if set, else the historical |
* values which are close to the sRGB/HDTV/ITU-Rec 709 values. See |
* png_do_rgb_to_gray for more discussion of the values. In this case |
* the coefficients are not marked as 'set' and are not overwritten if |
* something has already provided a default. |
*/ |
if (png_ptr->rgb_to_gray_red_coeff == 0 && |
png_ptr->rgb_to_gray_green_coeff == 0) |
{ |
png_ptr->rgb_to_gray_red_coeff = 6968; |
png_ptr->rgb_to_gray_green_coeff = 23434; |
/* png_ptr->rgb_to_gray_blue_coeff = 2366; */ |
} |
} |
} |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
/* Convert a RGB image to a grayscale of the same width. This allows us, |
775,12 → 1039,9 |
*/ |
void PNGAPI |
png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, |
png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red, |
double green) |
{ |
if (png_ptr == NULL) |
return; |
png_set_rgb_to_gray_fixed(png_ptr, error_action, |
png_fixed(png_ptr, red, "rgb to gray red coefficient"), |
png_fixed(png_ptr, green, "rgb to gray green coefficient")); |
787,19 → 1048,16 |
} |
#endif /* FLOATING POINT */ |
#endif |
#endif /* RGB_TO_GRAY */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
void PNGAPI |
png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
png_set_read_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr |
read_user_transform_fn) |
{ |
png_debug(1, "in png_set_read_user_transform_fn"); |
if (png_ptr == NULL) |
return; |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->read_user_transform_fn = read_user_transform_fn; |
807,167 → 1065,530 |
} |
#endif |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* In the case of gamma transformations only do transformations on images where |
* the [file] gamma and screen_gamma are not close reciprocals, otherwise it |
* slows things down slightly, and also needlessly introduces small errors. |
*/ |
static int /* PRIVATE */ |
png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma) |
{ |
/* PNG_GAMMA_THRESHOLD is the threshold for performing gamma |
* correction as a difference of the overall transform from 1.0 |
* |
* We want to compare the threshold with s*f - 1, if we get |
* overflow here it is because of wacky gamma values so we |
* turn on processing anyway. |
*/ |
png_fixed_point gtest; |
return !png_muldiv(>est, screen_gamma, file_gamma, PNG_FP_1) || |
png_gamma_significant(gtest); |
} |
#endif |
/* Initialize everything needed for the read. This includes modifying |
* the palette. |
*/ |
void /* PRIVATE */ |
png_init_read_transformations(png_structp png_ptr) |
/*For the moment 'png_init_palette_transformations' and |
* 'png_init_rgb_transformations' only do some flag canceling optimizations. |
* The intent is that these two routines should have palette or rgb operations |
* extracted from 'png_init_read_transformations'. |
*/ |
static void /* PRIVATE */ |
png_init_palette_transformations(png_structrp png_ptr) |
{ |
png_debug(1, "in png_init_read_transformations"); |
/* Called to handle the (input) palette case. In png_do_read_transformations |
* the first step is to expand the palette if requested, so this code must |
* take care to only make changes that are invariant with respect to the |
* palette expansion, or only do them if there is no expansion. |
* |
* STRIP_ALPHA has already been handled in the caller (by setting num_trans |
* to 0.) |
*/ |
int input_has_alpha = 0; |
int input_has_transparency = 0; |
if (png_ptr->num_trans > 0) |
{ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_SHIFT_SUPPORTED) || \ |
defined(PNG_READ_GAMMA_SUPPORTED) |
int color_type = png_ptr->color_type; |
#endif |
int i; |
/* Ignore if all the entries are opaque (unlikely!) */ |
for (i=0; i<png_ptr->num_trans; ++i) |
{ |
if (png_ptr->trans_alpha[i] == 255) |
continue; |
else if (png_ptr->trans_alpha[i] == 0) |
input_has_transparency = 1; |
else |
{ |
input_has_transparency = 1; |
input_has_alpha = 1; |
break; |
} |
} |
} |
/* If no alpha we can optimize. */ |
if (!input_has_alpha) |
{ |
/* Any alpha means background and associative alpha processing is |
* required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA |
* and ENCODE_ALPHA are irrelevant. |
*/ |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
if (!input_has_transparency) |
png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); |
} |
#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* png_set_background handling - deals with the complexity of whether the |
* background color is in the file format or the screen format in the case |
* where an 'expand' will happen. |
*/ |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* Detect gray background and attempt to enable optimization |
* for gray --> RGB case |
* |
* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or |
* RGB_ALPHA (in which case need_expand is superfluous anyway), the |
* background color might actually be gray yet not be flagged as such. |
* This is not a problem for the current code, which uses |
* PNG_BACKGROUND_IS_GRAY only to decide when to do the |
* png_do_gray_to_rgb() transformation. |
/* The following code cannot be entered in the alpha pre-multiplication case |
* because PNG_BACKGROUND_EXPAND is cancelled below. |
*/ |
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
!(color_type & PNG_COLOR_MASK_COLOR)) |
(png_ptr->transformations & PNG_EXPAND)) |
{ |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
{ |
png_ptr->background.red = |
png_ptr->palette[png_ptr->background.index].red; |
png_ptr->background.green = |
png_ptr->palette[png_ptr->background.index].green; |
png_ptr->background.blue = |
png_ptr->palette[png_ptr->background.index].blue; |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
{ |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
/* Invert the alpha channel (in tRNS) unless the pixels are |
* going to be expanded, in which case leave it for later |
*/ |
int i, istop = png_ptr->num_trans; |
for (i=0; i<istop; i++) |
png_ptr->trans_alpha[i] = (png_byte)(255 - |
png_ptr->trans_alpha[i]); |
} |
} |
#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */ |
} |
} /* background expand and (therefore) no alpha association. */ |
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ |
} |
else if ((png_ptr->transformations & PNG_BACKGROUND) && |
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
(png_ptr->transformations & PNG_GRAY_TO_RGB) && |
png_ptr->background.red == png_ptr->background.green && |
png_ptr->background.red == png_ptr->background.blue) |
static void /* PRIVATE */ |
png_init_rgb_transformations(png_structrp png_ptr) |
{ |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
png_ptr->background.gray = png_ptr->background.red; |
} |
/* Added to libpng-1.5.4: check the color type to determine whether there |
* is any alpha or transparency in the image and simply cancel the |
* background and alpha mode stuff if there isn't. |
*/ |
int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0; |
int input_has_transparency = png_ptr->num_trans > 0; |
/* If no alpha we can optimize. */ |
if (!input_has_alpha) |
{ |
/* Any alpha means background and associative alpha processing is |
* required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA |
* and ENCODE_ALPHA are irrelevant. |
*/ |
# ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
#endif |
if (!input_has_transparency) |
png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); |
} |
#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* png_set_background handling - deals with the complexity of whether the |
* background color is in the file format or the screen format in the case |
* where an 'expand' will happen. |
*/ |
/* The following code cannot be entered in the alpha pre-multiplication case |
* because PNG_BACKGROUND_EXPAND is cancelled below. |
*/ |
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
(png_ptr->transformations & PNG_EXPAND)) |
(png_ptr->transformations & PNG_EXPAND) && |
!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) |
/* i.e., GRAY or GRAY_ALPHA */ |
{ |
if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ |
{ |
/* Expand background and tRNS chunks */ |
int gray = png_ptr->background.gray; |
int trans_gray = png_ptr->trans_color.gray; |
switch (png_ptr->bit_depth) |
{ |
case 1: |
png_ptr->background.gray *= (png_uint_16)0xff; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0xff; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.gray; |
} |
gray *= 0xff; |
trans_gray *= 0xff; |
break; |
case 2: |
png_ptr->background.gray *= (png_uint_16)0x55; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0x55; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.gray; |
} |
gray *= 0x55; |
trans_gray *= 0x55; |
break; |
case 4: |
png_ptr->background.gray *= (png_uint_16)0x11; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0x11; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.gray; |
} |
gray *= 0x11; |
trans_gray *= 0x11; |
break; |
default: |
case 8: |
/* FALL THROUGH (Already 8 bits) */ |
case 16: |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
/* Already a full 16 bits */ |
break; |
} |
png_ptr->background.red = png_ptr->background.green = |
png_ptr->background.blue = (png_uint_16)gray; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.red = png_ptr->trans_color.green = |
png_ptr->trans_color.blue = (png_uint_16)trans_gray; |
} |
else if (color_type == PNG_COLOR_TYPE_PALETTE) |
} |
} /* background expand and (therefore) no alpha association. */ |
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ |
} |
void /* PRIVATE */ |
png_init_read_transformations(png_structrp png_ptr) |
{ |
png_ptr->background.red = |
png_ptr->palette[png_ptr->background.index].red; |
png_ptr->background.green = |
png_ptr->palette[png_ptr->background.index].green; |
png_ptr->background.blue = |
png_ptr->palette[png_ptr->background.index].blue; |
png_debug(1, "in png_init_read_transformations"); |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
/* This internal function is called from png_read_start_row in pngrutil.c |
* and it is called before the 'rowbytes' calculation is done, so the code |
* in here can change or update the transformations flags. |
* |
* First do updates that do not depend on the details of the PNG image data |
* being processed. |
*/ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds |
* png_set_alpha_mode and this is another source for a default file gamma so |
* the test needs to be performed later - here. In addition prior to 1.5.4 |
* the tests were repeated for the PALETTE color type here - this is no |
* longer necessary (and doesn't seem to have been necessary before.) |
*/ |
{ |
#ifdef PNG_READ_EXPAND_SUPPORTED |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
#endif |
/* The following temporary indicates if overall gamma correction is |
* required. |
*/ |
int gamma_correction = 0; |
if (png_ptr->colorspace.gamma != 0) /* has been set */ |
{ |
/* Invert the alpha channel (in tRNS) unless the pixels are |
* going to be expanded, in which case leave it for later |
if (png_ptr->screen_gamma != 0) /* screen set too */ |
gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma); |
else |
/* Assume the output matches the input; a long time default behavior |
* of libpng, although the standard has nothing to say about this. |
*/ |
int i, istop; |
istop=(int)png_ptr->num_trans; |
for (i=0; i<istop; i++) |
png_ptr->trans_alpha[i] = (png_byte)(255 - |
png_ptr->trans_alpha[i]); |
png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma); |
} |
else if (png_ptr->screen_gamma != 0) |
/* The converse - assume the file matches the screen, note that this |
* perhaps undesireable default can (from 1.5.4) be changed by calling |
* png_set_alpha_mode (even if the alpha handling mode isn't required |
* or isn't changed from the default.) |
*/ |
png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma); |
else /* neither are set */ |
/* Just in case the following prevents any processing - file and screen |
* are both assumed to be linear and there is no way to introduce a |
* third gamma value other than png_set_background with 'UNIQUE', and, |
* prior to 1.5.4 |
*/ |
png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1; |
/* We have a gamma value now. */ |
png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; |
/* Now turn the gamma transformation on or off as appropriate. Notice |
* that PNG_GAMMA just refers to the file->screen correction. Alpha |
* composition may independently cause gamma correction because it needs |
* linear data (e.g. if the file has a gAMA chunk but the screen gamma |
* hasn't been specified.) In any case this flag may get turned off in |
* the code immediately below if the transform can be handled outside the |
* row loop. |
*/ |
if (gamma_correction) |
png_ptr->transformations |= PNG_GAMMA; |
else |
png_ptr->transformations &= ~PNG_GAMMA; |
} |
#endif |
/* Certain transformations have the effect of preventing other |
* transformations that happen afterward in png_do_read_transformations, |
* resolve the interdependencies here. From the code of |
* png_do_read_transformations the order is: |
* |
* 1) PNG_EXPAND (including PNG_EXPAND_tRNS) |
* 2) PNG_STRIP_ALPHA (if no compose) |
* 3) PNG_RGB_TO_GRAY |
* 4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY |
* 5) PNG_COMPOSE |
* 6) PNG_GAMMA |
* 7) PNG_STRIP_ALPHA (if compose) |
* 8) PNG_ENCODE_ALPHA |
* 9) PNG_SCALE_16_TO_8 |
* 10) PNG_16_TO_8 |
* 11) PNG_QUANTIZE (converts to palette) |
* 12) PNG_EXPAND_16 |
* 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY |
* 14) PNG_INVERT_MONO |
* 15) PNG_SHIFT |
* 16) PNG_PACK |
* 17) PNG_BGR |
* 18) PNG_PACKSWAP |
* 19) PNG_FILLER (includes PNG_ADD_ALPHA) |
* 20) PNG_INVERT_ALPHA |
* 21) PNG_SWAP_ALPHA |
* 22) PNG_SWAP_BYTES |
* 23) PNG_USER_TRANSFORM [must be last] |
*/ |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && |
!(png_ptr->transformations & PNG_COMPOSE)) |
{ |
/* Stripping the alpha channel happens immediately after the 'expand' |
* transformations, before all other transformation, so it cancels out |
* the alpha handling. It has the side effect negating the effect of |
* PNG_EXPAND_tRNS too: |
*/ |
png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA | |
PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
/* Kill the tRNS chunk itself too. Prior to 1.5.4 this did not happen |
* so transparency information would remain just so long as it wasn't |
* expanded. This produces unexpected API changes if the set of things |
* that do PNG_EXPAND_tRNS changes (perfectly possible given the |
* documentation - which says ask for what you want, accept what you |
* get.) This makes the behavior consistent from 1.5.4: |
*/ |
png_ptr->num_trans = 0; |
} |
#endif /* STRIP_ALPHA supported, no COMPOSE */ |
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
/* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA |
* settings will have no effect. |
*/ |
if (!png_gamma_significant(png_ptr->screen_gamma)) |
{ |
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; |
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
png_ptr->background_1 = png_ptr->background; |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* Make sure the coefficients for the rgb to gray conversion are set |
* appropriately. |
*/ |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
png_colorspace_set_rgb_coefficients(png_ptr); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) |
&& png_gamma_threshold(png_ptr->screen_gamma, png_ptr->gamma)) |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* Detect gray background and attempt to enable optimization for |
* gray --> RGB case. |
* |
* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or |
* RGB_ALPHA (in which case need_expand is superfluous anyway), the |
* background color might actually be gray yet not be flagged as such. |
* This is not a problem for the current code, which uses |
* PNG_BACKGROUND_IS_GRAY only to decide when to do the |
* png_do_gray_to_rgb() transformation. |
* |
* TODO: this code needs to be revised to avoid the complexity and |
* interdependencies. The color type of the background should be recorded in |
* png_set_background, along with the bit depth, then the code has a record |
* of exactly what color space the background is currently in. |
*/ |
if (png_ptr->transformations & PNG_BACKGROUND_EXPAND) |
{ |
int i, k; |
k=0; |
for (i=0; i<png_ptr->num_trans; i++) |
/* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if |
* the file was grayscale the background value is gray. |
*/ |
if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
} |
else if (png_ptr->transformations & PNG_COMPOSE) |
{ |
if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff) |
k=1; /* Partial transparency is present */ |
/* PNG_COMPOSE: png_set_background was called with need_expand false, |
* so the color is in the color space of the output or png_set_alpha_mode |
* was called and the color is black. Ignore RGB_TO_GRAY because that |
* happens before GRAY_TO_RGB. |
*/ |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
{ |
if (png_ptr->background.red == png_ptr->background.green && |
png_ptr->background.red == png_ptr->background.blue) |
{ |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
png_ptr->background.gray = png_ptr->background.red; |
} |
if (k == 0) |
png_ptr->transformations &= ~PNG_GAMMA; |
} |
} |
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ |
#endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */ |
if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) && |
png_ptr->gamma != 0) |
/* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations |
* can be performed directly on the palette, and some (such as rgb to gray) |
* can be optimized inside the palette. This is particularly true of the |
* composite (background and alpha) stuff, which can be pretty much all done |
* in the palette even if the result is expanded to RGB or gray afterward. |
* |
* NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and |
* earlier and the palette stuff is actually handled on the first row. This |
* leads to the reported bug that the palette returned by png_get_PLTE is not |
* updated. |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
png_init_palette_transformations(png_ptr); |
else |
png_init_rgb_transformations(png_ptr); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
defined(PNG_READ_EXPAND_16_SUPPORTED) |
if ((png_ptr->transformations & PNG_EXPAND_16) && |
(png_ptr->transformations & PNG_COMPOSE) && |
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
png_ptr->bit_depth != 16) |
{ |
/* TODO: fix this. Because the expand_16 operation is after the compose |
* handling the background color must be 8, not 16, bits deep, but the |
* application will supply a 16-bit value so reduce it here. |
* |
* The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at |
* present, so that case is ok (until do_expand_16 is moved.) |
* |
* NOTE: this discards the low 16 bits of the user supplied background |
* color, but until expand_16 works properly there is no choice! |
*/ |
# define CHOP(x) (x)=((png_uint_16)PNG_DIV257(x)) |
CHOP(png_ptr->background.red); |
CHOP(png_ptr->background.green); |
CHOP(png_ptr->background.blue); |
CHOP(png_ptr->background.gray); |
# undef CHOP |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED && PNG_READ_EXPAND_16_SUPPORTED */ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
(defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \ |
defined(PNG_READ_STRIP_16_TO_8_SUPPORTED)) |
if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) && |
(png_ptr->transformations & PNG_COMPOSE) && |
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
png_ptr->bit_depth == 16) |
{ |
/* On the other hand, if a 16-bit file is to be reduced to 8-bits per |
* component this will also happen after PNG_COMPOSE and so the background |
* color must be pre-expanded here. |
* |
* TODO: fix this too. |
*/ |
png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257); |
png_ptr->background.green = |
(png_uint_16)(png_ptr->background.green * 257); |
png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257); |
png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257); |
} |
#endif |
/* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the |
* background support (see the comments in scripts/pnglibconf.dfa), this |
* allows pre-multiplication of the alpha channel to be implemented as |
* compositing on black. This is probably sub-optimal and has been done in |
* 1.5.4 betas simply to enable external critique and testing (i.e. to |
* implement the new API quickly, without lots of internal changes.) |
*/ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
# ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* Includes ALPHA_MODE */ |
png_ptr->background_1 = png_ptr->background; |
# endif |
/* This needs to change - in the palette image case a whole set of tables are |
* built when it would be quicker to just calculate the correct value for |
* each palette entry directly. Also, the test is too tricky - why check |
* PNG_RGB_TO_GRAY if PNG_GAMMA is not set? The answer seems to be that |
* PNG_GAMMA is cancelled even if the gamma is known? The test excludes the |
* PNG_COMPOSE case, so apparently if there is no *overall* gamma correction |
* the gamma tables will not be built even if composition is required on a |
* gamma encoded value. |
* |
* In 1.5.4 this is addressed below by an additional check on the individual |
* file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the |
* tables. |
*/ |
if ((png_ptr->transformations & PNG_GAMMA) |
|| ((png_ptr->transformations & PNG_RGB_TO_GRAY) |
&& (png_gamma_significant(png_ptr->colorspace.gamma) || |
png_gamma_significant(png_ptr->screen_gamma))) |
|| ((png_ptr->transformations & PNG_COMPOSE) |
&& (png_gamma_significant(png_ptr->colorspace.gamma) |
|| png_gamma_significant(png_ptr->screen_gamma) |
# ifdef PNG_READ_BACKGROUND_SUPPORTED |
|| (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE |
&& png_gamma_significant(png_ptr->background_gamma)) |
# endif |
)) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) |
&& png_gamma_significant(png_ptr->screen_gamma)) |
) |
{ |
png_build_gamma_table(png_ptr, png_ptr->bit_depth); |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if (png_ptr->transformations & PNG_BACKGROUND) |
if (png_ptr->transformations & PNG_COMPOSE) |
{ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
/* Issue a warning about this combination: because RGB_TO_GRAY is |
* optimized to do the gamma transform if present yet do_background has |
* to do the same thing if both options are set a |
* double-gamma-correction happens. This is true in all versions of |
* libpng to date. |
*/ |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
png_warning(png_ptr, |
"libpng does not support gamma+background+rgb_to_gray"); |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
/* Could skip if no transparency */ |
/* We don't get to here unless there is a tRNS chunk with non-opaque |
* entries - see the checking code at the start of this function. |
*/ |
png_color back, back_1; |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
995,8 → 1616,8 |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = png_reciprocal(png_ptr->gamma); |
gs = png_reciprocal2(png_ptr->gamma, |
g = png_reciprocal(png_ptr->colorspace.gamma); |
gs = png_reciprocal2(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma); |
break; |
1013,13 → 1634,6 |
if (png_gamma_significant(gs)) |
{ |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
} |
else |
{ |
back.red = png_gamma_8bit_correct(png_ptr->background.red, |
gs); |
back.green = png_gamma_8bit_correct(png_ptr->background.green, |
1027,12 → 1641,32 |
back.blue = png_gamma_8bit_correct(png_ptr->background.blue, |
gs); |
} |
back_1.red = png_gamma_8bit_correct(png_ptr->background.red, g); |
back_1.green = png_gamma_8bit_correct(png_ptr->background.green, |
else |
{ |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
} |
if (png_gamma_significant(g)) |
{ |
back_1.red = png_gamma_8bit_correct(png_ptr->background.red, |
g); |
back_1.green = png_gamma_8bit_correct( |
png_ptr->background.green, g); |
back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, |
g); |
} |
else |
{ |
back_1.red = (png_byte)png_ptr->background.red; |
back_1.green = (png_byte)png_ptr->background.green; |
back_1.blue = (png_byte)png_ptr->background.blue; |
} |
} |
for (i = 0; i < num_palette; i++) |
{ |
if (i < (int)png_ptr->num_trans && |
1066,22 → 1700,22 |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
/* Prevent the transformations being done again, and make sure |
* that the now spurious alpha channel is stripped - the code |
* has just reduced background composition and gamma correction |
* to a simple alpha channel strip. |
/* Prevent the transformations being done again. |
* |
* NOTE: this is highly dubious; it removes the transformations in |
* place. This seems inconsistent with the general treatment of the |
* transformations elsewhere. |
*/ |
png_ptr->transformations &= ~PNG_BACKGROUND; |
png_ptr->transformations &= ~PNG_GAMMA; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
} |
png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA); |
} /* color_type == PNG_COLOR_TYPE_PALETTE */ |
/* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ |
else |
/* color_type != PNG_COLOR_TYPE_PALETTE */ |
else /* color_type != PNG_COLOR_TYPE_PALETTE */ |
{ |
png_fixed_point g = PNG_FP_1; |
png_fixed_point gs = PNG_FP_1; |
int gs_sig, g_sig; |
png_fixed_point g = PNG_FP_1; /* Correction to linear */ |
png_fixed_point gs = PNG_FP_1; /* Correction to screen */ |
switch (png_ptr->background_gamma_type) |
{ |
1091,8 → 1725,9 |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = png_reciprocal(png_ptr->gamma); |
gs = png_reciprocal2(png_ptr->gamma, png_ptr->screen_gamma); |
g = png_reciprocal(png_ptr->colorspace.gamma); |
gs = png_reciprocal2(png_ptr->colorspace.gamma, |
png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
1105,9 → 1740,14 |
png_error(png_ptr, "invalid background gamma type"); |
} |
g_sig = png_gamma_significant(g); |
gs_sig = png_gamma_significant(gs); |
if (g_sig) |
png_ptr->background_1.gray = png_gamma_correct(png_ptr, |
png_ptr->background.gray, g); |
if (gs_sig) |
png_ptr->background.gray = png_gamma_correct(png_ptr, |
png_ptr->background.gray, gs); |
1116,6 → 1756,8 |
(png_ptr->background.red != png_ptr->background.gray)) |
{ |
/* RGB or RGBA with color background */ |
if (g_sig) |
{ |
png_ptr->background_1.red = png_gamma_correct(png_ptr, |
png_ptr->background.red, g); |
1124,7 → 1766,10 |
png_ptr->background_1.blue = png_gamma_correct(png_ptr, |
png_ptr->background.blue, g); |
} |
if (gs_sig) |
{ |
png_ptr->background.red = png_gamma_correct(png_ptr, |
png_ptr->background.red, gs); |
1134,6 → 1779,7 |
png_ptr->background.blue = png_gamma_correct(png_ptr, |
png_ptr->background.blue, gs); |
} |
} |
else |
{ |
1144,17 → 1790,30 |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
} |
} |
} |
/* The background is now in screen gamma: */ |
png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN; |
} /* color_type != PNG_COLOR_TYPE_PALETTE */ |
}/* png_ptr->transformations & PNG_BACKGROUND */ |
else |
/* Transformation does not include PNG_BACKGROUND */ |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* RGB_TO_GRAY needs to have non-gamma-corrected values! */ |
&& ((png_ptr->transformations & PNG_EXPAND) == 0 || |
(png_ptr->transformations & PNG_RGB_TO_GRAY) == 0) |
#endif |
) |
{ |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
int i; |
/* NOTE: there are other transformations that should probably be in |
* here too. |
*/ |
for (i = 0; i < num_palette; i++) |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
1164,16 → 1823,17 |
/* Done the gamma correction. */ |
png_ptr->transformations &= ~PNG_GAMMA; |
} /* color_type == PALETTE && !PNG_BACKGROUND transformation */ |
} |
} |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
else |
#endif |
#endif /* PNG_READ_GAMMA_SUPPORTED */ |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* No GAMMA transformation */ |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
/* No GAMMA transformation (see the hanging else 4 lines above) */ |
if ((png_ptr->transformations & PNG_COMPOSE) && |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
int i; |
int istop = (int)png_ptr->num_trans; |
1205,46 → 1865,56 |
} |
} |
/* Handled alpha, still need to strip the channel. */ |
png_ptr->transformations &= ~PNG_BACKGROUND; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
png_ptr->transformations &= ~PNG_COMPOSE; |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
#ifdef PNG_READ_SHIFT_SUPPORTED |
if ((png_ptr->transformations & PNG_SHIFT) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
!(png_ptr->transformations & PNG_EXPAND) && |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
png_uint_16 i; |
png_uint_16 istop = png_ptr->num_palette; |
int sr = 8 - png_ptr->sig_bit.red; |
int sg = 8 - png_ptr->sig_bit.green; |
int sb = 8 - png_ptr->sig_bit.blue; |
int i; |
int istop = png_ptr->num_palette; |
int shift = 8 - png_ptr->sig_bit.red; |
if (sr < 0 || sr > 8) |
sr = 0; |
png_ptr->transformations &= ~PNG_SHIFT; |
if (sg < 0 || sg > 8) |
sg = 0; |
/* significant bits can be in the range 1 to 7 for a meaninful result, if |
* the number of significant bits is 0 then no shift is done (this is an |
* error condition which is silently ignored.) |
*/ |
if (shift > 0 && shift < 8) |
for (i=0; i<istop; ++i) |
{ |
int component = png_ptr->palette[i].red; |
if (sb < 0 || sb > 8) |
sb = 0; |
component >>= shift; |
png_ptr->palette[i].red = (png_byte)component; |
} |
for (i = 0; i < istop; i++) |
shift = 8 - png_ptr->sig_bit.green; |
if (shift > 0 && shift < 8) |
for (i=0; i<istop; ++i) |
{ |
png_ptr->palette[i].red >>= sr; |
png_ptr->palette[i].green >>= sg; |
png_ptr->palette[i].blue >>= sb; |
int component = png_ptr->palette[i].green; |
component >>= shift; |
png_ptr->palette[i].green = (png_byte)component; |
} |
shift = 8 - png_ptr->sig_bit.blue; |
if (shift > 0 && shift < 8) |
for (i=0; i<istop; ++i) |
{ |
int component = png_ptr->palette[i].blue; |
component >>= shift; |
png_ptr->palette[i].blue = (png_byte)component; |
} |
} |
#endif /* PNG_READ_SHIFT_SUPPORTED */ |
} |
#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ |
&& !defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr) |
return; |
#endif |
} |
/* Modify the info structure to reflect the transformations. The |
* info should be updated so a PNG file could be written with it, |
1251,7 → 1921,7 |
* assuming the transformations result in valid PNG data. |
*/ |
void /* PRIVATE */ |
png_read_transform_info(png_structp png_ptr, png_infop info_ptr) |
png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr) |
{ |
png_debug(1, "in png_read_transform_info"); |
1260,8 → 1930,11 |
{ |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans && |
(png_ptr->transformations & PNG_EXPAND_tRNS)) |
/* This check must match what actually happens in |
* png_do_expand_palette; if it ever checks the tRNS chunk to see if |
* it is all opaque we must do the same (at present it does not.) |
*/ |
if (png_ptr->num_trans > 0) |
info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
else |
1285,45 → 1958,76 |
} |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
info_ptr->color_type = (png_byte)(info_ptr->color_type & |
~PNG_COLOR_MASK_ALPHA); |
info_ptr->num_trans = 0; |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
/* The following is almost certainly wrong unless the background value is in |
* the screen space! |
*/ |
if (png_ptr->transformations & PNG_COMPOSE) |
info_ptr->background = png_ptr->background; |
} |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
info_ptr->gamma = png_ptr->gamma; |
} |
/* The following used to be conditional on PNG_GAMMA (prior to 1.5.4), |
* however it seems that the code in png_init_read_transformations, which has |
* been called before this from png_read_update_info->png_read_start_row |
* sometimes does the gamma transform and cancels the flag. |
* |
* TODO: this looks wrong; the info_ptr should end up with a gamma equal to |
* the screen_gamma value. The following probably results in weirdness if |
* the info_ptr is used by the app after the rows have been read. |
*/ |
info_ptr->colorspace.gamma = png_ptr->colorspace.gamma; |
#endif |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
if (info_ptr->bit_depth == 16) |
{ |
#ifdef PNG_READ_16BIT_SUPPORTED |
if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) |
# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
if (png_ptr->transformations & PNG_SCALE_16_TO_8) |
info_ptr->bit_depth = 8; |
# endif |
# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
if (png_ptr->transformations & PNG_16_TO_8) |
info_ptr->bit_depth = 8; |
# endif |
#else |
/* Force chopping 16-bit input down to 8 */ |
if (info_ptr->bit_depth == 16) |
{ |
/* No 16 bit support: force chopping 16-bit input down to 8, in this case |
* the app program can chose if both APIs are available by setting the |
* correct scaling to use. |
*/ |
# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
/* For compatibility with previous versions use the strip method by |
* default. This code works because if PNG_SCALE_16_TO_8 is already |
* set the code below will do that in preference to the chop. |
*/ |
png_ptr->transformations |=PNG_16_TO_8; |
info_ptr->bit_depth = 8; |
} |
# else |
# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
png_ptr->transformations |= PNG_SCALE_16_TO_8; |
info_ptr->bit_depth = 8; |
# else |
CONFIGURATION ERROR: you must enable at least one 16 to 8 method |
#endif |
#endif |
#endif /* !READ_16BIT_SUPPORTED */ |
} |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
info_ptr->color_type |= PNG_COLOR_MASK_COLOR; |
info_ptr->color_type = (png_byte)(info_ptr->color_type | |
PNG_COLOR_MASK_COLOR); |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; |
info_ptr->color_type = (png_byte)(info_ptr->color_type & |
~PNG_COLOR_MASK_COLOR); |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
1338,6 → 2042,14 |
} |
#endif |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 && |
info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
info_ptr->bit_depth = 16; |
} |
#endif |
#ifdef PNG_READ_PACK_SUPPORTED |
if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) |
info_ptr->bit_depth = 8; |
1353,8 → 2065,12 |
info_ptr->channels = 1; |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA) |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
if (png_ptr->transformations & PNG_STRIP_ALPHA) |
{ |
info_ptr->color_type = (png_byte)(info_ptr->color_type & |
~PNG_COLOR_MASK_ALPHA); |
info_ptr->num_trans = 0; |
} |
#endif |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
1390,6 → 2106,14 |
info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); |
/* Adding in 1.5.4: cache the above value in png_struct so that we can later |
* check in png_rowbytes that the user buffer won't get overwritten. Note |
* that the field is not always set - if png_read_update_info isn't called |
* the application has to either not do any transforms or get the calculation |
* right itself. |
*/ |
png_ptr->info_rowbytes = info_ptr->rowbytes; |
#ifndef PNG_READ_EXPAND_SUPPORTED |
if (png_ptr) |
return; |
1401,53 → 2125,53 |
* decide how it fits in with the other transformations here. |
*/ |
void /* PRIVATE */ |
png_do_read_transformations(png_structp png_ptr) |
png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info) |
{ |
png_debug(1, "in png_do_read_transformations"); |
if (png_ptr->row_buf == NULL) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[50]; |
png_snprintf2(msg, 50, |
"NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number, |
png_ptr->pass); |
png_error(png_ptr, msg); |
#else |
/* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this |
* error is incredibly rare and incredibly easy to debug without this |
* information. |
*/ |
png_error(png_ptr, "NULL row buffer"); |
#endif |
} |
#ifdef PNG_WARN_UNINITIALIZED_ROW |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
/* Application has failed to call either png_read_start_image() |
* or png_read_update_info() after setting transforms that expand |
* pixels. This check added to libpng-1.2.19 |
/* The following is debugging; prior to 1.5.4 the code was never compiled in; |
* in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro |
* PNG_WARN_UNINITIALIZED_ROW removed. In 1.6 the new flag is set only for |
* all transformations, however in practice the ROW_INIT always gets done on |
* demand, if necessary. |
*/ |
#if (PNG_WARN_UNINITIALIZED_ROW==1) |
if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 && |
!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
{ |
/* Application has failed to call either png_read_start_image() or |
* png_read_update_info() after setting transforms that expand pixels. |
* This check added to libpng-1.2.19 (but not enabled until 1.5.4). |
*/ |
png_error(png_ptr, "Uninitialized row"); |
#else |
png_warning(png_ptr, "Uninitialized row"); |
#endif |
#endif |
} |
#ifdef PNG_READ_EXPAND_SUPPORTED |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) |
if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_expand_palette(row_info, png_ptr->row_buf + 1, |
png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans); |
} |
else |
{ |
if (png_ptr->num_trans && |
(png_ptr->transformations & PNG_EXPAND_tRNS)) |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_expand(row_info, png_ptr->row_buf + 1, |
&(png_ptr->trans_color)); |
else |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_expand(row_info, png_ptr->row_buf + 1, |
NULL); |
} |
} |
1454,9 → 2178,12 |
#endif |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)); |
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && |
!(png_ptr->transformations & PNG_COMPOSE) && |
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) |
png_do_strip_channel(row_info, png_ptr->row_buf + 1, |
0 /* at_start == false, because SWAP_ALPHA happens later */); |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
1463,7 → 2190,7 |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
{ |
int rgb_error = |
png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), |
png_do_rgb_to_gray(png_ptr, row_info, |
png_ptr->row_buf + 1); |
if (rgb_error) |
1517,107 → 2244,147 |
*/ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
((png_ptr->num_trans != 0) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) |
png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_color), &(png_ptr->background) |
#ifdef PNG_READ_GAMMA_SUPPORTED |
, &(png_ptr->background_1), |
png_ptr->gamma_table, png_ptr->gamma_from_1, |
png_ptr->gamma_to_1, png_ptr->gamma_16_table, |
png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, |
png_ptr->gamma_shift |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
if (png_ptr->transformations & PNG_COMPOSE) |
png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr); |
#endif |
); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if ((png_ptr->transformations & PNG_GAMMA) && |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
!((png_ptr->transformations & PNG_BACKGROUND) && |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* Because RGB_TO_GRAY does the gamma transform. */ |
!(png_ptr->transformations & PNG_RGB_TO_GRAY) && |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
/* Because PNG_COMPOSE does the gamma transform if there is something to |
* do (if there is an alpha channel or transparency.) |
*/ |
!((png_ptr->transformations & PNG_COMPOSE) && |
((png_ptr->num_trans != 0) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && |
#endif |
/* Because png_init_read_transformations transforms the palette, unless |
* RGB_TO_GRAY will do the transform. |
*/ |
(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) |
png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->gamma_table, png_ptr->gamma_16_table, |
png_ptr->gamma_shift); |
png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr); |
#endif |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && |
(png_ptr->transformations & PNG_COMPOSE) && |
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || |
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) |
png_do_strip_channel(row_info, png_ptr->row_buf + 1, |
0 /* at_start == false, because SWAP_ALPHA happens later */); |
#endif |
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
if ((png_ptr->transformations & PNG_ENCODE_ALPHA) && |
(row_info->color_type & PNG_COLOR_MASK_ALPHA)) |
png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr); |
#endif |
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
if (png_ptr->transformations & PNG_SCALE_16_TO_8) |
png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
/* There is no harm in doing both of these because only one has any effect, |
* by putting the 'scale' option first if the app asks for scale (either by |
* calling the API or in a TRANSFORM flag) this is what happens. |
*/ |
if (png_ptr->transformations & PNG_16_TO_8) |
png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_chop(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
if (png_ptr->transformations & PNG_QUANTIZE) |
{ |
png_do_quantize(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_quantize(row_info, png_ptr->row_buf + 1, |
png_ptr->palette_lookup, png_ptr->quantize_index); |
if (png_ptr->row_info.rowbytes == 0) |
if (row_info->rowbytes == 0) |
png_error(png_ptr, "png_do_quantize returned rowbytes=0"); |
} |
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
/* Do the expansion now, after all the arithmetic has been done. Notice |
* that previous transformations can handle the PNG_EXPAND_16 flag if this |
* is efficient (particularly true in the case of gamma correction, where |
* better accuracy results faster!) |
*/ |
if (png_ptr->transformations & PNG_EXPAND_16) |
png_do_expand_16(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* NOTE: moved here in 1.5.4 (from much later in this list.) */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_INVERT_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_invert(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_SHIFT_SUPPORTED |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_unshift(row_info, png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#ifdef PNG_READ_PACK_SUPPORTED |
if (png_ptr->transformations & PNG_PACK) |
png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_unpack(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED |
/* Added at libpng-1.5.10 */ |
if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && |
png_ptr->num_palette_max >= 0) |
png_do_check_palette_indexes(png_ptr, row_info); |
#endif |
#ifdef PNG_READ_BGR_SUPPORTED |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_bgr(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_packswap(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* If gray -> RGB, do so now only if we did not do so above */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_FILLER_SUPPORTED |
if (png_ptr->transformations & PNG_FILLER) |
png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_read_filler(row_info, png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->filler, png_ptr->flags); |
#endif |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_16BIT_SUPPORTED |
#ifdef PNG_READ_SWAP_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_swap(row_info, png_ptr->row_buf + 1); |
#endif |
#endif |
1627,7 → 2394,7 |
if (png_ptr->read_user_transform_fn != NULL) |
(*(png_ptr->read_user_transform_fn)) /* User read transform function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
row_info, /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_size_t rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
1637,19 → 2404,17 |
png_ptr->row_buf + 1); /* start of pixel data for row */ |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
if (png_ptr->user_transform_depth) |
png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; |
row_info->bit_depth = png_ptr->user_transform_depth; |
if (png_ptr->user_transform_channels) |
png_ptr->row_info.channels = png_ptr->user_transform_channels; |
row_info->channels = png_ptr->user_transform_channels; |
#endif |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
row_info->pixel_depth = (png_byte)(row_info->bit_depth * |
row_info->channels); |
png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width); |
} |
#endif |
} |
#ifdef PNG_READ_PACK_SUPPORTED |
1761,90 → 2526,109 |
png_do_unshift(png_row_infop row_info, png_bytep row, |
png_const_color_8p sig_bits) |
{ |
int color_type; |
png_debug(1, "in png_do_unshift"); |
if ( |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
/* The palette case has already been handled in the _init routine. */ |
color_type = row_info->color_type; |
if (color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
int shift[4]; |
int channels = 0; |
int c; |
png_uint_16 value = 0; |
png_uint_32 row_width = row_info->width; |
int bit_depth = row_info->bit_depth; |
if (row_info->color_type & PNG_COLOR_MASK_COLOR) |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->red; |
shift[channels++] = row_info->bit_depth - sig_bits->green; |
shift[channels++] = row_info->bit_depth - sig_bits->blue; |
shift[channels++] = bit_depth - sig_bits->red; |
shift[channels++] = bit_depth - sig_bits->green; |
shift[channels++] = bit_depth - sig_bits->blue; |
} |
else |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->gray; |
shift[channels++] = bit_depth - sig_bits->gray; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
if (color_type & PNG_COLOR_MASK_ALPHA) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->alpha; |
shift[channels++] = bit_depth - sig_bits->alpha; |
} |
for (c = 0; c < channels; c++) |
{ |
if (shift[c] <= 0) |
int c, have_shift; |
for (c = have_shift = 0; c < channels; ++c) |
{ |
/* A shift of more than the bit depth is an error condition but it |
* gets ignored here. |
*/ |
if (shift[c] <= 0 || shift[c] >= bit_depth) |
shift[c] = 0; |
else |
value = 1; |
have_shift = 1; |
} |
if (!value) |
if (!have_shift) |
return; |
} |
switch (row_info->bit_depth) |
switch (bit_depth) |
{ |
default: |
/* Must be 1bpp gray: should not be here! */ |
/* NOTREACHED */ |
break; |
case 2: |
/* Must be 2bpp gray */ |
/* assert(channels == 1 && shift[0] == 1) */ |
{ |
png_bytep bp; |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
png_bytep bp = row; |
png_bytep bp_end = bp + row_info->rowbytes; |
for (bp = row, i = 0; i < istop; i++) |
while (bp < bp_end) |
{ |
*bp >>= 1; |
*bp++ &= 0x55; |
int b = (*bp >> 1) & 0x55; |
*bp++ = (png_byte)b; |
} |
break; |
} |
case 4: |
/* Must be 4bpp gray */ |
/* assert(channels == 1) */ |
{ |
png_bytep bp = row; |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | |
(png_byte)((int)0xf >> shift[0])); |
png_bytep bp_end = bp + row_info->rowbytes; |
int gray_shift = shift[0]; |
int mask = 0xf >> gray_shift; |
for (i = 0; i < istop; i++) |
mask |= mask << 4; |
while (bp < bp_end) |
{ |
*bp >>= shift[0]; |
*bp++ &= mask; |
int b = (*bp >> gray_shift) & mask; |
*bp++ = (png_byte)b; |
} |
break; |
} |
case 8: |
/* Single byte components, G, GA, RGB, RGBA */ |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = row_width * channels; |
png_bytep bp_end = bp + row_info->rowbytes; |
int channel = 0; |
for (i = 0; i < istop; i++) |
while (bp < bp_end) |
{ |
*bp++ >>= shift[i%channels]; |
int b = *bp >> shift[channel]; |
if (++channel >= channels) |
channel = 0; |
*bp++ = (png_byte)b; |
} |
break; |
} |
1851,15 → 2635,19 |
#ifdef PNG_READ_16BIT_SUPPORTED |
case 16: |
/* Double byte components, G, GA, RGB, RGBA */ |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = channels * row_width; |
png_bytep bp_end = bp + row_info->rowbytes; |
int channel = 0; |
for (i = 0; i < istop; i++) |
while (bp < bp_end) |
{ |
value = (png_uint_16)((*bp << 8) + *(bp + 1)); |
value >>= shift[i%channels]; |
int value = (bp[0] << 8) + bp[1]; |
value >>= shift[channel]; |
if (++channel >= channels) |
channel = 0; |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)(value & 0xff); |
} |
1871,54 → 2659,86 |
} |
#endif |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
/* Chop rows of bit depth 16 down to 8 */ |
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED |
/* Scale rows of bit depth 16 down to 8 accurately */ |
void /* PRIVATE */ |
png_do_chop(png_row_infop row_info, png_bytep row) |
png_do_scale_16_to_8(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_chop"); |
png_debug(1, "in png_do_scale_16_to_8"); |
if (row_info->bit_depth == 16) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->width * row_info->channels; |
png_bytep sp = row; /* source */ |
png_bytep dp = row; /* destination */ |
png_bytep ep = sp + row_info->rowbytes; /* end+1 */ |
for (i = 0; i<istop; i++, sp += 2, dp++) |
while (sp < ep) |
{ |
#ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED |
/* This does a more accurate scaling of the 16-bit color |
* value, rather than a simple low-byte truncation. |
/* The input is an array of 16 bit components, these must be scaled to |
* 8 bits each. For a 16 bit value V the required value (from the PNG |
* specification) is: |
* |
* What the ideal calculation should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) * 255 + 127) |
* / (png_uint_32)65535L; |
* (V * 255) / 65535 |
* |
* GRR: no, I think this is what it really should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) + 128L) |
* / (png_uint_32)257L; |
* This reduces to round(V / 257), or floor((V + 128.5)/257) |
* |
* GRR: here's the exact calculation with shifts: |
* temp = (((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) + 128L; |
* *dp = (temp - (temp >> 8)) >> 8; |
* Represent V as the two byte value vhi.vlo. Make a guess that the |
* result is the top byte of V, vhi, then the correction to this value |
* is: |
* |
* Approximate calculation with shift/add instead of multiply/divide: |
* *dp = ((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; |
* error = floor(((V-vhi.vhi) + 128.5) / 257) |
* = floor(((vlo-vhi) + 128.5) / 257) |
* |
* What we actually do to avoid extra shifting and conversion: |
* This can be approximated using integer arithmetic (and a signed |
* shift): |
* |
* error = (vlo-vhi+128) >> 8; |
* |
* The approximate differs from the exact answer only when (vlo-vhi) is |
* 128; it then gives a correction of +1 when the exact correction is |
* 0. This gives 128 errors. The exact answer (correct for all 16 bit |
* input values) is: |
* |
* error = (vlo-vhi+128)*65535 >> 24; |
* |
* An alternative arithmetic calculation which also gives no errors is: |
* |
* (V * 255 + 32895) >> 16 |
*/ |
*dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); |
#else |
/* Simply discard the low order byte */ |
*dp = *sp; |
png_int_32 tmp = *sp++; /* must be signed! */ |
tmp += (((int)*sp++ - tmp + 128) * 65535) >> 24; |
*dp++ = (png_byte)tmp; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_info->width * row_info->channels; |
} |
} |
#endif |
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED |
void /* PRIVATE */ |
/* Simply discard the low byte. This was the default behavior prior |
* to libpng-1.5.4. |
*/ |
png_do_chop(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_chop"); |
if (row_info->bit_depth == 16) |
{ |
png_bytep sp = row; /* source */ |
png_bytep dp = row; /* destination */ |
png_bytep ep = sp + row_info->rowbytes; /* end+1 */ |
while (sp < ep) |
{ |
*dp++ = *sp; |
sp += 2; /* skip low byte */ |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_info->width * row_info->channels; |
2390,7 → 3210,7 |
} |
} |
} |
row_info->channels += (png_byte)2; |
row_info->channels = (png_byte)(row_info->channels + 2); |
row_info->color_type |= PNG_COLOR_MASK_COLOR; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
2401,33 → 3221,61 |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* Reduce RGB files to grayscale, with or without alpha |
* using the equation given in Poynton's ColorFAQ at |
* <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008) |
* New link: |
* <http://www.poynton.com/notes/colour_and_gamma/> |
* using the equation given in Poynton's ColorFAQ of 1998-01-04 at |
* <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008 but |
* versions dated 1998 through November 2002 have been archived at |
* http://web.archive.org/web/20000816232553/http://www.inforamp.net/ |
* ~poynton/notes/colour_and_gamma/ColorFAQ.txt ) |
* Charles Poynton poynton at poynton.com |
* |
* Y = 0.212671 * R + 0.715160 * G + 0.072169 * B |
* |
* We approximate this with |
* which can be expressed with integers as |
* |
* Y = 0.21268 * R + 0.7151 * G + 0.07217 * B |
* Y = (6969 * R + 23434 * G + 2365 * B)/32768 |
* |
* Poynton's current link (as of January 2003 through July 2011): |
* <http://www.poynton.com/notes/colour_and_gamma/> |
* has changed the numbers slightly: |
* |
* Y = 0.2126*R + 0.7152*G + 0.0722*B |
* |
* which can be expressed with integers as |
* |
* Y = (6969 * R + 23434 * G + 2365 * B)/32768 |
* Y = (6966 * R + 23436 * G + 2366 * B)/32768 |
* |
* The calculation is to be done in a linear colorspace. |
* Historically, however, libpng uses numbers derived from the ITU-R Rec 709 |
* end point chromaticities and the D65 white point. Depending on the |
* precision used for the D65 white point this produces a variety of different |
* numbers, however if the four decimal place value used in ITU-R Rec 709 is |
* used (0.3127,0.3290) the Y calculation would be: |
* |
* Other integer coefficents can be used via png_set_rgb_to_gray(). |
* Y = (6968 * R + 23435 * G + 2366 * B)/32768 |
* |
* While this is correct the rounding results in an overflow for white, because |
* the sum of the rounded coefficients is 32769, not 32768. Consequently |
* libpng uses, instead, the closest non-overflowing approximation: |
* |
* Y = (6968 * R + 23434 * G + 2366 * B)/32768 |
* |
* Starting with libpng-1.5.5, if the image being converted has a cHRM chunk |
* (including an sRGB chunk) then the chromaticities are used to calculate the |
* coefficients. See the chunk handling in pngrutil.c for more information. |
* |
* In all cases the calculation is to be done in a linear colorspace. If no |
* gamma information is available to correct the encoding of the original RGB |
* values this results in an implicit assumption that the original PNG RGB |
* values were linear. |
* |
* Other integer coefficents can be used via png_set_rgb_to_gray(). Because |
* the API takes just red and green coefficients the blue coefficient is |
* calculated to make the sum 32768. This will result in different rounding |
* to that used above. |
*/ |
int /* PRIVATE */ |
png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) |
png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
int rgb_error = 0; |
png_debug(1, "in png_do_rgb_to_gray"); |
2435,42 → 3283,66 |
if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) && |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; |
png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; |
png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff; |
PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; |
PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; |
PNG_CONST png_uint_32 bc = 32768 - rc - gc; |
PNG_CONST png_uint_32 row_width = row_info->width; |
PNG_CONST int have_alpha = |
(row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Notice that gamma to/from 1 are not necessarily inverses (if |
* there is an overall gamma correction). Prior to 1.5.5 this code |
* checked the linearized values for equality; this doesn't match |
* the documentation, the original values must be checked. |
*/ |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if (red != green || red != blue) |
{ |
red = png_ptr->gamma_to_1[red]; |
green = png_ptr->gamma_to_1[green]; |
blue = png_ptr->gamma_to_1[blue]; |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1[ |
(rc*red + gc*green + bc*blue)>>15]; |
(rc*red + gc*green + bc*blue + 16384)>>15]; |
} |
else |
*(dp++) = *(sp - 1); |
{ |
/* If there is no overall correction the table will not be |
* set. |
*/ |
if (png_ptr->gamma_table != NULL) |
red = png_ptr->gamma_table[red]; |
*(dp++) = red; |
} |
if (have_alpha) |
*(dp++) = *(sp++); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
2480,11 → 3352,17 |
if (red != green || red != blue) |
{ |
rgb_error |= 1; |
/* NOTE: this is the historical approach which simply |
* truncates the results. |
*/ |
*(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); |
} |
else |
*(dp++) = *(sp - 1); |
*(dp++) = red; |
if (have_alpha) |
*(dp++) = *(sp++); |
} |
} |
} |
2491,12 → 3369,13 |
else /* RGB bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
2506,7 → 3385,14 |
blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; |
if (red == green && red == blue) |
{ |
if (png_ptr->gamma_16_table != NULL) |
w = png_ptr->gamma_16_table[(red&0xff) |
>> png_ptr->gamma_shift][red>>8]; |
else |
w = red; |
} |
else |
{ |
2518,7 → 3404,7 |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) |
>> png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 |
+ bc*blue_1)>>15); |
+ bc*blue_1 + 16384)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
2526,13 → 3412,21 |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
if (have_alpha) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
} |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
2544,126 → 3438,25 |
if (red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
/* From 1.5.5 in the 16 bit case do the accurate conversion even |
* in the 'fast' case - this is because this is where the code |
* ends up when handling linear 16 bit data. |
*/ |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >> |
15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
} |
} |
} |
} |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
if (red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1 |
[(rc*red + gc*green + bc*blue)>>15]; |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
else |
#endif |
if (have_alpha) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if (red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
} |
else /* RGBA bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; |
if (red == green && red == blue) |
w = red; |
else |
{ |
png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> |
png_ptr->gamma_shift][red>>8]; |
png_uint_16 green_1 = |
png_ptr->gamma_16_to_1[(green&0xff) >> |
png_ptr->gamma_shift][green>>8]; |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> |
png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc * red_1 |
+ gc * green_1 + bc * blue_1)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
} |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
red = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2; |
green = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2; |
blue = (png_uint_16)((*(sp)<<8) | *(sp + 1)); sp += 2; |
if (red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
} |
} |
row_info->channels -= 2; |
row_info->channels = (png_byte)(row_info->channels - 2); |
row_info->color_type = (png_byte)(row_info->color_type & |
~PNG_COLOR_MASK_COLOR); |
row_info->pixel_depth = (png_byte)(row_info->channels * |
2673,11 → 3466,13 |
return rgb_error; |
} |
#endif |
#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ |
#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED |
/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth |
* large of png_color. This lets grayscale images be treated as |
* paletted. Most useful for gamma correction and simplification |
* of code. |
* of code. This API is not used internally. |
*/ |
void PNGAPI |
png_build_grayscale_palette(int bit_depth, png_colorp palette) |
2727,34 → 3522,37 |
palette[i].blue = (png_byte)v; |
} |
} |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
/* Replace any alpha or transparency with the supplied background color. |
* "background" is already in the screen gamma, while "background_1" is |
* at a gamma of 1.0. Paletted files have already been taken care of. |
*/ |
void /* PRIVATE */ |
png_do_background(png_row_infop row_info, png_bytep row, |
png_const_color_16p trans_color, png_const_color_16p background |
png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr) |
{ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
, png_const_color_16p background_1, png_const_bytep gamma_table, |
png_const_bytep gamma_from_1, png_const_bytep gamma_to_1, |
png_const_uint_16pp gamma_16, png_const_uint_16pp gamma_16_from_1, |
png_const_uint_16pp gamma_16_to_1, int gamma_shift |
png_const_bytep gamma_table = png_ptr->gamma_table; |
png_const_bytep gamma_from_1 = png_ptr->gamma_from_1; |
png_const_bytep gamma_to_1 = png_ptr->gamma_to_1; |
png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table; |
png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1; |
png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1; |
int gamma_shift = png_ptr->gamma_shift; |
int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0; |
#endif |
) |
{ |
png_bytep sp, dp; |
png_bytep sp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
int shift; |
png_debug(1, "in png_do_background"); |
png_debug(1, "in png_do_compose"); |
if (background != NULL && |
(!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || |
(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color))) |
{ |
switch (row_info->color_type) |
{ |
2769,10 → 3567,11 |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x01) |
== trans_color->gray) |
== png_ptr->trans_color.gray) |
{ |
*sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
unsigned int tmp = *sp & (0x7f7f >> (7 - shift)); |
tmp |= png_ptr->background.gray << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
if (!shift) |
2797,19 → 3596,21 |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_color->gray) |
== png_ptr->trans_color.gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); |
tmp |= png_ptr->background.gray << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x03); |
png_byte g = (png_byte)((gamma_table [p | (p << 2) | |
(p << 4) | (p << 6)] >> 6) & 0x03); |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
unsigned int p = (*sp >> shift) & 0x03; |
unsigned int g = (gamma_table [p | (p << 2) | |
(p << 4) | (p << 6)] >> 6) & 0x03; |
unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); |
tmp |= g << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
if (!shift) |
2831,10 → 3632,11 |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_color->gray) |
== png_ptr->trans_color.gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); |
tmp |= png_ptr->background.gray << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
if (!shift) |
2860,19 → 3662,21 |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_color->gray) |
== png_ptr->trans_color.gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
unsigned int tmp = *sp & (0xf0f >> (4 - shift)); |
tmp |= png_ptr->background.gray << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x0f); |
png_byte g = (png_byte)((gamma_table[p | |
(p << 4)] >> 4) & 0x0f); |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
unsigned int p = (*sp >> shift) & 0x0f; |
unsigned int g = (gamma_table[p | (p << 4)] >> 4) & |
0x0f; |
unsigned int tmp = *sp & (0xf0f >> (4 - shift)); |
tmp |= g << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
if (!shift) |
2894,10 → 3698,11 |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_color->gray) |
== png_ptr->trans_color.gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
unsigned int tmp = *sp & (0xf0f >> (4 - shift)); |
tmp |= png_ptr->background.gray << shift; |
*sp = (png_byte)(tmp & 0xff); |
} |
if (!shift) |
2921,8 → 3726,8 |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_color->gray) |
*sp = (png_byte)background->gray; |
if (*sp == png_ptr->trans_color.gray) |
*sp = (png_byte)png_ptr->background.gray; |
else |
*sp = gamma_table[*sp]; |
2934,8 → 3739,8 |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_color->gray) |
*sp = (png_byte)background->gray; |
if (*sp == png_ptr->trans_color.gray) |
*sp = (png_byte)png_ptr->background.gray; |
} |
} |
break; |
2953,11 → 3758,13 |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_color->gray) |
if (v == png_ptr->trans_color.gray) |
{ |
/* Background is already in screen gamma */ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
*sp = (png_byte)((png_ptr->background.gray >> 8) |
& 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.gray |
& 0xff); |
} |
else |
2978,10 → 3785,12 |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_color->gray) |
if (v == png_ptr->trans_color.gray) |
{ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
*sp = (png_byte)((png_ptr->background.gray >> 8) |
& 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.gray |
& 0xff); |
} |
} |
} |
3004,13 → 3813,13 |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_color->red && |
*(sp + 1) == trans_color->green && |
*(sp + 2) == trans_color->blue) |
if (*sp == png_ptr->trans_color.red && |
*(sp + 1) == png_ptr->trans_color.green && |
*(sp + 2) == png_ptr->trans_color.blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
*sp = (png_byte)png_ptr->background.red; |
*(sp + 1) = (png_byte)png_ptr->background.green; |
*(sp + 2) = (png_byte)png_ptr->background.blue; |
} |
else |
3027,13 → 3836,13 |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_color->red && |
*(sp + 1) == trans_color->green && |
*(sp + 2) == trans_color->blue) |
if (*sp == png_ptr->trans_color.red && |
*(sp + 1) == png_ptr->trans_color.green && |
*(sp + 2) == png_ptr->trans_color.blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
*sp = (png_byte)png_ptr->background.red; |
*(sp + 1) = (png_byte)png_ptr->background.green; |
*(sp + 2) = (png_byte)png_ptr->background.blue; |
} |
} |
} |
3054,16 → 3863,20 |
png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) |
+ *(sp + 5)); |
if (r == trans_color->red && g == trans_color->green && |
b == trans_color->blue) |
if (r == png_ptr->trans_color.red && |
g == png_ptr->trans_color.green && |
b == png_ptr->trans_color.blue) |
{ |
/* Background is already in screen gamma */ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); |
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) |
& 0xff); |
*(sp + 3) = (png_byte)(png_ptr->background.green |
& 0xff); |
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) |
& 0xff); |
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); |
} |
else |
3097,15 → 3910,19 |
png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) |
+ *(sp + 5)); |
if (r == trans_color->red && g == trans_color->green && |
b == trans_color->blue) |
if (r == png_ptr->trans_color.red && |
g == png_ptr->trans_color.green && |
b == png_ptr->trans_color.blue) |
{ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); |
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) |
& 0xff); |
*(sp + 3) = (png_byte)(png_ptr->background.green |
& 0xff); |
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) |
& 0xff); |
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); |
} |
} |
} |
3122,18 → 3939,17 |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_uint_16 a = *(sp + 1); |
if (a == 0xff) |
*dp = gamma_table[*sp]; |
*sp = gamma_table[*sp]; |
else if (a == 0) |
{ |
/* Background is already in screen gamma */ |
*dp = (png_byte)background->gray; |
*sp = (png_byte)png_ptr->background.gray; |
} |
else |
3141,8 → 3957,10 |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->gray); |
*dp = gamma_from_1[w]; |
png_composite(w, v, a, png_ptr->background_1.gray); |
if (!optimize) |
w = gamma_from_1[w]; |
*sp = w; |
} |
} |
} |
3150,24 → 3968,15 |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_byte a = *(sp + 1); |
if (a == 0xff) |
*dp = *sp; |
if (a == 0) |
*sp = (png_byte)png_ptr->background.gray; |
#ifdef PNG_READ_GAMMA_SUPPORTED |
else if (a == 0) |
*dp = (png_byte)background->gray; |
else |
png_composite(*dp, *sp, a, background_1->gray); |
#else |
*dp = (png_byte)background->gray; |
#endif |
else if (a < 0xff) |
png_composite(*sp, *sp, a, png_ptr->background.gray); |
} |
} |
} |
3178,8 → 3987,7 |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
for (i = 0; i < row_width; i++, sp += 4) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) |
+ *(sp + 3)); |
3189,33 → 3997,31 |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
} |
#ifdef PNG_READ_GAMMA_SUPPORTED |
else if (a == 0) |
#else |
else |
#endif |
{ |
/* Background is already in screen gamma */ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
*sp = (png_byte)((png_ptr->background.gray >> 8) |
& 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); |
} |
#ifdef PNG_READ_GAMMA_SUPPORTED |
else |
{ |
png_uint_16 g, v, w; |
g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(v, g, a, background_1->gray); |
png_composite_16(v, g, a, png_ptr->background_1.gray); |
if (optimize) |
w = v; |
else |
w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; |
*dp = (png_byte)((w >> 8) & 0xff); |
*(dp + 1) = (png_byte)(w & 0xff); |
*sp = (png_byte)((w >> 8) & 0xff); |
*(sp + 1) = (png_byte)(w & 0xff); |
} |
#endif |
} |
} |
else |
3222,36 → 4028,27 |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
for (i = 0; i < row_width; i++, sp += 4) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) |
+ *(sp + 3)); |
if (a == (png_uint_16)0xffff) |
png_memcpy(dp, sp, 2); |
#ifdef PNG_READ_GAMMA_SUPPORTED |
else if (a == 0) |
#else |
else |
#endif |
if (a == 0) |
{ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
*sp = (png_byte)((png_ptr->background.gray >> 8) |
& 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); |
} |
#ifdef PNG_READ_GAMMA_SUPPORTED |
else |
else if (a < 0xffff) |
{ |
png_uint_16 g, v; |
g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_composite_16(v, g, a, background_1->gray); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
png_composite_16(v, g, a, png_ptr->background.gray); |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
} |
#endif |
} |
} |
} |
3267,24 → 4064,23 |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
for (i = 0; i < row_width; i++, sp += 4) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
{ |
*dp = gamma_table[*sp]; |
*(dp + 1) = gamma_table[*(sp + 1)]; |
*(dp + 2) = gamma_table[*(sp + 2)]; |
*sp = gamma_table[*sp]; |
*(sp + 1) = gamma_table[*(sp + 1)]; |
*(sp + 2) = gamma_table[*(sp + 2)]; |
} |
else if (a == 0) |
{ |
/* Background is already in screen gamma */ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
*sp = (png_byte)png_ptr->background.red; |
*(sp + 1) = (png_byte)png_ptr->background.green; |
*(sp + 2) = (png_byte)png_ptr->background.blue; |
} |
else |
3292,16 → 4088,19 |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->red); |
*dp = gamma_from_1[w]; |
png_composite(w, v, a, png_ptr->background_1.red); |
if (!optimize) w = gamma_from_1[w]; |
*sp = w; |
v = gamma_to_1[*(sp + 1)]; |
png_composite(w, v, a, background_1->green); |
*(dp + 1) = gamma_from_1[w]; |
png_composite(w, v, a, png_ptr->background_1.green); |
if (!optimize) w = gamma_from_1[w]; |
*(sp + 1) = w; |
v = gamma_to_1[*(sp + 2)]; |
png_composite(w, v, a, background_1->blue); |
*(dp + 2) = gamma_from_1[w]; |
png_composite(w, v, a, png_ptr->background_1.blue); |
if (!optimize) w = gamma_from_1[w]; |
*(sp + 2) = w; |
} |
} |
} |
3309,34 → 4108,26 |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
for (i = 0; i < row_width; i++, sp += 4) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
if (a == 0) |
{ |
*dp = *sp; |
*(dp + 1) = *(sp + 1); |
*(dp + 2) = *(sp + 2); |
*sp = (png_byte)png_ptr->background.red; |
*(sp + 1) = (png_byte)png_ptr->background.green; |
*(sp + 2) = (png_byte)png_ptr->background.blue; |
} |
else if (a == 0) |
else if (a < 0xff) |
{ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
} |
png_composite(*sp, *sp, a, png_ptr->background.red); |
else |
{ |
png_composite(*dp, *sp, a, background->red); |
png_composite(*(sp + 1), *(sp + 1), a, |
png_ptr->background.green); |
png_composite(*(dp + 1), *(sp + 1), a, |
background->green); |
png_composite(*(dp + 2), *(sp + 2), a, |
background->blue); |
png_composite(*(sp + 2), *(sp + 2), a, |
png_ptr->background.blue); |
} |
} |
} |
3348,8 → 4139,7 |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
for (i = 0; i < row_width; i++, sp += 8) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
3359,53 → 4149,61 |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
*(sp + 2) = (png_byte)((v >> 8) & 0xff); |
*(sp + 3) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
*(sp + 4) = (png_byte)((v >> 8) & 0xff); |
*(sp + 5) = (png_byte)(v & 0xff); |
} |
else if (a == 0) |
{ |
/* Background is already in screen gamma */ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); |
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) |
& 0xff); |
*(sp + 3) = (png_byte)(png_ptr->background.green |
& 0xff); |
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) |
& 0xff); |
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); |
} |
else |
{ |
png_uint_16 v, w, x; |
png_uint_16 v, w; |
v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(w, v, a, background_1->red); |
png_composite_16(w, v, a, png_ptr->background_1.red); |
if (!optimize) |
w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> |
8]; |
*sp = (png_byte)((w >> 8) & 0xff); |
*(sp + 1) = (png_byte)(w & 0xff); |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*dp = (png_byte)((x >> 8) & 0xff); |
*(dp + 1) = (png_byte)(x & 0xff); |
v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
png_composite_16(w, v, a, background_1->green); |
png_composite_16(w, v, a, png_ptr->background_1.green); |
if (!optimize) |
w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> |
8]; |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*(dp + 2) = (png_byte)((x >> 8) & 0xff); |
*(dp + 3) = (png_byte)(x & 0xff); |
*(sp + 2) = (png_byte)((w >> 8) & 0xff); |
*(sp + 3) = (png_byte)(w & 0xff); |
v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
png_composite_16(w, v, a, background_1->blue); |
png_composite_16(w, v, a, png_ptr->background_1.blue); |
if (!optimize) |
w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> |
8]; |
x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; |
*(dp + 4) = (png_byte)((x >> 8) & 0xff); |
*(dp + 5) = (png_byte)(x & 0xff); |
*(sp + 4) = (png_byte)((w >> 8) & 0xff); |
*(sp + 5) = (png_byte)(w & 0xff); |
} |
} |
} |
3414,29 → 4212,26 |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
for (i = 0; i < row_width; i++, sp += 8) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
if (a == (png_uint_16)0xffff) |
if (a == 0) |
{ |
png_memcpy(dp, sp, 6); |
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); |
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) |
& 0xff); |
*(sp + 3) = (png_byte)(png_ptr->background.green |
& 0xff); |
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) |
& 0xff); |
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); |
} |
else if (a == 0) |
else if (a < 0xffff) |
{ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v; |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
3445,17 → 4240,17 |
png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) |
+ *(sp + 5)); |
png_composite_16(v, r, a, background->red); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
png_composite_16(v, r, a, png_ptr->background.red); |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
png_composite_16(v, g, a, background->green); |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
png_composite_16(v, g, a, png_ptr->background.green); |
*(sp + 2) = (png_byte)((v >> 8) & 0xff); |
*(sp + 3) = (png_byte)(v & 0xff); |
png_composite_16(v, b, a, background->blue); |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
png_composite_16(v, b, a, png_ptr->background.blue); |
*(sp + 4) = (png_byte)((v >> 8) & 0xff); |
*(sp + 5) = (png_byte)(v & 0xff); |
} |
} |
} |
3466,19 → 4261,9 |
default: |
break; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
row_info->color_type = (png_byte)(row_info->color_type & |
~PNG_COLOR_MASK_ALPHA); |
row_info->channels--; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
} |
} |
#endif |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_READ_ALPHA_MODE_SUPPORTED */ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Gamma correct the image, avoiding the alpha channel. Make sure |
3488,10 → 4273,12 |
* build_gamma_table(). |
*/ |
void /* PRIVATE */ |
png_do_gamma(png_row_infop row_info, png_bytep row, |
png_const_bytep gamma_table, png_const_uint_16pp gamma_16_table, |
int gamma_shift) |
png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr) |
{ |
png_const_bytep gamma_table = png_ptr->gamma_table; |
png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table; |
int gamma_shift = png_ptr->gamma_shift; |
png_bytep sp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
3681,6 → 4468,73 |
} |
#endif |
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED |
/* Encode the alpha channel to the output gamma (the input channel is always |
* linear.) Called only with color types that have an alpha channel. Needs the |
* from_1 tables. |
*/ |
void /* PRIVATE */ |
png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr) |
{ |
png_uint_32 row_width = row_info->width; |
png_debug(1, "in png_do_encode_alpha"); |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
PNG_CONST png_bytep table = png_ptr->gamma_from_1; |
if (table != NULL) |
{ |
PNG_CONST int step = |
(row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2; |
/* The alpha channel is the last component: */ |
row += step - 1; |
for (; row_width > 0; --row_width, row += step) |
*row = table[*row]; |
return; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
PNG_CONST png_uint_16pp table = png_ptr->gamma_16_from_1; |
PNG_CONST int gamma_shift = png_ptr->gamma_shift; |
if (table != NULL) |
{ |
PNG_CONST int step = |
(row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4; |
/* The alpha channel is the last component: */ |
row += step - 2; |
for (; row_width > 0; --row_width, row += step) |
{ |
png_uint_16 v; |
v = table[*(row + 1) >> gamma_shift][*row]; |
*row = (png_byte)((v >> 8) & 0xff); |
*(row + 1) = (png_byte)(v & 0xff); |
} |
return; |
} |
} |
} |
/* Only get to here if called with a weird row_info; no harm has been done, |
* so just issue a warning. |
*/ |
png_warning(png_ptr, "png_do_encode_alpha: unexpected call"); |
} |
#endif |
#ifdef PNG_READ_EXPAND_SUPPORTED |
/* Expands a palette row to an RGB or RGBA row depending |
* upon whether you supply trans and num_trans. |
3786,7 → 4640,7 |
if (row_info->bit_depth == 8) |
{ |
{ |
if (trans_alpha != NULL) |
if (num_trans > 0) |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
3840,7 → 4694,7 |
*/ |
void /* PRIVATE */ |
png_do_expand(png_row_infop row_info, png_bytep row, |
png_const_color_16p trans_value) |
png_const_color_16p trans_color) |
{ |
int shift, value; |
png_bytep sp, dp; |
3852,7 → 4706,7 |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); |
unsigned int gray = trans_color ? trans_color->gray : 0; |
if (row_info->bit_depth < 8) |
{ |
3860,7 → 4714,7 |
{ |
case 1: |
{ |
gray = (png_uint_16)((gray & 0x01) * 0xff); |
gray = (gray & 0x01) * 0xff; |
sp = row + (png_size_t)((row_width - 1) >> 3); |
dp = row + (png_size_t)row_width - 1; |
shift = 7 - (int)((row_width + 7) & 0x07); |
3888,7 → 4742,7 |
case 2: |
{ |
gray = (png_uint_16)((gray & 0x03) * 0x55); |
gray = (gray & 0x03) * 0x55; |
sp = row + (png_size_t)((row_width - 1) >> 2); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
3913,7 → 4767,7 |
case 4: |
{ |
gray = (png_uint_16)((gray & 0x0f) * 0x11); |
gray = (gray & 0x0f) * 0x11; |
sp = row + (png_size_t)((row_width - 1) >> 1); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); |
3944,7 → 4798,7 |
row_info->rowbytes = row_width; |
} |
if (trans_value != NULL) |
if (trans_color != NULL) |
{ |
if (row_info->bit_depth == 8) |
{ |
3966,8 → 4820,8 |
else if (row_info->bit_depth == 16) |
{ |
png_byte gray_high = (png_byte)((gray >> 8) & 0xff); |
png_byte gray_low = (png_byte)(gray & 0xff); |
unsigned int gray_high = (gray >> 8) & 0xff; |
unsigned int gray_low = gray & 0xff; |
sp = row + row_info->rowbytes - 1; |
dp = row + (row_info->rowbytes << 1) - 1; |
for (i = 0; i < row_width; i++) |
3996,13 → 4850,13 |
row_width); |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_color) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_byte red = (png_byte)(trans_value->red & 0xff); |
png_byte green = (png_byte)(trans_value->green & 0xff); |
png_byte blue = (png_byte)(trans_value->blue & 0xff); |
png_byte red = (png_byte)(trans_color->red & 0xff); |
png_byte green = (png_byte)(trans_color->green & 0xff); |
png_byte blue = (png_byte)(trans_color->blue & 0xff); |
sp = row + (png_size_t)row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
for (i = 0; i < row_width; i++) |
4020,12 → 4874,12 |
} |
else if (row_info->bit_depth == 16) |
{ |
png_byte red_high = (png_byte)((trans_value->red >> 8) & 0xff); |
png_byte green_high = (png_byte)((trans_value->green >> 8) & 0xff); |
png_byte blue_high = (png_byte)((trans_value->blue >> 8) & 0xff); |
png_byte red_low = (png_byte)(trans_value->red & 0xff); |
png_byte green_low = (png_byte)(trans_value->green & 0xff); |
png_byte blue_low = (png_byte)(trans_value->blue & 0xff); |
png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff); |
png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff); |
png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff); |
png_byte red_low = (png_byte)(trans_color->red & 0xff); |
png_byte green_low = (png_byte)(trans_color->green & 0xff); |
png_byte blue_low = (png_byte)(trans_color->blue & 0xff); |
sp = row + row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 3) - 1; |
for (i = 0; i < row_width; i++) |
4064,6 → 4918,37 |
} |
#endif |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
/* If the bit depth is 8 and the color type is not a palette type expand the |
* whole row to 16 bits. Has no effect otherwise. |
*/ |
void /* PRIVATE */ |
png_do_expand_16(png_row_infop row_info, png_bytep row) |
{ |
if (row_info->bit_depth == 8 && |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
/* The row have a sequence of bytes containing [0..255] and we need |
* to turn it into another row containing [0..65535], to do this we |
* calculate: |
* |
* (input / 255) * 65535 |
* |
* Which happens to be exactly input * 257 and this can be achieved |
* simply by byte replication in place (copying backwards). |
*/ |
png_byte *sp = row + row_info->rowbytes; /* source, last byte + 1 */ |
png_byte *dp = sp + row_info->rowbytes; /* destination, end + 1 */ |
while (dp > sp) |
dp[-2] = dp[-1] = *--sp, dp -= 2; |
row_info->rowbytes *= 2; |
row_info->bit_depth = 16; |
row_info->pixel_depth = (png_byte)(row_info->channels * 16); |
} |
} |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
void /* PRIVATE */ |
png_do_quantize(png_row_infop row_info, png_bytep row, |
4157,6 → 5042,7 |
} |
} |
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ |
#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
/* Undoes intrapixel differencing */ |
4210,8 → 5096,8 |
png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1); |
png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3); |
png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5); |
png_uint_32 red = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL); |
png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL); |
png_uint_32 red = (s0 + s1 + 65536) & 0xffff; |
png_uint_32 blue = (s2 + s1 + 65536) & 0xffff; |
*(rp ) = (png_byte)((red >> 8) & 0xff); |
*(rp + 1) = (png_byte)(red & 0xff); |
*(rp + 4) = (png_byte)((blue >> 8) & 0xff); |
/programs/develop/libraries/libpng/pngrutil.c |
---|
1,8 → 1,8 |
/* pngrutil.c - utilities to read a PNG file |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.4 [September 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
18,10 → 18,8 |
#ifdef PNG_READ_SUPPORTED |
#define png_strtod(p,a,b) strtod(a,b) |
png_uint_32 PNGAPI |
png_get_uint_31(png_structp png_ptr, png_const_bytep buf) |
png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
40,7 → 38,7 |
#define PNG_FIXED_ERROR (-1) |
static png_fixed_point /* PRIVATE */ |
png_get_fixed_point(png_structp png_ptr, png_const_bytep buf) |
png_get_fixed_point(png_structrp png_ptr, png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
87,10 → 85,10 |
png_get_int_32)(png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
if ((uval & 0x80000000L) == 0) /* non-negative */ |
if ((uval & 0x80000000) == 0) /* non-negative */ |
return uval; |
uval = (uval ^ 0xffffffffL) + 1; /* 2's complement: -x = ~x+1 */ |
uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */ |
return -(png_int_32)uval; |
} |
114,7 → 112,7 |
/* Read and check the PNG file signature */ |
void /* PRIVATE */ |
png_read_sig(png_structp png_ptr, png_infop info_ptr) |
png_read_sig(png_structrp png_ptr, png_inforp info_ptr) |
{ |
png_size_t num_checked, num_to_check; |
149,7 → 147,7 |
* Put the type name into png_ptr->chunk_name, and return the length. |
*/ |
png_uint_32 /* PRIVATE */ |
png_read_chunk_header(png_structp png_ptr) |
png_read_chunk_header(png_structrp png_ptr) |
{ |
png_byte buf[8]; |
png_uint_32 length; |
165,14 → 163,14 |
length = png_get_uint_31(png_ptr, buf); |
/* Put the chunk name into png_ptr->chunk_name. */ |
png_memcpy(png_ptr->chunk_name, buf + 4, 4); |
png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4); |
png_debug2(0, "Reading %s chunk, length = %u", |
png_ptr->chunk_name, length); |
png_debug2(0, "Reading %lx chunk, length = %lu", |
(unsigned long)png_ptr->chunk_name, (unsigned long)length); |
/* Reset the crc and run it over the chunk name. */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, png_ptr->chunk_name, 4); |
png_calculate_crc(png_ptr, buf + 4, 4); |
/* Check to see if chunk name is valid. */ |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
186,7 → 184,7 |
/* Read data, and (optionally) run it through the CRC. */ |
void /* PRIVATE */ |
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) |
png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length) |
{ |
if (png_ptr == NULL) |
return; |
196,32 → 194,34 |
} |
/* Optionally skip data and then check the CRC. Depending on whether we |
* are reading a ancillary or critical chunk, and how the program has set |
* are reading an ancillary or critical chunk, and how the program has set |
* things up, we may calculate the CRC on the data and print a message. |
* Returns '1' if there was a CRC error, '0' otherwise. |
*/ |
int /* PRIVATE */ |
png_crc_finish(png_structp png_ptr, png_uint_32 skip) |
png_crc_finish(png_structrp png_ptr, png_uint_32 skip) |
{ |
png_size_t i; |
png_size_t istop = png_ptr->zbuf_size; |
for (i = (png_size_t)skip; i > istop; i -= istop) |
/* The size of the local buffer for inflate is a good guess as to a |
* reasonable size to use for buffering reads from the application. |
*/ |
while (skip > 0) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
} |
png_uint_32 len; |
png_byte tmpbuf[PNG_INFLATE_BUF_SIZE]; |
if (i) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, i); |
len = (sizeof tmpbuf); |
if (len > skip) |
len = skip; |
skip -= len; |
png_crc_read(png_ptr, tmpbuf, len); |
} |
if (png_crc_error(png_ptr)) |
{ |
if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ |
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || |
(!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ |
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) |
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ? |
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) : |
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)) |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
} |
242,13 → 242,13 |
* the data it has read thus far. |
*/ |
int /* PRIVATE */ |
png_crc_error(png_structp png_ptr) |
png_crc_error(png_structrp png_ptr) |
{ |
png_byte crc_bytes[4]; |
png_uint_32 crc; |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)) |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
278,269 → 278,521 |
return (0); |
} |
#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ |
defined(PNG_READ_iCCP_SUPPORTED) |
static png_size_t |
png_inflate(png_structp png_ptr, png_bytep data, png_size_t size, |
png_bytep output, png_size_t output_size) |
/* Manage the read buffer; this simply reallocates the buffer if it is not small |
* enough (or if it is not allocated). The routine returns a pointer to the |
* buffer; if an error occurs and 'warn' is set the routine returns NULL, else |
* it will call png_error (via png_malloc) on failure. (warn == 2 means |
* 'silent'). |
*/ |
static png_bytep |
png_read_buffer(png_structrp png_ptr, png_alloc_size_t new_size, int warn) |
{ |
png_size_t count = 0; |
png_bytep buffer = png_ptr->read_buffer; |
/* zlib can't necessarily handle more than 65535 bytes at once (i.e. it can't |
* even necessarily handle 65536 bytes) because the type uInt is "16 bits or |
* more". Consequently it is necessary to chunk the input to zlib. This |
* code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the maximum value |
* that can be stored in a uInt.) It is possible to set ZLIB_IO_MAX to a |
* lower value in pngpriv.h and this may sometimes have a performance |
* advantage, because it forces access of the input data to be separated from |
* at least some of the use by some period of time. |
*/ |
png_ptr->zstream.next_in = data; |
/* avail_in is set below from 'size' */ |
png_ptr->zstream.avail_in = 0; |
if (buffer != NULL && new_size > png_ptr->read_buffer_size) |
{ |
png_ptr->read_buffer = NULL; |
png_ptr->read_buffer = NULL; |
png_ptr->read_buffer_size = 0; |
png_free(png_ptr, buffer); |
buffer = NULL; |
} |
while (1) |
if (buffer == NULL) |
{ |
int ret, avail; |
buffer = png_voidcast(png_bytep, png_malloc_base(png_ptr, new_size)); |
/* The setting of 'avail_in' used to be outside the loop, by setting it |
* inside it is possible to chunk the input to zlib and simply rely on |
* zlib to advance the 'next_in' pointer. This allows arbitrary amounts o |
* data to be passed through zlib at the unavoidable cost of requiring a |
* window save (memcpy of up to 32768 output bytes) every ZLIB_IO_MAX |
* input bytes. |
*/ |
if (png_ptr->zstream.avail_in == 0 && size > 0) |
if (buffer != NULL) |
{ |
if (size <= ZLIB_IO_MAX) |
{ |
/* The value is less than ZLIB_IO_MAX so the cast is safe: */ |
png_ptr->zstream.avail_in = (uInt)size; |
size = 0; |
png_ptr->read_buffer = buffer; |
png_ptr->read_buffer_size = new_size; |
} |
else if (warn < 2) /* else silent */ |
{ |
#ifdef PNG_WARNINGS_SUPPORTED |
if (warn) |
png_chunk_warning(png_ptr, "insufficient memory to read chunk"); |
else |
#endif |
{ |
png_ptr->zstream.avail_in = ZLIB_IO_MAX; |
size -= ZLIB_IO_MAX; |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
png_chunk_error(png_ptr, "insufficient memory to read chunk"); |
#endif |
} |
} |
} |
/* Reset the output buffer each time round - we empty it |
* after every inflate call. |
return buffer; |
} |
/* png_inflate_claim: claim the zstream for some nefarious purpose that involves |
* decompression. Returns Z_OK on success, else a zlib error code. It checks |
* the owner but, in final release builds, just issues a warning if some other |
* chunk apparently owns the stream. Prior to release it does a png_error. |
*/ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = png_ptr->zbuf_size; |
static int |
png_inflate_claim(png_structrp png_ptr, png_uint_32 owner) |
{ |
if (png_ptr->zowner != 0) |
{ |
char msg[64]; |
ret = inflate(&png_ptr->zstream, Z_NO_FLUSH); |
avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
PNG_STRING_FROM_CHUNK(msg, png_ptr->zowner); |
/* So the message that results is "<chunk> using zstream"; this is an |
* internal error, but is very useful for debugging. i18n requirements |
* are minimal. |
*/ |
(void)png_safecat(msg, (sizeof msg), 4, " using zstream"); |
# if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC |
png_chunk_warning(png_ptr, msg); |
png_ptr->zowner = 0; |
# else |
png_chunk_error(png_ptr, msg); |
# endif |
} |
/* First copy/count any new output - but only if we didn't |
* get an error code. |
/* Implementation note: unlike 'png_deflate_claim' this internal function |
* does not take the size of the data as an argument. Some efficiency could |
* be gained by using this when it is known *if* the zlib stream itself does |
* not record the number; however, this is an illusion: the original writer |
* of the PNG may have selected a lower window size, and we really must |
* follow that because, for systems with with limited capabilities, we |
* would otherwise reject the application's attempts to use a smaller window |
* size (zlib doesn't have an interface to say "this or lower"!). |
* |
* inflateReset2 was added to zlib 1.2.4; before this the window could not be |
* reset, therefore it is necessary to always allocate the maximum window |
* size with earlier zlibs just in case later compressed chunks need it. |
*/ |
if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0) |
{ |
png_size_t space = avail; /* > 0, see above */ |
int ret; /* zlib return code */ |
# if PNG_ZLIB_VERNUM >= 0x1240 |
if (output != 0 && output_size > count) |
{ |
png_size_t copy = output_size - count; |
# if defined(PNG_SET_OPTION_SUPPORTED) && \ |
defined(PNG_MAXIMUM_INFLATE_WINDOW) |
int window_bits; |
if (space < copy) |
copy = space; |
if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) == |
PNG_OPTION_ON) |
window_bits = 15; |
png_memcpy(output + count, png_ptr->zbuf, copy); |
} |
count += space; |
} |
else |
window_bits = 0; |
# else |
# define window_bits 0 |
# endif |
# endif |
if (ret == Z_OK) |
continue; |
/* Termination conditions - always reset the zstream, it |
* must be left in inflateInit state. |
/* Set this for safety, just in case the previous owner left pointers to |
* memory allocations. |
*/ |
png_ptr->zstream.next_in = NULL; |
png_ptr->zstream.avail_in = 0; |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.next_out = NULL; |
png_ptr->zstream.avail_out = 0; |
if (ret == Z_STREAM_END) |
return count; /* NOTE: may be zero. */ |
/* Now handle the error codes - the API always returns 0 |
* and the error message is dumped into the uncompressed |
* buffer if available. |
*/ |
if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) |
{ |
PNG_CONST char *msg; |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char umsg[52]; |
# if PNG_ZLIB_VERNUM < 0x1240 |
ret = inflateReset(&png_ptr->zstream); |
# else |
ret = inflateReset2(&png_ptr->zstream, window_bits); |
#endif |
if (png_ptr->zstream.msg != 0) |
msg = png_ptr->zstream.msg; |
} |
else |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
switch (ret) |
{ |
case Z_BUF_ERROR: |
msg = "Buffer error in compressed datastream in %s chunk"; |
break; |
# if PNG_ZLIB_VERNUM < 0x1240 |
ret = inflateInit(&png_ptr->zstream); |
# else |
ret = inflateInit2(&png_ptr->zstream, window_bits); |
# endif |
case Z_DATA_ERROR: |
msg = "Data error in compressed datastream in %s chunk"; |
break; |
if (ret == Z_OK) |
png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED; |
} |
default: |
msg = "Incomplete compressed datastream in %s chunk"; |
break; |
if (ret == Z_OK) |
png_ptr->zowner = owner; |
else |
png_zstream_error(png_ptr, ret); |
return ret; |
} |
png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name); |
msg = umsg; |
#else |
msg = "Damaged compressed datastream in chunk other than IDAT"; |
# ifdef window_bits |
# undef window_bits |
#endif |
} |
png_warning(png_ptr, msg); |
#ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED |
/* png_inflate now returns zlib error codes including Z_OK and Z_STREAM_END to |
* allow the caller to do multiple calls if required. If the 'finish' flag is |
* set Z_FINISH will be passed to the final inflate() call and Z_STREAM_END must |
* be returned or there has been a problem, otherwise Z_SYNC_FLUSH is used and |
* Z_OK or Z_STREAM_END will be returned on success. |
* |
* The input and output sizes are updated to the actual amounts of data consumed |
* or written, not the amount available (as in a z_stream). The data pointers |
* are not changed, so the next input is (data+input_size) and the next |
* available output is (output+output_size). |
*/ |
static int |
png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish, |
/* INPUT: */ png_const_bytep input, png_uint_32p input_size_ptr, |
/* OUTPUT: */ png_bytep output, png_alloc_size_t *output_size_ptr) |
{ |
if (png_ptr->zowner == owner) /* Else not claimed */ |
{ |
int ret; |
png_alloc_size_t avail_out = *output_size_ptr; |
png_uint_32 avail_in = *input_size_ptr; |
/* zlib can't necessarily handle more than 65535 bytes at once (i.e. it |
* can't even necessarily handle 65536 bytes) because the type uInt is |
* "16 bits or more". Consequently it is necessary to chunk the input to |
* zlib. This code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the |
* maximum value that can be stored in a uInt.) It is possible to set |
* ZLIB_IO_MAX to a lower value in pngpriv.h and this may sometimes have |
* a performance advantage, because it reduces the amount of data accessed |
* at each step and that may give the OS more time to page it in. |
*/ |
png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input); |
/* avail_in and avail_out are set below from 'size' */ |
png_ptr->zstream.avail_in = 0; |
png_ptr->zstream.avail_out = 0; |
/* Read directly into the output if it is available (this is set to |
* a local buffer below if output is NULL). |
*/ |
if (output != NULL) |
png_ptr->zstream.next_out = output; |
do |
{ |
uInt avail; |
Byte local_buffer[PNG_INFLATE_BUF_SIZE]; |
/* zlib INPUT BUFFER */ |
/* The setting of 'avail_in' used to be outside the loop; by setting it |
* inside it is possible to chunk the input to zlib and simply rely on |
* zlib to advance the 'next_in' pointer. This allows arbitrary |
* amounts of data to be passed through zlib at the unavoidable cost of |
* requiring a window save (memcpy of up to 32768 output bytes) |
* every ZLIB_IO_MAX input bytes. |
*/ |
avail_in += png_ptr->zstream.avail_in; /* not consumed last time */ |
avail = ZLIB_IO_MAX; |
if (avail_in < avail) |
avail = (uInt)avail_in; /* safe: < than ZLIB_IO_MAX */ |
avail_in -= avail; |
png_ptr->zstream.avail_in = avail; |
/* zlib OUTPUT BUFFER */ |
avail_out += png_ptr->zstream.avail_out; /* not written last time */ |
avail = ZLIB_IO_MAX; /* maximum zlib can process */ |
if (output == NULL) |
{ |
/* Reset the output buffer each time round if output is NULL and |
* make available the full buffer, up to 'remaining_space' |
*/ |
png_ptr->zstream.next_out = local_buffer; |
if ((sizeof local_buffer) < avail) |
avail = (sizeof local_buffer); |
} |
/* 0 means an error - notice that this code simply ignores |
* zero length compressed chunks as a result. |
if (avail_out < avail) |
avail = (uInt)avail_out; /* safe: < ZLIB_IO_MAX */ |
png_ptr->zstream.avail_out = avail; |
avail_out -= avail; |
/* zlib inflate call */ |
/* In fact 'avail_out' may be 0 at this point, that happens at the end |
* of the read when the final LZ end code was not passed at the end of |
* the previous chunk of input data. Tell zlib if we have reached the |
* end of the output buffer. |
*/ |
return 0; |
ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH : |
(finish ? Z_FINISH : Z_SYNC_FLUSH)); |
} while (ret == Z_OK); |
/* For safety kill the local buffer pointer now */ |
if (output == NULL) |
png_ptr->zstream.next_out = NULL; |
/* Claw back the 'size' and 'remaining_space' byte counts. */ |
avail_in += png_ptr->zstream.avail_in; |
avail_out += png_ptr->zstream.avail_out; |
/* Update the input and output sizes; the updated values are the amount |
* consumed or written, effectively the inverse of what zlib uses. |
*/ |
if (avail_out > 0) |
*output_size_ptr -= avail_out; |
if (avail_in > 0) |
*input_size_ptr -= avail_in; |
/* Ensure png_ptr->zstream.msg is set (even in the success case!) */ |
png_zstream_error(png_ptr, ret); |
return ret; |
} |
else |
{ |
/* This is a bad internal error. The recovery assigns to the zstream msg |
* pointer, which is not owned by the caller, but this is safe; it's only |
* used on errors! |
*/ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed"); |
return Z_STREAM_ERROR; |
} |
} |
/* |
* Decompress trailing data in a chunk. The assumption is that chunkdata |
* Decompress trailing data in a chunk. The assumption is that read_buffer |
* points at an allocated area holding the contents of a chunk with a |
* trailing compressed part. What we get back is an allocated area |
* holding the original prefix part and an uncompressed version of the |
* trailing part (the malloc area passed in is freed). |
*/ |
void /* PRIVATE */ |
png_decompress_chunk(png_structp png_ptr, int comp_type, |
png_size_t chunklength, |
png_size_t prefix_size, png_size_t *newlength) |
static int |
png_decompress_chunk(png_structrp png_ptr, |
png_uint_32 chunklength, png_uint_32 prefix_size, |
png_alloc_size_t *newlength /* must be initialized to the maximum! */, |
int terminate /*add a '\0' to the end of the uncompressed data*/) |
{ |
/* The caller should guarantee this */ |
if (prefix_size > chunklength) |
/* TODO: implement different limits for different types of chunk. |
* |
* The caller supplies *newlength set to the maximum length of the |
* uncompressed data, but this routine allocates space for the prefix and |
* maybe a '\0' terminator too. We have to assume that 'prefix_size' is |
* limited only by the maximum chunk size. |
*/ |
png_alloc_size_t limit = PNG_SIZE_MAX; |
# ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
if (png_ptr->user_chunk_malloc_max > 0 && |
png_ptr->user_chunk_malloc_max < limit) |
limit = png_ptr->user_chunk_malloc_max; |
# elif PNG_USER_CHUNK_MALLOC_MAX > 0 |
if (PNG_USER_CHUNK_MALLOC_MAX < limit) |
limit = PNG_USER_CHUNK_MALLOC_MAX; |
# endif |
if (limit >= prefix_size + (terminate != 0)) |
{ |
/* The recovery is to delete the chunk. */ |
png_warning(png_ptr, "invalid chunklength"); |
prefix_size = 0; /* To delete everything */ |
} |
int ret; |
else if (comp_type == PNG_COMPRESSION_TYPE_BASE) |
limit -= prefix_size + (terminate != 0); |
if (limit < *newlength) |
*newlength = limit; |
/* Now try to claim the stream. */ |
ret = png_inflate_claim(png_ptr, png_ptr->chunk_name); |
if (ret == Z_OK) |
{ |
png_size_t expanded_size = png_inflate(png_ptr, |
(png_bytep)(png_ptr->chunkdata + prefix_size), |
chunklength - prefix_size, |
0, /*output*/ |
0); /*output size*/ |
png_uint_32 lzsize = chunklength - prefix_size; |
/* Now check the limits on this chunk - if the limit fails the |
* compressed data will be removed, the prefix will remain. |
*/ |
#ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
if (png_ptr->user_chunk_malloc_max && |
(prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1)) |
#else |
# ifdef PNG_USER_CHUNK_MALLOC_MAX |
if ((PNG_USER_CHUNK_MALLOC_MAX > 0) && |
prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1) |
# endif |
#endif |
png_warning(png_ptr, "Exceeded size limit while expanding chunk"); |
ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/, |
/* input: */ png_ptr->read_buffer + prefix_size, &lzsize, |
/* output: */ NULL, newlength); |
/* If the size is zero either there was an error and a message |
* has already been output (warning) or the size really is zero |
* and we have nothing to do - the code will exit through the |
* error case below. |
if (ret == Z_STREAM_END) |
{ |
/* Use 'inflateReset' here, not 'inflateReset2' because this |
* preserves the previously decided window size (otherwise it would |
* be necessary to store the previous window size.) In practice |
* this doesn't matter anyway, because png_inflate will call inflate |
* with Z_FINISH in almost all cases, so the window will not be |
* maintained. |
*/ |
#if defined(PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED) || \ |
defined(PNG_USER_CHUNK_MALLOC_MAX) |
else if (expanded_size > 0) |
#else |
if (expanded_size > 0) |
#endif |
if (inflateReset(&png_ptr->zstream) == Z_OK) |
{ |
/* Success (maybe) - really uncompress the chunk. */ |
png_size_t new_size = 0; |
png_charp text = png_malloc_warn(png_ptr, |
prefix_size + expanded_size + 1); |
/* Because of the limit checks above we know that the new, |
* expanded, size will fit in a size_t (let alone an |
* png_alloc_size_t). Use png_malloc_base here to avoid an |
* extra OOM message. |
*/ |
png_alloc_size_t new_size = *newlength; |
png_alloc_size_t buffer_size = prefix_size + new_size + |
(terminate != 0); |
png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr, |
buffer_size)); |
if (text != NULL) |
{ |
png_memcpy(text, png_ptr->chunkdata, prefix_size); |
new_size = png_inflate(png_ptr, |
(png_bytep)(png_ptr->chunkdata + prefix_size), |
chunklength - prefix_size, |
(png_bytep)(text + prefix_size), expanded_size); |
text[prefix_size + expanded_size] = 0; /* just in case */ |
ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/, |
png_ptr->read_buffer + prefix_size, &lzsize, |
text + prefix_size, newlength); |
if (new_size == expanded_size) |
if (ret == Z_STREAM_END) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = text; |
*newlength = prefix_size + expanded_size; |
return; /* The success return! */ |
if (new_size == *newlength) |
{ |
if (terminate) |
text[prefix_size + *newlength] = 0; |
if (prefix_size > 0) |
memcpy(text, png_ptr->read_buffer, prefix_size); |
{ |
png_bytep old_ptr = png_ptr->read_buffer; |
png_ptr->read_buffer = text; |
png_ptr->read_buffer_size = buffer_size; |
text = old_ptr; /* freed below */ |
} |
} |
png_warning(png_ptr, "png_inflate logic error"); |
else |
{ |
/* The size changed on the second read, there can be no |
* guarantee that anything is correct at this point. |
* The 'msg' pointer has been set to "unexpected end of |
* LZ stream", which is fine, but return an error code |
* that the caller won't accept. |
*/ |
ret = PNG_UNEXPECTED_ZLIB_RETURN; |
} |
} |
else if (ret == Z_OK) |
ret = PNG_UNEXPECTED_ZLIB_RETURN; /* for safety */ |
/* Free the text pointer (this is the old read_buffer on |
* success) |
*/ |
png_free(png_ptr, text); |
/* This really is very benign, but it's still an error because |
* the extra space may otherwise be used as a Trojan Horse. |
*/ |
if (ret == Z_STREAM_END && |
chunklength - prefix_size != lzsize) |
png_chunk_benign_error(png_ptr, "extra compressed data"); |
} |
else |
png_warning(png_ptr, "Not enough memory to decompress chunk"); |
{ |
/* Out of memory allocating the buffer */ |
ret = Z_MEM_ERROR; |
png_zstream_error(png_ptr, Z_MEM_ERROR); |
} |
} |
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ |
else |
{ |
#ifdef PNG_STDIO_SUPPORTED |
char umsg[50]; |
/* inflateReset failed, store the error message */ |
png_zstream_error(png_ptr, ret); |
png_snprintf(umsg, sizeof umsg, |
"Unknown zTXt compression type %d", comp_type); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, "Unknown zTXt compression type"); |
#endif |
if (ret == Z_STREAM_END) |
ret = PNG_UNEXPECTED_ZLIB_RETURN; |
} |
} |
/* The recovery is to simply drop the data. */ |
else if (ret == Z_OK) |
ret = PNG_UNEXPECTED_ZLIB_RETURN; |
/* Release the claimed stream */ |
png_ptr->zowner = 0; |
} |
/* Generic error return - leave the prefix, delete the compressed |
* data, reallocate the chunkdata to remove the potentially large |
* amount of compressed data. |
else /* the claim failed */ if (ret == Z_STREAM_END) /* impossible! */ |
ret = PNG_UNEXPECTED_ZLIB_RETURN; |
return ret; |
} |
else |
{ |
/* Application/configuration limits exceeded */ |
png_zstream_error(png_ptr, Z_MEM_ERROR); |
return Z_MEM_ERROR; |
} |
} |
#endif /* PNG_READ_COMPRESSED_TEXT_SUPPORTED */ |
#ifdef PNG_READ_iCCP_SUPPORTED |
/* Perform a partial read and decompress, producing 'avail_out' bytes and |
* reading from the current chunk as required. |
*/ |
static int |
png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size, |
png_uint_32p chunk_bytes, png_bytep next_out, png_alloc_size_t *out_size, |
int finish) |
{ |
png_charp text = png_malloc_warn(png_ptr, prefix_size + 1); |
if (png_ptr->zowner == png_ptr->chunk_name) |
{ |
int ret; |
if (text != NULL) |
/* next_in and avail_in must have been initialized by the caller. */ |
png_ptr->zstream.next_out = next_out; |
png_ptr->zstream.avail_out = 0; /* set in the loop */ |
do |
{ |
if (prefix_size > 0) |
png_memcpy(text, png_ptr->chunkdata, prefix_size); |
if (png_ptr->zstream.avail_in == 0) |
{ |
if (read_size > *chunk_bytes) |
read_size = (uInt)*chunk_bytes; |
*chunk_bytes -= read_size; |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = text; |
if (read_size > 0) |
png_crc_read(png_ptr, read_buffer, read_size); |
/* This is an extra zero in the 'uncompressed' part. */ |
*(png_ptr->chunkdata + prefix_size) = 0x00; |
png_ptr->zstream.next_in = read_buffer; |
png_ptr->zstream.avail_in = read_size; |
} |
/* Ignore a malloc error here - it is safe. */ |
if (png_ptr->zstream.avail_out == 0) |
{ |
uInt avail = ZLIB_IO_MAX; |
if (avail > *out_size) |
avail = (uInt)*out_size; |
*out_size -= avail; |
png_ptr->zstream.avail_out = avail; |
} |
*newlength = prefix_size; |
/* Use Z_SYNC_FLUSH when there is no more chunk data to ensure that all |
* the available output is produced; this allows reading of truncated |
* streams. |
*/ |
ret = inflate(&png_ptr->zstream, |
*chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH)); |
} |
while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0)); |
*out_size += png_ptr->zstream.avail_out; |
png_ptr->zstream.avail_out = 0; /* Should not be required, but is safe */ |
/* Ensure the error message pointer is always set: */ |
png_zstream_error(png_ptr, ret); |
return ret; |
} |
else |
{ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed"); |
return Z_STREAM_ERROR; |
} |
} |
#endif |
/* Read and check the IDHR chunk */ |
void /* PRIVATE */ |
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte buf[13]; |
png_uint_32 width, height; |
550,11 → 802,11 |
png_debug(1, "in png_handle_IHDR"); |
if (png_ptr->mode & PNG_HAVE_IHDR) |
png_error(png_ptr, "Out of place IHDR"); |
png_chunk_error(png_ptr, "out of place"); |
/* Check the length */ |
if (length != 13) |
png_error(png_ptr, "Invalid IHDR chunk"); |
png_chunk_error(png_ptr, "invalid"); |
png_ptr->mode |= PNG_HAVE_IHDR; |
615,7 → 867,7 |
/* Read and check the palette */ |
void /* PRIVATE */ |
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_color palette[PNG_MAX_PALETTE_LENGTH]; |
int num, i; |
626,25 → 878,32 |
png_debug(1, "in png_handle_PLTE"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before PLTE"); |
png_chunk_error(png_ptr, "missing IHDR"); |
/* Moved to before the 'after IDAT' check below because otherwise duplicate |
* PLTE chunks are potentially ignored (the spec says there shall not be more |
* than one PLTE, the error is not treated as benign, so this check trumps |
* the requirement that PLTE appears before IDAT.) |
*/ |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
png_chunk_error(png_ptr, "duplicate"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid PLTE after IDAT"); |
/* This is benign because the non-benign error happened before, when an |
* IDAT was encountered in a color-mapped image with no PLTE. |
*/ |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
png_error(png_ptr, "Duplicate PLTE chunk"); |
png_ptr->mode |= PNG_HAVE_PLTE; |
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
{ |
png_warning(png_ptr, |
"Ignoring PLTE chunk in grayscale PNG"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "ignored in grayscale PNG"); |
return; |
} |
658,19 → 917,18 |
if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) |
{ |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
png_warning(png_ptr, "Invalid palette chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
png_chunk_benign_error(png_ptr, "invalid"); |
else |
{ |
png_error(png_ptr, "Invalid palette chunk"); |
png_chunk_error(png_ptr, "invalid"); |
return; |
} |
} |
/* The cast is safe because 'length' is less than 3*PNG_MAX_PALETTE_LENGTH */ |
num = (int)length / 3; |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
715,6 → 973,10 |
* we have two options: an error abort, or a warning and we |
* ignore the data in this chunk (which should be OK, since |
* it's considered ancillary for a RGB or RGBA image). |
* |
* IMPLEMENTATION NOTE: this is only here because png_crc_finish uses the |
* chunk type to determine whether to check the ancillary or the critical |
* flags. |
*/ |
if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) |
{ |
738,55 → 1000,74 |
} |
#endif |
/* TODO: png_set_PLTE has the side effect of setting png_ptr->palette to its |
* own copy of the palette. This has the side effect that when png_start_row |
* is called (this happens after any call to png_read_update_info) the |
* info_ptr palette gets changed. This is extremely unexpected and |
* confusing. |
* |
* Fix this by not sharing the palette in this way. |
*/ |
png_set_PLTE(png_ptr, info_ptr, palette, num); |
/* The three chunks, bKGD, hIST and tRNS *must* appear after PLTE and before |
* IDAT. Prior to 1.6.0 this was not checked; instead the code merely |
* checked the apparent validity of a tRNS chunk inserted before PLTE on a |
* palette PNG. 1.6.0 attempts to rigorously follow the standard and |
* therefore does a benign error if the erroneous condition is detected *and* |
* cancels the tRNS if the benign error returns. The alternative is to |
* amend the standard since it would be rather hypocritical of the standards |
* maintainers to ignore it. |
*/ |
#ifdef PNG_READ_tRNS_SUPPORTED |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
if (png_ptr->num_trans > 0 || |
(info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0)) |
{ |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
if (png_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); |
png_ptr->num_trans = (png_uint_16)num; |
} |
/* Cancel this because otherwise it would be used if the transforms |
* require it. Don't cancel the 'valid' flag because this would prevent |
* detection of duplicate chunks. |
*/ |
png_ptr->num_trans = 0; |
if (info_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); |
info_ptr->num_trans = (png_uint_16)num; |
if (info_ptr != NULL) |
info_ptr->num_trans = 0; |
png_chunk_benign_error(png_ptr, "tRNS must be after"); |
} |
} |
} |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0) |
png_chunk_benign_error(png_ptr, "hIST must be after"); |
#endif |
#ifdef PNG_READ_bKGD_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0) |
png_chunk_benign_error(png_ptr, "bKGD must be after"); |
#endif |
} |
void /* PRIVATE */ |
png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_debug(1, "in png_handle_IEND"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) |
{ |
png_error(png_ptr, "No image in file"); |
} |
png_chunk_error(png_ptr, "out of place"); |
png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); |
png_crc_finish(png_ptr, length); |
if (length != 0) |
{ |
png_warning(png_ptr, "Incorrect IEND chunk length"); |
} |
png_chunk_benign_error(png_ptr, "invalid"); |
png_crc_finish(png_ptr, length); |
PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */ |
PNG_UNUSED(info_ptr) |
} |
#ifdef PNG_READ_gAMA_SUPPORTED |
void /* PRIVATE */ |
png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_fixed_point igamma; |
png_byte buf[4]; |
794,34 → 1075,19 |
png_debug(1, "in png_handle_gAMA"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before gAMA"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid gAMA after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place gAMA chunk"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
#ifdef PNG_READ_sRGB_SUPPORTED |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
#endif |
) |
{ |
png_warning(png_ptr, "Duplicate gAMA chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 4) |
{ |
png_warning(png_ptr, "Incorrect gAMA chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
832,45 → 1098,16 |
igamma = png_get_fixed_point(NULL, buf); |
/* Check for zero gamma or an error. */ |
if (igamma <= 0) |
{ |
png_warning(png_ptr, |
"Ignoring gAMA chunk with out of range gamma"); |
return; |
png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma); |
png_colorspace_sync(png_ptr, info_ptr); |
} |
# ifdef PNG_READ_sRGB_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
# ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "gamma = (%d/100000)", (int)igamma); |
# endif |
return; |
} |
} |
# endif /* PNG_READ_sRGB_SUPPORTED */ |
# ifdef PNG_READ_GAMMA_SUPPORTED |
/* Gamma correction on read is supported. */ |
png_ptr->gamma = igamma; |
# endif |
/* And set the 'info' structure members. */ |
png_set_gAMA_fixed(png_ptr, info_ptr, igamma); |
} |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
void /* PRIVATE */ |
png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
unsigned int truelen; |
png_byte buf[4]; |
png_debug(1, "in png_handle_sBIT"); |
878,25 → 1115,19 |
buf[0] = buf[1] = buf[2] = buf[3] = 0; |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sBIT"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid sBIT after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
{ |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sBIT chunk"); |
} |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) |
{ |
png_warning(png_ptr, "Duplicate sBIT chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
904,11 → 1135,11 |
truelen = 3; |
else |
truelen = (png_size_t)png_ptr->channels; |
truelen = png_ptr->channels; |
if (length != truelen || length > 4) |
{ |
png_warning(png_ptr, "Incorrect sBIT chunk length"); |
png_chunk_benign_error(png_ptr, "invalid"); |
png_crc_finish(png_ptr, length); |
return; |
} |
941,43 → 1172,27 |
#ifdef PNG_READ_cHRM_SUPPORTED |
void /* PRIVATE */ |
png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte buf[32]; |
png_fixed_point x_white, y_white, x_red, y_red, x_green, y_green, x_blue, |
y_blue; |
png_xy xy; |
png_debug(1, "in png_handle_cHRM"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before cHRM"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid cHRM after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Missing PLTE before cHRM"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) |
# ifdef PNG_READ_sRGB_SUPPORTED |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
# endif |
) |
{ |
png_warning(png_ptr, "Duplicate cHRM chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 32) |
{ |
png_warning(png_ptr, "Incorrect cHRM chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
986,302 → 1201,381 |
if (png_crc_finish(png_ptr, 0)) |
return; |
x_white = png_get_fixed_point(NULL, buf); |
y_white = png_get_fixed_point(NULL, buf + 4); |
x_red = png_get_fixed_point(NULL, buf + 8); |
y_red = png_get_fixed_point(NULL, buf + 12); |
x_green = png_get_fixed_point(NULL, buf + 16); |
y_green = png_get_fixed_point(NULL, buf + 20); |
x_blue = png_get_fixed_point(NULL, buf + 24); |
y_blue = png_get_fixed_point(NULL, buf + 28); |
xy.whitex = png_get_fixed_point(NULL, buf); |
xy.whitey = png_get_fixed_point(NULL, buf + 4); |
xy.redx = png_get_fixed_point(NULL, buf + 8); |
xy.redy = png_get_fixed_point(NULL, buf + 12); |
xy.greenx = png_get_fixed_point(NULL, buf + 16); |
xy.greeny = png_get_fixed_point(NULL, buf + 20); |
xy.bluex = png_get_fixed_point(NULL, buf + 24); |
xy.bluey = png_get_fixed_point(NULL, buf + 28); |
if (x_white == PNG_FIXED_ERROR || |
y_white == PNG_FIXED_ERROR || |
x_red == PNG_FIXED_ERROR || |
y_red == PNG_FIXED_ERROR || |
x_green == PNG_FIXED_ERROR || |
y_green == PNG_FIXED_ERROR || |
x_blue == PNG_FIXED_ERROR || |
y_blue == PNG_FIXED_ERROR) |
if (xy.whitex == PNG_FIXED_ERROR || |
xy.whitey == PNG_FIXED_ERROR || |
xy.redx == PNG_FIXED_ERROR || |
xy.redy == PNG_FIXED_ERROR || |
xy.greenx == PNG_FIXED_ERROR || |
xy.greeny == PNG_FIXED_ERROR || |
xy.bluex == PNG_FIXED_ERROR || |
xy.bluey == PNG_FIXED_ERROR) |
{ |
png_warning(png_ptr, "Ignoring cHRM chunk with negative chromaticities"); |
png_chunk_benign_error(png_ptr, "invalid values"); |
return; |
} |
#ifdef PNG_READ_sRGB_SUPPORTED |
if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB)) |
/* If a colorspace error has already been output skip this chunk */ |
if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) |
return; |
if (png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) |
{ |
if (PNG_OUT_OF_RANGE(x_white, 31270, 1000) || |
PNG_OUT_OF_RANGE(y_white, 32900, 1000) || |
PNG_OUT_OF_RANGE(x_red, 64000L, 1000) || |
PNG_OUT_OF_RANGE(y_red, 33000, 1000) || |
PNG_OUT_OF_RANGE(x_green, 30000, 1000) || |
PNG_OUT_OF_RANGE(y_green, 60000L, 1000) || |
PNG_OUT_OF_RANGE(x_blue, 15000, 1000) || |
PNG_OUT_OF_RANGE(y_blue, 6000, 1000)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "wx=%d, wy=%d, rx=%d, ry=%d\n", |
x_white, y_white, x_red, y_red); |
fprintf(stderr, "gx=%d, gy=%d, bx=%d, by=%d\n", |
x_green, y_green, x_blue, y_blue); |
#endif /* PNG_CONSOLE_IO_SUPPORTED */ |
} |
png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID; |
png_colorspace_sync(png_ptr, info_ptr); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
png_set_cHRM_fixed(png_ptr, info_ptr, x_white, y_white, x_red, y_red, |
x_green, y_green, x_blue, y_blue); |
png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; |
(void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy, |
1/*prefer cHRM values*/); |
png_colorspace_sync(png_ptr, info_ptr); |
} |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
void /* PRIVATE */ |
png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
int intent; |
png_byte buf[1]; |
png_byte intent; |
png_debug(1, "in png_handle_sRGB"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sRGB"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid sRGB after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sRGB chunk"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
png_warning(png_ptr, "Duplicate sRGB chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 1) |
{ |
png_warning(png_ptr, "Incorrect sRGB chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
png_crc_read(png_ptr, buf, 1); |
png_crc_read(png_ptr, &intent, 1); |
if (png_crc_finish(png_ptr, 0)) |
return; |
intent = buf[0]; |
/* If a colorspace error has already been output skip this chunk */ |
if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) |
return; |
/* Check for bad intent */ |
if (intent >= PNG_sRGB_INTENT_LAST) |
/* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect |
* this. |
*/ |
if (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) |
{ |
png_warning(png_ptr, "Unknown sRGB intent"); |
png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID; |
png_colorspace_sync(png_ptr, info_ptr); |
png_chunk_benign_error(png_ptr, "too many profiles"); |
return; |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)) |
{ |
if (PNG_OUT_OF_RANGE(info_ptr->gamma, 45500L, 500)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "incorrect gamma=(%d/100000)\n", info_ptr->gamma); |
#endif |
(void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent); |
png_colorspace_sync(png_ptr, info_ptr); |
} |
} |
#endif /* PNG_READ_gAMA_SUPPORTED */ |
#ifdef PNG_READ_cHRM_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
if (PNG_OUT_OF_RANGE(info_ptr->x_white, 31270, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_white, 32900, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_red, 64000L, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_red, 33000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_green, 30000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_green, 60000L, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_blue, 15000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_blue, 6000, 1000)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
} |
#endif /* PNG_READ_cHRM_SUPPORTED */ |
png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef PNG_READ_iCCP_SUPPORTED |
void /* PRIVATE */ |
png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
/* Note: this does not properly handle profiles that are > 64K under DOS */ |
{ |
png_byte compression_type; |
png_bytep pC; |
png_charp profile; |
png_uint_32 skip = 0; |
png_uint_32 profile_size; |
png_alloc_size_t profile_length; |
png_size_t slength, prefix_length, data_length; |
png_const_charp errmsg = NULL; /* error message output, or no error */ |
int finished = 0; /* crc checked */ |
png_debug(1, "in png_handle_iCCP"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iCCP"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if (png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid iCCP after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place iCCP chunk"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) |
/* Consistent with all the above colorspace handling an obviously *invalid* |
* chunk is just ignored, so does not invalidate the color space. An |
* alternative is to set the 'invalid' flags at the start of this routine |
* and only clear them in they were not set before and all the tests pass. |
* The minimum 'deflate' stream is assumed to be just the 2 byte header and 4 |
* byte checksum. The keyword must be one character and there is a |
* terminator (0) byte and the compression method. |
*/ |
if (length < 9) |
{ |
png_warning(png_ptr, "Duplicate iCCP chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "too short"); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
/* If a colorspace error has already been output skip this chunk */ |
if (png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) |
{ |
png_warning(png_ptr, "iCCP chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
/* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect |
* this. |
*/ |
if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) == 0) |
{ |
uInt read_length, keyword_length; |
char keyword[81]; |
if (png_crc_finish(png_ptr, skip)) |
/* Find the keyword; the keyword plus separator and compression method |
* bytes can be at most 81 characters long. |
*/ |
read_length = 81; /* maximum */ |
if (read_length > length) |
read_length = (uInt)length; |
png_crc_read(png_ptr, (png_bytep)keyword, read_length); |
length -= read_length; |
keyword_length = 0; |
while (keyword_length < 80 && keyword_length < read_length && |
keyword[keyword_length] != 0) |
++keyword_length; |
/* TODO: make the keyword checking common */ |
if (keyword_length >= 1 && keyword_length <= 79) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
/* We only understand '0' compression - deflate - so if we get a |
* different value we can't safely decode the chunk. |
*/ |
if (keyword_length+1 < read_length && |
keyword[keyword_length+1] == PNG_COMPRESSION_TYPE_BASE) |
{ |
read_length -= keyword_length+2; |
png_ptr->chunkdata[slength] = 0x00; |
if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK) |
{ |
Byte profile_header[132]; |
Byte local_buffer[PNG_INFLATE_BUF_SIZE]; |
png_alloc_size_t size = (sizeof profile_header); |
for (profile = png_ptr->chunkdata; *profile; profile++) |
/* Empty loop to find end of name */ ; |
png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2); |
png_ptr->zstream.avail_in = read_length; |
(void)png_inflate_read(png_ptr, local_buffer, |
(sizeof local_buffer), &length, profile_header, &size, |
0/*finish: don't, because the output is too small*/); |
++profile; |
if (size == 0) |
{ |
/* We have the ICC profile header; do the basic header checks. |
*/ |
const png_uint_32 profile_length = |
png_get_uint_32(profile_header); |
/* There should be at least one zero (the compression type byte) |
* following the separator, and we should be on it |
if (png_icc_check_length(png_ptr, &png_ptr->colorspace, |
keyword, profile_length)) |
{ |
/* The length is apparently ok, so we can check the 132 |
* byte header. |
*/ |
if (profile >= png_ptr->chunkdata + slength - 1) |
if (png_icc_check_header(png_ptr, &png_ptr->colorspace, |
keyword, profile_length, profile_header, |
png_ptr->color_type)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "Malformed iCCP chunk"); |
return; |
} |
/* Now read the tag table; a variable size buffer is |
* needed at this point, allocate one for the whole |
* profile. The header check has already validated |
* that none of these stuff will overflow. |
*/ |
const png_uint_32 tag_count = png_get_uint_32( |
profile_header+128); |
png_bytep profile = png_read_buffer(png_ptr, |
profile_length, 2/*silent*/); |
/* Compression_type should always be zero */ |
compression_type = *profile++; |
if (profile != NULL) |
{ |
memcpy(profile, profile_header, |
(sizeof profile_header)); |
if (compression_type) |
size = 12 * tag_count; |
(void)png_inflate_read(png_ptr, local_buffer, |
(sizeof local_buffer), &length, |
profile + (sizeof profile_header), &size, 0); |
/* Still expect a a buffer error because we expect |
* there to be some tag data! |
*/ |
if (size == 0) |
{ |
png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); |
compression_type = 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 |
wrote nonzero) */ |
} |
if (png_icc_check_tag_table(png_ptr, |
&png_ptr->colorspace, keyword, profile_length, |
profile)) |
{ |
/* The profile has been validated for basic |
* security issues, so read the whole thing in. |
*/ |
size = profile_length - (sizeof profile_header) |
- 12 * tag_count; |
prefix_length = profile - png_ptr->chunkdata; |
png_decompress_chunk(png_ptr, compression_type, |
slength, prefix_length, &data_length); |
(void)png_inflate_read(png_ptr, local_buffer, |
(sizeof local_buffer), &length, |
profile + (sizeof profile_header) + |
12 * tag_count, &size, 1/*finish*/); |
profile_length = data_length - prefix_length; |
if (length > 0 && !(png_ptr->flags & |
PNG_FLAG_BENIGN_ERRORS_WARN)) |
errmsg = "extra compressed data"; |
if (prefix_length > data_length || profile_length < 4) |
/* But otherwise allow extra data: */ |
else if (size == 0) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "Profile size field missing from iCCP chunk"); |
return; |
if (length > 0) |
{ |
/* This can be handled completely, so |
* keep going. |
*/ |
png_chunk_warning(png_ptr, |
"extra compressed data"); |
} |
/* Check the profile_size recorded in the first 32 bits of the ICC profile */ |
pC = (png_bytep)(png_ptr->chunkdata + prefix_length); |
profile_size = ((*(pC )) << 24) | |
((*(pC + 1)) << 16) | |
((*(pC + 2)) << 8) | |
((*(pC + 3)) ); |
png_crc_finish(png_ptr, length); |
finished = 1; |
/* NOTE: the following guarantees that 'profile_length' fits into 32 bits, |
* because profile_size is a 32 bit value. |
*/ |
if (profile_size < profile_length) |
profile_length = profile_size; |
# ifdef PNG_sRGB_SUPPORTED |
/* Check for a match against sRGB */ |
png_icc_set_sRGB(png_ptr, |
&png_ptr->colorspace, profile, |
png_ptr->zstream.adler); |
# endif |
/* And the following guarantees that profile_size == profile_length. */ |
if (profile_size > profile_length) |
/* Steal the profile for info_ptr. */ |
if (info_ptr != NULL) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
#ifdef PNG_STDIO_SUPPORTED |
png_free_data(png_ptr, info_ptr, |
PNG_FREE_ICCP, 0); |
info_ptr->iccp_name = png_voidcast(char*, |
png_malloc_base(png_ptr, |
keyword_length+1)); |
if (info_ptr->iccp_name != NULL) |
{ |
char umsg[80]; |
memcpy(info_ptr->iccp_name, keyword, |
keyword_length+1); |
info_ptr->iccp_proflen = |
profile_length; |
info_ptr->iccp_profile = profile; |
png_ptr->read_buffer = NULL; /*steal*/ |
info_ptr->free_me |= PNG_FREE_ICCP; |
info_ptr->valid |= PNG_INFO_iCCP; |
} |
png_snprintf2(umsg, 80, |
"Ignoring iCCP chunk with declared size = %u " |
"and actual length = %u", |
(unsigned int) profile_size, |
(unsigned int) profile_length); |
png_warning(png_ptr, umsg); |
else |
{ |
png_ptr->colorspace.flags |= |
PNG_COLORSPACE_INVALID; |
errmsg = "out of memory"; |
} |
#else |
png_warning(png_ptr, |
"Ignoring iCCP chunk with uncompressed size mismatch"); |
#endif |
} |
/* else the profile remains in the read |
* buffer which gets reused for subsequent |
* chunks. |
*/ |
if (info_ptr != NULL) |
png_colorspace_sync(png_ptr, info_ptr); |
if (errmsg == NULL) |
{ |
png_ptr->zowner = 0; |
return; |
} |
} |
png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata, |
compression_type, (png_bytep)png_ptr->chunkdata + prefix_length, |
profile_size); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
else if (size > 0) |
errmsg = "truncated"; |
else |
errmsg = png_ptr->zstream.msg; |
} |
/* else png_icc_check_tag_table output an error */ |
} |
else /* profile truncated */ |
errmsg = png_ptr->zstream.msg; |
} |
else |
errmsg = "out of memory"; |
} |
/* else png_icc_check_header output an error */ |
} |
/* else png_icc_check_length output an error */ |
} |
else /* profile truncated */ |
errmsg = png_ptr->zstream.msg; |
/* Release the stream */ |
png_ptr->zowner = 0; |
} |
else /* png_inflate_claim failed */ |
errmsg = png_ptr->zstream.msg; |
} |
else |
errmsg = "bad compression method"; /* or missing */ |
} |
else |
errmsg = "bad keyword"; |
} |
else |
errmsg = "too many profiles"; |
/* Failure: the reason is in 'errmsg' */ |
if (!finished) |
png_crc_finish(png_ptr, length); |
png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID; |
png_colorspace_sync(png_ptr, info_ptr); |
if (errmsg != NULL) /* else already output */ |
png_chunk_benign_error(png_ptr, errmsg); |
} |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#ifdef PNG_READ_sPLT_SUPPORTED |
void /* PRIVATE */ |
png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
{ |
png_bytep entry_start; |
png_bytep entry_start, buffer; |
png_sPLT_t new_palette; |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
png_sPLT_entryp pp; |
#endif |
png_uint_32 data_length; |
int entry_size, i; |
png_uint_32 skip = 0; |
png_size_t slength; |
png_uint_32 dl; |
png_size_t max_dl; |
1288,7 → 1582,6 |
png_debug(1, "in png_handle_sPLT"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
1307,54 → 1600,52 |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sPLT"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sPLT after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
if (length > 65535U) |
{ |
png_warning(png_ptr, "sPLT chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "too large to fit in memory"); |
return; |
} |
#endif |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); |
if (buffer == NULL) |
{ |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
/* WARNING: this may break if size_t is less than 32 bits; it is assumed |
* that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a |
* potential breakage point if the types in pngconf.h aren't exactly right. |
*/ |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
png_crc_read(png_ptr, buffer, length); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
buffer[length] = 0; |
for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; |
entry_start++) |
for (entry_start = buffer; *entry_start; entry_start++) |
/* Empty loop to find end of name */ ; |
++entry_start; |
/* A sample depth should follow the separator, and we should be on it */ |
if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2) |
if (entry_start > buffer + length - 2) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "malformed sPLT chunk"); |
return; |
} |
1362,23 → 1653,19 |
new_palette.depth = *entry_start++; |
entry_size = (new_palette.depth == 8 ? 6 : 10); |
/* This must fit in a png_uint_32 because it is derived from the original |
* chunk data length (and use 'length', not 'slength' here for clarity - |
* they are guaranteed to be the same, see the tests above.) |
* chunk data length. |
*/ |
data_length = length - (png_uint_32)(entry_start - |
(png_bytep)png_ptr->chunkdata); |
data_length = length - (png_uint_32)(entry_start - buffer); |
/* Integrity-check the data length */ |
if (data_length % entry_size) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "sPLT chunk has bad length"); |
return; |
} |
dl = (png_int_32)(data_length / entry_size); |
max_dl = PNG_SIZE_MAX / png_sizeof(png_sPLT_entry); |
max_dl = PNG_SIZE_MAX / (sizeof (png_sPLT_entry)); |
if (dl > max_dl) |
{ |
1389,7 → 1676,7 |
new_palette.nentries = (png_int_32)(data_length / entry_size); |
new_palette.entries = (png_sPLT_entryp)png_malloc_warn( |
png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); |
png_ptr, new_palette.nentries * (sizeof (png_sPLT_entry))); |
if (new_palette.entries == NULL) |
{ |
1442,17 → 1729,15 |
pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; |
} |
pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].frequency = png_get_uint_16(entry_start); entry_start += 2; |
} |
#endif |
/* Discard all chunk data except the name and stash that */ |
new_palette.name = png_ptr->chunkdata; |
new_palette.name = (png_charp)buffer; |
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, new_palette.entries); |
} |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
1459,7 → 1744,7 |
#ifdef PNG_READ_tRNS_SUPPORTED |
void /* PRIVATE */ |
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_tRNS(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; |
1466,19 → 1751,19 |
png_debug(1, "in png_handle_tRNS"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tRNS"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid tRNS after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
png_warning(png_ptr, "Duplicate tRNS chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
1488,8 → 1773,8 |
if (length != 2) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1504,12 → 1789,12 |
if (length != 6) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
png_crc_read(png_ptr, buf, (png_size_t)length); |
png_crc_read(png_ptr, buf, length); |
png_ptr->num_trans = 1; |
png_ptr->trans_color.red = png_get_uint_16(buf); |
png_ptr->trans_color.green = png_get_uint_16(buf + 2); |
1520,33 → 1805,28 |
{ |
if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
/* Should be an error, but we can cope with it. */ |
png_warning(png_ptr, "Missing PLTE before tRNS"); |
} |
if (length > (png_uint_32)png_ptr->num_palette || |
length > PNG_MAX_PALETTE_LENGTH) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
/* TODO: is this actually an error in the ISO spec? */ |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
if (length == 0) |
if (length > png_ptr->num_palette || length > PNG_MAX_PALETTE_LENGTH || |
length == 0) |
{ |
png_warning(png_ptr, "Zero length tRNS chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
png_crc_read(png_ptr, readbuf, (png_size_t)length); |
png_crc_read(png_ptr, readbuf, length); |
png_ptr->num_trans = (png_uint_16)length; |
} |
else |
{ |
png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid with alpha channel"); |
return; |
} |
1556,6 → 1836,10 |
return; |
} |
/* TODO: this is a horrible side effect in the palette case because the |
* png_struct ends up with a pointer to the tRNS buffer owned by the |
* png_info. Fix this. |
*/ |
png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, |
&(png_ptr->trans_color)); |
} |
1563,35 → 1847,30 |
#ifdef PNG_READ_bKGD_SUPPORTED |
void /* PRIVATE */ |
png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_bKGD(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
unsigned int truelen; |
png_byte buf[6]; |
png_color_16 background; |
png_debug(1, "in png_handle_bKGD"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before bKGD"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if ((png_ptr->mode & PNG_HAVE_IDAT) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE))) |
{ |
png_warning(png_ptr, "Invalid bKGD after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before bKGD"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) |
{ |
png_warning(png_ptr, "Duplicate bKGD chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
1606,8 → 1885,8 |
if (length != truelen) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1623,49 → 1902,52 |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_ptr->background.index = buf[0]; |
background.index = buf[0]; |
if (info_ptr && info_ptr->num_palette) |
{ |
if (buf[0] >= info_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk index value"); |
png_chunk_benign_error(png_ptr, "invalid index"); |
return; |
} |
png_ptr->background.red = |
(png_uint_16)png_ptr->palette[buf[0]].red; |
background.red = (png_uint_16)png_ptr->palette[buf[0]].red; |
background.green = (png_uint_16)png_ptr->palette[buf[0]].green; |
background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue; |
} |
png_ptr->background.green = |
(png_uint_16)png_ptr->palette[buf[0]].green; |
else |
background.red = background.green = background.blue = 0; |
png_ptr->background.blue = |
(png_uint_16)png_ptr->palette[buf[0]].blue; |
background.gray = 0; |
} |
} |
else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ |
{ |
png_ptr->background.red = |
png_ptr->background.green = |
png_ptr->background.blue = |
png_ptr->background.gray = png_get_uint_16(buf); |
background.index = 0; |
background.red = |
background.green = |
background.blue = |
background.gray = png_get_uint_16(buf); |
} |
else |
{ |
png_ptr->background.red = png_get_uint_16(buf); |
png_ptr->background.green = png_get_uint_16(buf + 2); |
png_ptr->background.blue = png_get_uint_16(buf + 4); |
background.index = 0; |
background.red = png_get_uint_16(buf); |
background.green = png_get_uint_16(buf + 2); |
background.blue = png_get_uint_16(buf + 4); |
background.gray = 0; |
} |
png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); |
png_set_bKGD(png_ptr, info_ptr, &background); |
} |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
void /* PRIVATE */ |
png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_hIST(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
unsigned int num, i; |
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; |
1673,36 → 1955,28 |
png_debug(1, "in png_handle_hIST"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before hIST"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
else if ((png_ptr->mode & PNG_HAVE_IDAT) || !(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Invalid hIST after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before hIST"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) |
{ |
png_warning(png_ptr, "Duplicate hIST chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
num = length / 2 ; |
if (num != (unsigned int)png_ptr->num_palette || num > |
(unsigned int)PNG_MAX_PALETTE_LENGTH) |
if (num != png_ptr->num_palette || num > PNG_MAX_PALETTE_LENGTH) |
{ |
png_warning(png_ptr, "Incorrect hIST chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1723,7 → 1997,7 |
#ifdef PNG_READ_pHYs_SUPPORTED |
void /* PRIVATE */ |
png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_pHYs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_uint_32 res_x, res_y; |
1732,26 → 2006,26 |
png_debug(1, "in png_handle_pHYs"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pHYs"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pHYs after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_warning(png_ptr, "Duplicate pHYs chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect pHYs chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1769,7 → 2043,7 |
#ifdef PNG_READ_oFFs_SUPPORTED |
void /* PRIVATE */ |
png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_oFFs(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_int_32 offset_x, offset_y; |
1778,26 → 2052,26 |
png_debug(1, "in png_handle_oFFs"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before oFFs"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid oFFs after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_warning(png_ptr, "Duplicate oFFs chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect oFFs chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1816,62 → 2090,57 |
#ifdef PNG_READ_pCAL_SUPPORTED |
/* Read the pCAL chunk (described in the PNG Extensions document) */ |
void /* PRIVATE */ |
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_int_32 X0, X1; |
png_byte type, nparams; |
png_charp buf, units, endptr; |
png_bytep buffer, buf, units, endptr; |
png_charpp params; |
png_size_t slength; |
int i; |
png_debug(1, "in png_handle_pCAL"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pCAL"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) |
{ |
png_warning(png_ptr, "Duplicate pCAL chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)", |
length + 1); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->chunkdata == NULL) |
buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "No memory for pCAL purpose"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
png_crc_read(png_ptr, buffer, length); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ |
buffer[length] = 0; /* Null terminate the last string */ |
png_debug(3, "Finding end of pCAL purpose string"); |
for (buf = png_ptr->chunkdata; *buf; buf++) |
for (buf = buffer; *buf; buf++) |
/* Empty loop */ ; |
endptr = png_ptr->chunkdata + slength; |
endptr = buffer + length; |
/* We need to have at least 12 bytes after the purpose string |
* in order to get the parameter information. |
1878,9 → 2147,7 |
*/ |
if (endptr <= buf + 12) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
1900,15 → 2167,13 |
(type == PNG_EQUATION_ARBITRARY && nparams != 3) || |
(type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) |
{ |
png_warning(png_ptr, "Invalid pCAL parameters for equation type"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_chunk_benign_error(png_ptr, "invalid parameter count"); |
return; |
} |
else if (type >= PNG_EQUATION_LAST) |
{ |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
png_chunk_benign_error(png_ptr, "unrecognized equation type"); |
} |
for (buf = units; *buf; buf++) |
1916,43 → 2181,37 |
png_debug(3, "Allocating pCAL parameters array"); |
params = (png_charpp)png_malloc_warn(png_ptr, |
(png_size_t)(nparams * png_sizeof(png_charp))); |
params = png_voidcast(png_charpp, png_malloc_warn(png_ptr, |
nparams * (sizeof (png_charp)))); |
if (params == NULL) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "No memory for pCAL params"); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
/* Get pointers to the start of each parameter string. */ |
for (i = 0; i < (int)nparams; i++) |
for (i = 0; i < nparams; i++) |
{ |
buf++; /* Skip the null string terminator from previous parameter. */ |
png_debug1(3, "Reading pCAL parameter %d", i); |
for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++) |
for (params[i] = (png_charp)buf; buf <= endptr && *buf != 0; buf++) |
/* Empty loop to move past each parameter string */ ; |
/* Make sure we haven't run out of data yet */ |
if (buf > endptr) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, params); |
png_chunk_benign_error(png_ptr, "invalid data"); |
return; |
} |
} |
png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams, |
units, params); |
png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams, |
(png_charp)units, params); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, params); |
} |
#endif |
1960,59 → 2219,61 |
#ifdef PNG_READ_sCAL_SUPPORTED |
/* Read the sCAL chunk */ |
void /* PRIVATE */ |
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_size_t slength, i; |
png_bytep buffer; |
png_size_t i; |
int state; |
png_debug(1, "in png_handle_sCAL"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sCAL"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of place"); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) |
{ |
png_warning(png_ptr, "Duplicate sCAL chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
/* Need unit type, width, \0, height: minimum 4 bytes */ |
else if (length < 4) |
{ |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)", |
length + 1); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); |
if (png_ptr->chunkdata == NULL) |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk"); |
png_chunk_benign_error(png_ptr, "out of memory"); |
png_crc_finish(png_ptr, length); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ |
png_crc_read(png_ptr, buffer, length); |
buffer[length] = 0; /* Null terminate the last string */ |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
/* Validate the unit. */ |
if (png_ptr->chunkdata[0] != 1 && png_ptr->chunkdata[0] != 2) |
if (buffer[0] != 1 && buffer[0] != 2) |
{ |
png_warning(png_ptr, "Invalid sCAL ignored: invalid unit"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_chunk_benign_error(png_ptr, "invalid unit"); |
return; |
} |
2019,38 → 2280,39 |
/* Validate the ASCII numbers, need two ASCII numbers separated by |
* a '\0' and they need to fit exactly in the chunk data. |
*/ |
i = 0; |
i = 1; |
state = 0; |
if (png_ptr->chunkdata[1] == 45 /* negative width */ || |
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || |
i >= slength || png_ptr->chunkdata[i++] != 0) |
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format"); |
if (!png_check_fp_number((png_const_charp)buffer, length, &state, &i) || |
i >= length || buffer[i++] != 0) |
png_chunk_benign_error(png_ptr, "bad width format"); |
else if (!PNG_FP_IS_POSITIVE(state)) |
png_chunk_benign_error(png_ptr, "non-positive width"); |
else |
{ |
png_size_t heighti = i; |
if (png_ptr->chunkdata[i] == 45 /* negative height */ || |
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || |
i != slength) |
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format"); |
state = 0; |
if (!png_check_fp_number((png_const_charp)buffer, length, &state, &i) || |
i != length) |
png_chunk_benign_error(png_ptr, "bad height format"); |
else if (!PNG_FP_IS_POSITIVE(state)) |
png_chunk_benign_error(png_ptr, "non-positive height"); |
else |
/* This is the (only) success case. */ |
png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], |
png_ptr->chunkdata+1, png_ptr->chunkdata+heighti); |
png_set_sCAL_s(png_ptr, info_ptr, buffer[0], |
(png_charp)buffer+1, (png_charp)buffer+heighti); |
} |
/* Clean up - just free the temporarily allocated buffer. */ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
} |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
void /* PRIVATE */ |
png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_tIME(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_byte buf[7]; |
png_time mod_time; |
2058,12 → 2320,12 |
png_debug(1, "in png_handle_tIME"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Out of place tIME chunk"); |
png_chunk_error(png_ptr, "missing IHDR"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) |
{ |
png_warning(png_ptr, "Duplicate tIME chunk"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "duplicate"); |
return; |
} |
2072,8 → 2334,8 |
if (length != 7) |
{ |
png_warning(png_ptr, "Incorrect tIME chunk length"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "invalid"); |
return; |
} |
2096,14 → 2358,13 |
#ifdef PNG_READ_tEXt_SUPPORTED |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_tEXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_text text_info; |
png_bytep buffer; |
png_charp key; |
png_charp text; |
png_uint_32 skip = 0; |
png_size_t slength; |
int ret; |
png_debug(1, "in png_handle_tEXt"); |
2118,8 → 2379,8 |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for tEXt"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "no space in chunk cache"); |
return; |
} |
} |
2126,76 → 2387,51 |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tEXt"); |
png_chunk_error(png_ptr, "missing IHDR"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
if (length > 65535U) |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "too large to fit in memory"); |
return; |
} |
#endif |
png_free(png_ptr, png_ptr->chunkdata); |
buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->chunkdata == NULL) |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "No memory to process text chunk"); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
png_crc_read(png_ptr, buffer, length); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
key = png_ptr->chunkdata; |
key = (png_charp)buffer; |
key[length] = 0; |
key[slength] = 0x00; |
for (text = key; *text; text++) |
/* Empty loop to find end of key */ ; |
if (text != key + slength) |
if (text != key + length) |
text++; |
text_ptr = (png_textp)png_malloc_warn(png_ptr, |
png_sizeof(png_text)); |
text_info.compression = PNG_TEXT_COMPRESSION_NONE; |
text_info.key = key; |
text_info.lang = NULL; |
text_info.lang_key = NULL; |
text_info.itxt_length = 0; |
text_info.text = text; |
text_info.text_length = strlen(text); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process text chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
text_ptr->text = text; |
text_ptr->text_length = png_strlen(text); |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, text_ptr); |
if (ret) |
if (png_set_text_2(png_ptr, info_ptr, &text_info, 1)) |
png_warning(png_ptr, "Insufficient memory to process text chunk"); |
} |
#endif |
2203,13 → 2439,11 |
#ifdef PNG_READ_zTXt_SUPPORTED |
/* Note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_zTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp text; |
int comp_type; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_const_charp errmsg = NULL; |
png_bytep buffer; |
png_uint_32 keyword_length; |
png_debug(1, "in png_handle_zTXt"); |
2224,8 → 2458,8 |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for zTXt"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "no space in chunk cache"); |
return; |
} |
} |
2232,101 → 2466,82 |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before zTXt"); |
png_chunk_error(png_ptr, "missing IHDR"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
* there is no hard and fast rule to tell us where to stop. |
*/ |
if (length > (png_uint_32)65535L) |
buffer = png_read_buffer(png_ptr, length, 2/*silent*/); |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "zTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
#endif |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
png_crc_read(png_ptr, buffer, length); |
if (png_ptr->chunkdata == NULL) |
{ |
png_warning(png_ptr, "Out of memory processing zTXt chunk"); |
if (png_crc_finish(png_ptr, 0)) |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
/* TODO: also check that the keyword contents match the spec! */ |
for (keyword_length = 0; |
keyword_length < length && buffer[keyword_length] != 0; |
++keyword_length) |
/* Empty loop to find end of name */ ; |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
if (keyword_length > 79 || keyword_length < 1) |
errmsg = "bad keyword"; |
png_ptr->chunkdata[slength] = 0x00; |
/* zTXt must have some LZ data after the keyword, although it may expand to |
* zero bytes; we need a '\0' at the end of the keyword, the compression type |
* then the LZ data: |
*/ |
else if (keyword_length + 3 > length) |
errmsg = "truncated"; |
for (text = png_ptr->chunkdata; *text; text++) |
/* Empty loop */ ; |
else if (buffer[keyword_length+1] != PNG_COMPRESSION_TYPE_BASE) |
errmsg = "unknown compression type"; |
/* zTXt must have some text after the chunkdataword */ |
if (text >= png_ptr->chunkdata + slength - 2) |
{ |
png_warning(png_ptr, "Truncated zTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
else |
{ |
comp_type = *(++text); |
png_alloc_size_t uncompressed_length = PNG_SIZE_MAX; |
if (comp_type != PNG_TEXT_COMPRESSION_zTXt) |
/* TODO: at present png_decompress_chunk imposes a single application |
* level memory limit, this should be split to different values for iCCP |
* and text chunks. |
*/ |
if (png_decompress_chunk(png_ptr, length, keyword_length+2, |
&uncompressed_length, 1/*terminate*/) == Z_STREAM_END) |
{ |
png_warning(png_ptr, "Unknown compression type in zTXt chunk"); |
comp_type = PNG_TEXT_COMPRESSION_zTXt; |
} |
png_text text; |
text++; /* Skip the compression_method byte */ |
} |
/* It worked; png_ptr->read_buffer now looks like a tEXt chunk except |
* for the extra compression type byte and the fact that it isn't |
* necessarily '\0' terminated. |
*/ |
buffer = png_ptr->read_buffer; |
buffer[uncompressed_length+(keyword_length+2)] = 0; |
prefix_len = text - png_ptr->chunkdata; |
text.compression = PNG_TEXT_COMPRESSION_zTXt; |
text.key = (png_charp)buffer; |
text.text = (png_charp)(buffer + keyword_length+2); |
text.text_length = uncompressed_length; |
text.itxt_length = 0; |
text.lang = NULL; |
text.lang_key = NULL; |
png_decompress_chunk(png_ptr, comp_type, |
(png_size_t)length, prefix_len, &data_len); |
if (png_set_text_2(png_ptr, info_ptr, &text, 1)) |
errmsg = "insufficient memory"; |
} |
text_ptr = (png_textp)png_malloc_warn(png_ptr, |
png_sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process zTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
else |
errmsg = png_ptr->zstream.msg; |
} |
text_ptr->compression = comp_type; |
text_ptr->key = png_ptr->chunkdata; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
text_ptr->text = png_ptr->chunkdata + prefix_len; |
text_ptr->text_length = data_len; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
if (ret) |
png_error(png_ptr, "Insufficient memory to store zTXt chunk"); |
if (errmsg != NULL) |
png_chunk_benign_error(png_ptr, errmsg); |
} |
#endif |
2333,14 → 2548,11 |
#ifdef PNG_READ_iTXt_SUPPORTED |
/* Note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp key, lang, text, lang_key; |
int comp_flag; |
int comp_type = 0; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_const_charp errmsg = NULL; |
png_bytep buffer; |
png_uint_32 prefix_length; |
png_debug(1, "in png_handle_iTXt"); |
2355,8 → 2567,8 |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for iTXt"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "no space in chunk cache"); |
return; |
} |
} |
2363,266 → 2575,384 |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iTXt"); |
png_chunk_error(png_ptr, "missing IHDR"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
* there is no hard and fast rule to tell us where to stop. |
*/ |
if (length > (png_uint_32)65535L) |
buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/); |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "iTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
png_chunk_benign_error(png_ptr, "out of memory"); |
return; |
} |
#endif |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
png_crc_read(png_ptr, buffer, length); |
if (png_ptr->chunkdata == NULL) |
{ |
png_warning(png_ptr, "No memory to process iTXt chunk"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
for (lang = png_ptr->chunkdata; *lang; lang++) |
/* First the keyword. */ |
for (prefix_length=0; |
prefix_length < length && buffer[prefix_length] != 0; |
++prefix_length) |
/* Empty loop */ ; |
lang++; /* Skip NUL separator */ |
/* Perform a basic check on the keyword length here. */ |
if (prefix_length > 79 || prefix_length < 1) |
errmsg = "bad keyword"; |
/* iTXt must have a language tag (possibly empty), two compression bytes, |
* translated keyword (possibly empty), and possibly some text after the |
* keyword |
/* Expect keyword, compression flag, compression type, language, translated |
* keyword (both may be empty but are 0 terminated) then the text, which may |
* be empty. |
*/ |
else if (prefix_length + 5 > length) |
errmsg = "truncated"; |
if (lang >= png_ptr->chunkdata + slength - 3) |
else if (buffer[prefix_length+1] == 0 || |
(buffer[prefix_length+1] == 1 && |
buffer[prefix_length+2] == PNG_COMPRESSION_TYPE_BASE)) |
{ |
png_warning(png_ptr, "Truncated iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
int compressed = buffer[prefix_length+1] != 0; |
png_uint_32 language_offset, translated_keyword_offset; |
png_alloc_size_t uncompressed_length = 0; |
else |
{ |
comp_flag = *lang++; |
comp_type = *lang++; |
} |
/* Now the language tag */ |
prefix_length += 3; |
language_offset = prefix_length; |
for (lang_key = lang; *lang_key; lang_key++) |
for (; prefix_length < length && buffer[prefix_length] != 0; |
++prefix_length) |
/* Empty loop */ ; |
lang_key++; /* Skip NUL separator */ |
/* WARNING: the length may be invalid here, this is checked below. */ |
translated_keyword_offset = ++prefix_length; |
if (lang_key >= png_ptr->chunkdata + slength) |
{ |
png_warning(png_ptr, "Truncated iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
for (text = lang_key; *text; text++) |
for (; prefix_length < length && buffer[prefix_length] != 0; |
++prefix_length) |
/* Empty loop */ ; |
text++; /* Skip NUL separator */ |
/* prefix_length should now be at the trailing '\0' of the translated |
* keyword, but it may already be over the end. None of this arithmetic |
* can overflow because chunks are at most 2^31 bytes long, but on 16-bit |
* systems the available allocaton may overflow. |
*/ |
++prefix_length; |
if (text >= png_ptr->chunkdata + slength) |
if (!compressed && prefix_length <= length) |
uncompressed_length = length - prefix_length; |
else if (compressed && prefix_length < length) |
{ |
png_warning(png_ptr, "Malformed iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
uncompressed_length = PNG_SIZE_MAX; |
/* TODO: at present png_decompress_chunk imposes a single application |
* level memory limit, this should be split to different values for |
* iCCP and text chunks. |
*/ |
if (png_decompress_chunk(png_ptr, length, prefix_length, |
&uncompressed_length, 1/*terminate*/) == Z_STREAM_END) |
buffer = png_ptr->read_buffer; |
else |
errmsg = png_ptr->zstream.msg; |
} |
prefix_len = text - png_ptr->chunkdata; |
else |
errmsg = "truncated"; |
key=png_ptr->chunkdata; |
if (errmsg == NULL) |
{ |
png_text text; |
if (comp_flag) |
png_decompress_chunk(png_ptr, comp_type, |
(size_t)length, prefix_len, &data_len); |
buffer[uncompressed_length+prefix_length] = 0; |
if (compressed) |
text.compression = PNG_ITXT_COMPRESSION_NONE; |
else |
data_len = png_strlen(png_ptr->chunkdata + prefix_len); |
text.compression = PNG_ITXT_COMPRESSION_zTXt; |
text_ptr = (png_textp)png_malloc_warn(png_ptr, |
png_sizeof(png_text)); |
text.key = (png_charp)buffer; |
text.lang = (png_charp)buffer + language_offset; |
text.lang_key = (png_charp)buffer + translated_keyword_offset; |
text.text = (png_charp)buffer + prefix_length; |
text.text_length = 0; |
text.itxt_length = uncompressed_length; |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
if (png_set_text_2(png_ptr, info_ptr, &text, 1)) |
errmsg = "insufficient memory"; |
} |
} |
text_ptr->compression = (int)comp_flag + 1; |
text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key); |
text_ptr->lang = png_ptr->chunkdata + (lang - key); |
text_ptr->itxt_length = data_len; |
text_ptr->text_length = 0; |
text_ptr->key = png_ptr->chunkdata; |
text_ptr->text = png_ptr->chunkdata + prefix_len; |
else |
errmsg = "bad compression info"; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
if (errmsg != NULL) |
png_chunk_benign_error(png_ptr, errmsg); |
} |
#endif |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
/* Utility function for png_handle_unknown; set up png_ptr::unknown_chunk */ |
static int |
png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length) |
{ |
png_alloc_size_t limit = PNG_SIZE_MAX; |
if (ret) |
png_error(png_ptr, "Insufficient memory to store iTXt chunk"); |
if (png_ptr->unknown_chunk.data != NULL) |
{ |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
# ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
if (png_ptr->user_chunk_malloc_max > 0 && |
png_ptr->user_chunk_malloc_max < limit) |
limit = png_ptr->user_chunk_malloc_max; |
# elif PNG_USER_CHUNK_MALLOC_MAX > 0 |
if (PNG_USER_CHUNK_MALLOC_MAX < limit) |
limit = PNG_USER_CHUNK_MALLOC_MAX; |
#endif |
/* This function is called when we haven't found a handler for a |
* chunk. If there isn't a problem with the chunk itself (ie bad |
* chunk name, CRC, or a critical chunk), the chunk is silently ignored |
* -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which |
* case it will be saved away to be written out later. |
*/ |
void /* PRIVATE */ |
png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
if (length <= limit) |
{ |
png_uint_32 skip = 0; |
PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name); |
/* The following is safe because of the PNG_SIZE_MAX init above */ |
png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/; |
/* 'mode' is a flag array, only the bottom four bits matter here */ |
png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/; |
png_debug(1, "in png_handle_unknown"); |
if (length == 0) |
png_ptr->unknown_chunk.data = NULL; |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
else |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
/* Do a 'warn' here - it is handled below. */ |
png_ptr->unknown_chunk.data = png_voidcast(png_bytep, |
png_malloc_warn(png_ptr, length)); |
} |
} |
if (png_ptr->unknown_chunk.data == NULL && length > 0) |
{ |
/* This is benign because we clean up correctly */ |
png_crc_finish(png_ptr, length); |
return; |
png_chunk_benign_error(png_ptr, "unknown chunk exceeds memory limits"); |
return 0; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
else |
{ |
png_warning(png_ptr, "No space in chunk cache for unknown chunk"); |
png_crc_finish(png_ptr, length); |
return; |
if (length > 0) |
png_crc_read(png_ptr, png_ptr->unknown_chunk.data, length); |
png_crc_finish(png_ptr, 0); |
return 1; |
} |
} |
#endif |
#endif /* PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */ |
if (png_ptr->mode & PNG_HAVE_IDAT) |
/* Handle an unknown, or known but disabled, chunk */ |
void /* PRIVATE */ |
png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr, |
png_uint_32 length, int keep) |
{ |
PNG_IDAT; |
int handled = 0; /* the chunk was handled */ |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */ |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
png_debug(1, "in png_handle_unknown"); |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
/* NOTE: this code is based on the code in libpng-1.4.12 except for fixing |
* the bug which meant that setting a non-default behavior for a specific |
* chunk would be ignored (the default was always used unless a user |
* callback was installed). |
* |
* 'keep' is the value from the png_chunk_unknown_handling, the setting for |
* this specific chunk_name, if PNG_HANDLE_AS_UNKNOWN_SUPPORTED, if not it |
* will always be PNG_HANDLE_CHUNK_AS_DEFAULT and it needs to be set here. |
* This is just an optimization to avoid multiple calls to the lookup |
* function. |
*/ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
&& png_ptr->read_user_chunk_fn == NULL |
keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name); |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
/* One of the following methods will read the chunk or skip it (at least one |
* of these is always defined because this is the only way to switch on |
* PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
*/ |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
|| (png_ptr->read_user_chunk_fn != NULL) |
#endif |
) |
/* The user callback takes precedence over the chunk keep value, but the |
* keep value is still required to validate a save of a critical chunk. |
*/ |
if (png_ptr->read_user_chunk_fn != NULL) |
{ |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
if (png_cache_unknown_chunk(png_ptr, length)) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
/* Callback to user unknown chunk handler */ |
int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr, |
&png_ptr->unknown_chunk); |
/* ret is: |
* negative: An error occured, png_chunk_error will be called. |
* zero: The chunk was not handled, the chunk will be discarded |
* unless png_set_keep_unknown_chunks has been used to set |
* a 'keep' behavior for this particular chunk, in which |
* case that will be used. A critical chunk will cause an |
* error at this point unless it is to be saved. |
* positive: The chunk was handled, libpng will ignore/discard it. |
*/ |
if (ret < 0) |
png_chunk_error(png_ptr, "error in user chunk"); |
else if (ret == 0) |
{ |
/* If the keep value is 'default' or 'never' override it, but |
* still error out on critical chunks unless the keep value is |
* 'always' While this is weird it is the behavior in 1.4.12. |
* A possible improvement would be to obey the value set for the |
* chunk, but this would be an API change that would probably |
* damage some applications. |
* |
* The png_app_warning below catches the case that matters, where |
* the application has not set specific save or ignore for this |
* chunk or global save or ignore. |
*/ |
if (keep < PNG_HANDLE_CHUNK_IF_SAFE) |
{ |
# ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE) |
{ |
png_chunk_warning(png_ptr, "Saving unknown chunk:"); |
png_app_warning(png_ptr, |
"forcing save of an unhandled chunk;" |
" please call png_set_keep_unknown_chunks"); |
/* with keep = PNG_HANDLE_CHUNK_IF_SAFE */ |
} |
#endif |
keep = PNG_HANDLE_CHUNK_IF_SAFE; |
} |
} |
png_memcpy((png_charp)png_ptr->unknown_chunk.name, |
(png_charp)png_ptr->chunk_name, |
png_sizeof(png_ptr->unknown_chunk.name)); |
else /* chunk was handled */ |
{ |
handled = 1; |
/* Critical chunks can be safely discarded at this point. */ |
keep = PNG_HANDLE_CHUNK_NEVER; |
} |
} |
png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] |
= '\0'; |
else |
keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */ |
} |
png_ptr->unknown_chunk.size = (png_size_t)length; |
else |
/* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */ |
# endif /* PNG_READ_USER_CHUNKS_SUPPORTED */ |
if (length == 0) |
png_ptr->unknown_chunk.data = NULL; |
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED |
{ |
/* keep is currently just the per-chunk setting, if there was no |
* setting change it to the global default now (not that this may |
* still be AS_DEFAULT) then obtain the cache of the chunk if required, |
* if not simply skip the chunk. |
*/ |
if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT) |
keep = png_ptr->unknown_default; |
else |
if (keep == PNG_HANDLE_CHUNK_ALWAYS || |
(keep == PNG_HANDLE_CHUNK_IF_SAFE && |
PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))) |
{ |
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length); |
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); |
if (!png_cache_unknown_chunk(png_ptr, length)) |
keep = PNG_HANDLE_CHUNK_NEVER; |
} |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
if (png_ptr->read_user_chunk_fn != NULL) |
else |
png_crc_finish(png_ptr, length); |
} |
# else |
# ifndef PNG_READ_USER_CHUNKS_SUPPORTED |
# error no method to support READ_UNKNOWN_CHUNKS |
# endif |
{ |
/* Callback to user unknown chunk handler */ |
int ret; |
/* If here there is no read callback pointer set and no support is |
* compiled in to just save the unknown chunks, so simply skip this |
* chunk. If 'keep' is something other than AS_DEFAULT or NEVER then |
* the app has erroneously asked for unknown chunk saving when there |
* is no support. |
*/ |
if (keep > PNG_HANDLE_CHUNK_NEVER) |
png_app_error(png_ptr, "no unknown chunk support available"); |
ret = (*(png_ptr->read_user_chunk_fn)) |
(png_ptr, &png_ptr->unknown_chunk); |
png_crc_finish(png_ptr, length); |
} |
# endif /* PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED */ |
if (ret < 0) |
png_chunk_error(png_ptr, "error in user chunk"); |
if (ret == 0) |
# ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
/* Now store the chunk in the chunk list if appropriate, and if the limits |
* permit it. |
*/ |
if (keep == PNG_HANDLE_CHUNK_ALWAYS || |
(keep == PNG_HANDLE_CHUNK_IF_SAFE && |
PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
# ifdef PNG_USER_LIMITS_SUPPORTED |
switch (png_ptr->user_chunk_cache_max) |
{ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
case 2: |
png_ptr->user_chunk_cache_max = 1; |
png_chunk_benign_error(png_ptr, "no space in chunk cache"); |
/* FALL THROUGH */ |
case 1: |
/* NOTE: prior to 1.6.0 this case resulted in an unknown critical |
* chunk being skipped, now there will be a hard error below. |
*/ |
break; |
default: /* not at limit */ |
--(png_ptr->user_chunk_cache_max); |
/* FALL THROUGH */ |
case 0: /* no limit */ |
# endif /* PNG_USER_LIMITS_SUPPORTED */ |
/* Here when the limit isn't reached or when limits are compiled |
* out; store the chunk. |
*/ |
png_set_unknown_chunks(png_ptr, info_ptr, |
&png_ptr->unknown_chunk, 1); |
handled = 1; |
# ifdef PNG_USER_LIMITS_SUPPORTED |
break; |
} |
# endif |
} |
else |
# else /* no store support! */ |
PNG_UNUSED(info_ptr) |
# error untested code (reading unknown chunks with no store support) |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); |
/* Regardless of the error handling below the cached data (if any) can be |
* freed now. Notice that the data is not freed if there is a png_error, but |
* it will be freed by destroy_read_struct. |
*/ |
if (png_ptr->unknown_chunk.data != NULL) |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
else |
#endif |
skip = length; |
#else /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */ |
/* There is no support to read an unknown chunk, so just skip it. */ |
png_crc_finish(png_ptr, length); |
PNG_UNUSED(info_ptr) |
PNG_UNUSED(keep) |
#endif /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */ |
png_crc_finish(png_ptr, skip); |
#ifndef PNG_READ_USER_CHUNKS_SUPPORTED |
PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */ |
#endif |
/* Check for unhandled critical chunks */ |
if (!handled && PNG_CHUNK_CRITICAL(png_ptr->chunk_name)) |
png_chunk_error(png_ptr, "unhandled critical chunk"); |
} |
/* This function is called to verify that a chunk name is valid. |
2632,259 → 2962,525 |
* the chunk name itself is valid. |
*/ |
#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) |
/* Bit hacking: the test for an invalid byte in the 4 byte chunk name is: |
* |
* ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) |
*/ |
void /* PRIVATE */ |
png_check_chunk_name(png_structp png_ptr, png_const_bytep chunk_name) |
png_check_chunk_name(png_structrp png_ptr, png_uint_32 chunk_name) |
{ |
int i; |
png_debug(1, "in png_check_chunk_name"); |
if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || |
isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) |
for (i=1; i<=4; ++i) |
{ |
int c = chunk_name & 0xff; |
if (c < 65 || c > 122 || (c > 90 && c < 97)) |
png_chunk_error(png_ptr, "invalid chunk type"); |
chunk_name >>= 8; |
} |
} |
/* Combines the row recently read in with the existing pixels in the |
* row. This routine takes care of alpha and transparency if requested. |
* This routine also handles the two methods of progressive display |
* of interlaced images, depending on the mask value. |
* The mask value describes which pixels are to be combined with |
* the row. The pattern always repeats every 8 pixels, so just 8 |
* bits are needed. A one indicates the pixel is to be combined, |
* a zero indicates the pixel is to be skipped. This is in addition |
* to any alpha or transparency value associated with the pixel. If |
* you want all pixels to be combined, pass 0xff (255) in mask. |
/* Combines the row recently read in with the existing pixels in the row. This |
* routine takes care of alpha and transparency if requested. This routine also |
* handles the two methods of progressive display of interlaced images, |
* depending on the 'display' value; if 'display' is true then the whole row |
* (dp) is filled from the start by replicating the available pixels. If |
* 'display' is false only those pixels present in the pass are filled in. |
*/ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display) |
{ |
unsigned int pixel_depth = png_ptr->transformed_pixel_depth; |
png_const_bytep sp = png_ptr->row_buf + 1; |
png_uint_32 row_width = png_ptr->width; |
unsigned int pass = png_ptr->pass; |
png_bytep end_ptr = 0; |
png_byte end_byte = 0; |
unsigned int end_mask; |
png_debug(1, "in png_combine_row"); |
if (mask == 0xff) |
/* Added in 1.5.6: it should not be possible to enter this routine until at |
* least one row has been read from the PNG data and transformed. |
*/ |
if (pixel_depth == 0) |
png_error(png_ptr, "internal row logic error"); |
/* Added in 1.5.4: the pixel depth should match the information returned by |
* any call to png_read_update_info at this point. Do not continue if we got |
* this wrong. |
*/ |
if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes != |
PNG_ROWBYTES(pixel_depth, row_width)) |
png_error(png_ptr, "internal row size calculation error"); |
/* Don't expect this to ever happen: */ |
if (row_width == 0) |
png_error(png_ptr, "internal row width error"); |
/* Preserve the last byte in cases where only part of it will be overwritten, |
* the multiply below may overflow, we don't care because ANSI-C guarantees |
* we get the low bits. |
*/ |
end_mask = (pixel_depth * row_width) & 7; |
if (end_mask != 0) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width)); |
/* end_ptr == NULL is a flag to say do nothing */ |
end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1; |
end_byte = *end_ptr; |
# ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) /* little-endian byte */ |
end_mask = 0xff << end_mask; |
else /* big-endian byte */ |
# endif |
end_mask = 0xff >> end_mask; |
/* end_mask is now the bits to *keep* from the destination row */ |
} |
else |
/* For non-interlaced images this reduces to a memcpy(). A memcpy() |
* will also happen if interlacing isn't supported or if the application |
* does not call png_set_interlace_handling(). In the latter cases the |
* caller just gets a sequence of the unexpanded rows from each interlace |
* pass. |
*/ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE) && |
pass < 6 && (display == 0 || |
/* The following copies everything for 'display' on passes 0, 2 and 4. */ |
(display == 1 && (pass & 1) != 0))) |
{ |
switch (png_ptr->row_info.pixel_depth) |
/* Narrow images may have no bits in a pass; the caller should handle |
* this, but this test is cheap: |
*/ |
if (row_width <= PNG_PASS_START_COL(pass)) |
return; |
if (pixel_depth < 8) |
{ |
case 1: |
/* For pixel depths up to 4 bpp the 8-pixel mask can be expanded to fit |
* into 32 bits, then a single loop over the bytes using the four byte |
* values in the 32-bit mask can be used. For the 'display' option the |
* expanded mask may also not require any masking within a byte. To |
* make this work the PACKSWAP option must be taken into account - it |
* simply requires the pixels to be reversed in each byte. |
* |
* The 'regular' case requires a mask for each of the first 6 passes, |
* the 'display' case does a copy for the even passes in the range |
* 0..6. This has already been handled in the test above. |
* |
* The masks are arranged as four bytes with the first byte to use in |
* the lowest bits (little-endian) regardless of the order (PACKSWAP or |
* not) of the pixels in each byte. |
* |
* NOTE: the whole of this logic depends on the caller of this function |
* only calling it on rows appropriate to the pass. This function only |
* understands the 'x' logic; the 'y' logic is handled by the caller. |
* |
* The following defines allow generation of compile time constant bit |
* masks for each pixel depth and each possibility of swapped or not |
* swapped bytes. Pass 'p' is in the range 0..6; 'x', a pixel index, |
* is in the range 0..7; and the result is 1 if the pixel is to be |
* copied in the pass, 0 if not. 'S' is for the sparkle method, 'B' |
* for the block method. |
* |
* With some compilers a compile time expression of the general form: |
* |
* (shift >= 32) ? (a >> (shift-32)) : (b >> shift) |
* |
* Produces warnings with values of 'shift' in the range 33 to 63 |
* because the right hand side of the ?: expression is evaluated by |
* the compiler even though it isn't used. Microsoft Visual C (various |
* versions) and the Intel C compiler are known to do this. To avoid |
* this the following macros are used in 1.5.6. This is a temporary |
* solution to avoid destabilizing the code during the release process. |
*/ |
# if PNG_USE_COMPILE_TIME_MASKS |
# define PNG_LSR(x,s) ((x)>>((s) & 0x1f)) |
# define PNG_LSL(x,s) ((x)<<((s) & 0x1f)) |
# else |
# define PNG_LSR(x,s) ((x)>>(s)) |
# define PNG_LSL(x,s) ((x)<<(s)) |
# endif |
# define S_COPY(p,x) (((p)<4 ? PNG_LSR(0x80088822,(3-(p))*8+(7-(x))) :\ |
PNG_LSR(0xaa55ff00,(7-(p))*8+(7-(x)))) & 1) |
# define B_COPY(p,x) (((p)<4 ? PNG_LSR(0xff0fff33,(3-(p))*8+(7-(x))) :\ |
PNG_LSR(0xff55ff00,(7-(p))*8+(7-(x)))) & 1) |
/* Return a mask for pass 'p' pixel 'x' at depth 'd'. The mask is |
* little endian - the first pixel is at bit 0 - however the extra |
* parameter 's' can be set to cause the mask position to be swapped |
* within each byte, to match the PNG format. This is done by XOR of |
* the shift with 7, 6 or 4 for bit depths 1, 2 and 4. |
*/ |
# define PIXEL_MASK(p,x,d,s) \ |
(PNG_LSL(((PNG_LSL(1U,(d)))-1),(((x)*(d))^((s)?8-(d):0)))) |
/* Hence generate the appropriate 'block' or 'sparkle' pixel copy mask. |
*/ |
# define S_MASKx(p,x,d,s) (S_COPY(p,x)?PIXEL_MASK(p,x,d,s):0) |
# define B_MASKx(p,x,d,s) (B_COPY(p,x)?PIXEL_MASK(p,x,d,s):0) |
/* Combine 8 of these to get the full mask. For the 1-bpp and 2-bpp |
* cases the result needs replicating, for the 4-bpp case the above |
* generates a full 32 bits. |
*/ |
# define MASK_EXPAND(m,d) ((m)*((d)==1?0x01010101:((d)==2?0x00010001:1))) |
# define S_MASK(p,d,s) MASK_EXPAND(S_MASKx(p,0,d,s) + S_MASKx(p,1,d,s) +\ |
S_MASKx(p,2,d,s) + S_MASKx(p,3,d,s) + S_MASKx(p,4,d,s) +\ |
S_MASKx(p,5,d,s) + S_MASKx(p,6,d,s) + S_MASKx(p,7,d,s), d) |
# define B_MASK(p,d,s) MASK_EXPAND(B_MASKx(p,0,d,s) + B_MASKx(p,1,d,s) +\ |
B_MASKx(p,2,d,s) + B_MASKx(p,3,d,s) + B_MASKx(p,4,d,s) +\ |
B_MASKx(p,5,d,s) + B_MASKx(p,6,d,s) + B_MASKx(p,7,d,s), d) |
#if PNG_USE_COMPILE_TIME_MASKS |
/* Utility macros to construct all the masks for a depth/swap |
* combination. The 's' parameter says whether the format is PNG |
* (big endian bytes) or not. Only the three odd-numbered passes are |
* required for the display/block algorithm. |
*/ |
# define S_MASKS(d,s) { S_MASK(0,d,s), S_MASK(1,d,s), S_MASK(2,d,s),\ |
S_MASK(3,d,s), S_MASK(4,d,s), S_MASK(5,d,s) } |
# define B_MASKS(d,s) { B_MASK(1,d,s), S_MASK(3,d,s), S_MASK(5,d,s) } |
# define DEPTH_INDEX(d) ((d)==1?0:((d)==2?1:2)) |
/* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and |
* then pass: |
*/ |
static PNG_CONST png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] = |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_inc, s_start, s_end; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
/* Little-endian byte masks for PACKSWAP */ |
{ S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) }, |
/* Normal (big-endian byte) masks - PNG format */ |
{ S_MASKS(1,1), S_MASKS(2,1), S_MASKS(4,1) } |
}; |
/* display_mask has only three entries for the odd passes, so index by |
* pass>>1. |
*/ |
static PNG_CONST png_uint_32 display_mask[2][3][3] = |
{ |
/* Little-endian byte masks for PACKSWAP */ |
{ B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) }, |
/* Normal (big-endian byte) masks - PNG format */ |
{ B_MASKS(1,1), B_MASKS(2,1), B_MASKS(4,1) } |
}; |
# define MASK(pass,depth,display,png)\ |
((display)?display_mask[png][DEPTH_INDEX(depth)][pass>>1]:\ |
row_mask[png][DEPTH_INDEX(depth)][pass]) |
#else /* !PNG_USE_COMPILE_TIME_MASKS */ |
/* This is the runtime alternative: it seems unlikely that this will |
* ever be either smaller or faster than the compile time approach. |
*/ |
# define MASK(pass,depth,display,png)\ |
((display)?B_MASK(pass,depth,png):S_MASK(pass,depth,png)) |
#endif /* !PNG_USE_COMPILE_TIME_MASKS */ |
/* Use the appropriate mask to copy the required bits. In some cases |
* the byte mask will be 0 or 0xff, optimize these cases. row_width is |
* the number of pixels, but the code copies bytes, so it is necessary |
* to special case the end. |
*/ |
png_uint_32 pixels_per_byte = 8 / pixel_depth; |
png_uint_32 mask; |
#ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
mask = MASK(pass, pixel_depth, display, 0); |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
mask = MASK(pass, pixel_depth, display, 1); |
shift = s_start; |
for (i = 0; i < row_width; i++) |
for (;;) |
{ |
if (m & mask) |
{ |
int value; |
png_uint_32 m; |
value = (*sp >> shift) & 0x01; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
/* It doesn't matter in the following if png_uint_32 has more than |
* 32 bits because the high bits always match those in m<<24; it is, |
* however, essential to use OR here, not +, because of this. |
*/ |
m = mask; |
mask = (m >> 8) | (m << 24); /* rotate right to good compilers */ |
m &= 0xff; |
if (shift == s_end) |
if (m != 0) /* something to copy */ |
{ |
shift = s_start; |
sp++; |
dp++; |
if (m != 0xff) |
*dp = (png_byte)((*dp & ~m) | (*sp & m)); |
else |
*dp = *sp; |
} |
else |
shift += s_inc; |
/* NOTE: this may overwrite the last byte with garbage if the image |
* is not an exact number of bytes wide; libpng has always done |
* this. |
*/ |
if (row_width <= pixels_per_byte) |
break; /* May need to restore part of the last byte */ |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
row_width -= pixels_per_byte; |
++dp; |
++sp; |
} |
break; |
} |
case 2: |
else /* pixel_depth >= 8 */ |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
unsigned int bytes_to_copy, bytes_to_jump; |
#ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
/* Validate the depth - it must be a multiple of 8 */ |
if (pixel_depth & 7) |
png_error(png_ptr, "invalid user transform pixel depth"); |
pixel_depth >>= 3; /* now in bytes */ |
row_width *= pixel_depth; |
/* Regardless of pass number the Adam 7 interlace always results in a |
* fixed number of pixels to copy then to skip. There may be a |
* different number of pixels to skip at the start though. |
*/ |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
unsigned int offset = PNG_PASS_START_COL(pass) * pixel_depth; |
row_width -= offset; |
dp += offset; |
sp += offset; |
} |
else |
#endif |
/* Work out the bytes to copy. */ |
if (display) |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
/* When doing the 'block' algorithm the pixel in the pass gets |
* replicated to adjacent pixels. This is why the even (0,2,4,6) |
* passes are skipped above - the entire expanded row is copied. |
*/ |
bytes_to_copy = (1<<((6-pass)>>1)) * pixel_depth; |
/* But don't allow this number to exceed the actual row width. */ |
if (bytes_to_copy > row_width) |
bytes_to_copy = row_width; |
} |
shift = s_start; |
else /* normal row; Adam7 only ever gives us one pixel to copy. */ |
bytes_to_copy = pixel_depth; |
for (i = 0; i < row_width; i++) |
/* In Adam7 there is a constant offset between where the pixels go. */ |
bytes_to_jump = PNG_PASS_COL_OFFSET(pass) * pixel_depth; |
/* And simply copy these bytes. Some optimization is possible here, |
* depending on the value of 'bytes_to_copy'. Special case the low |
* byte counts, which we know to be frequent. |
* |
* Notice that these cases all 'return' rather than 'break' - this |
* avoids an unnecessary test on whether to restore the last byte |
* below. |
*/ |
switch (bytes_to_copy) |
{ |
if (m & mask) |
case 1: |
for (;;) |
{ |
value = (*sp >> shift) & 0x03; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
*dp = *sp; |
if (row_width <= bytes_to_jump) |
return; |
dp += bytes_to_jump; |
sp += bytes_to_jump; |
row_width -= bytes_to_jump; |
} |
if (shift == s_end) |
case 2: |
/* There is a possibility of a partial copy at the end here; this |
* slows the code down somewhat. |
*/ |
do |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
dp[0] = sp[0], dp[1] = sp[1]; |
else |
shift += s_inc; |
if (row_width <= bytes_to_jump) |
return; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
sp += bytes_to_jump; |
dp += bytes_to_jump; |
row_width -= bytes_to_jump; |
} |
break; |
} |
while (row_width > 1); |
case 4: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
/* And there can only be one byte left at this point: */ |
*dp = *sp; |
return; |
#ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
case 3: |
/* This can only be the RGB case, so each copy is exactly one |
* pixel and it is not necessary to check for a partial copy. |
*/ |
for(;;) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
dp[0] = sp[0], dp[1] = sp[1], dp[2] = sp[2]; |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
if (row_width <= bytes_to_jump) |
return; |
sp += bytes_to_jump; |
dp += bytes_to_jump; |
row_width -= bytes_to_jump; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
default: |
#if PNG_ALIGN_TYPE != PNG_ALIGN_NONE |
/* Check for double byte alignment and, if possible, use a |
* 16-bit copy. Don't attempt this for narrow images - ones that |
* are less than an interlace panel wide. Don't attempt it for |
* wide bytes_to_copy either - use the memcpy there. |
*/ |
if (bytes_to_copy < 16 /*else use memcpy*/ && |
png_isaligned(dp, png_uint_16) && |
png_isaligned(sp, png_uint_16) && |
bytes_to_copy % (sizeof (png_uint_16)) == 0 && |
bytes_to_jump % (sizeof (png_uint_16)) == 0) |
{ |
if (m & mask) |
/* Everything is aligned for png_uint_16 copies, but try for |
* png_uint_32 first. |
*/ |
if (png_isaligned(dp, png_uint_32) && |
png_isaligned(sp, png_uint_32) && |
bytes_to_copy % (sizeof (png_uint_32)) == 0 && |
bytes_to_jump % (sizeof (png_uint_32)) == 0) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
png_uint_32p dp32 = png_aligncast(png_uint_32p,dp); |
png_const_uint_32p sp32 = png_aligncastconst( |
png_const_uint_32p, sp); |
size_t skip = (bytes_to_jump-bytes_to_copy) / |
(sizeof (png_uint_32)); |
if (shift == s_end) |
do |
{ |
shift = s_start; |
sp++; |
dp++; |
size_t c = bytes_to_copy; |
do |
{ |
*dp32++ = *sp32++; |
c -= (sizeof (png_uint_32)); |
} |
while (c > 0); |
else |
shift += s_inc; |
if (row_width <= bytes_to_jump) |
return; |
if (m == 1) |
m = 0x80; |
dp32 += skip; |
sp32 += skip; |
row_width -= bytes_to_jump; |
} |
while (bytes_to_copy <= row_width); |
else |
m >>= 1; |
/* Get to here when the row_width truncates the final copy. |
* There will be 1-3 bytes left to copy, so don't try the |
* 16-bit loop below. |
*/ |
dp = (png_bytep)dp32; |
sp = (png_const_bytep)sp32; |
do |
*dp++ = *sp++; |
while (--row_width > 0); |
return; |
} |
break; |
} |
default: |
/* Else do it in 16-bit quantities, but only if the size is |
* not too large. |
*/ |
else |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
png_byte m = 0x80; |
png_uint_16p dp16 = png_aligncast(png_uint_16p, dp); |
png_const_uint_16p sp16 = png_aligncastconst( |
png_const_uint_16p, sp); |
size_t skip = (bytes_to_jump-bytes_to_copy) / |
(sizeof (png_uint_16)); |
for (i = 0; i < row_width; i++) |
do |
{ |
if (m & mask) |
size_t c = bytes_to_copy; |
do |
{ |
png_memcpy(dp, sp, pixel_bytes); |
*dp16++ = *sp16++; |
c -= (sizeof (png_uint_16)); |
} |
while (c > 0); |
sp += pixel_bytes; |
dp += pixel_bytes; |
if (row_width <= bytes_to_jump) |
return; |
if (m == 1) |
m = 0x80; |
dp16 += skip; |
sp16 += skip; |
row_width -= bytes_to_jump; |
} |
while (bytes_to_copy <= row_width); |
else |
m >>= 1; |
/* End of row - 1 byte left, bytes_to_copy > row_width: */ |
dp = (png_bytep)dp16; |
sp = (png_const_bytep)sp16; |
do |
*dp++ = *sp++; |
while (--row_width > 0); |
return; |
} |
break; |
} |
#endif /* PNG_ALIGN_ code */ |
/* The true default - use a memcpy: */ |
for (;;) |
{ |
memcpy(dp, sp, bytes_to_copy); |
if (row_width <= bytes_to_jump) |
return; |
sp += bytes_to_jump; |
dp += bytes_to_jump; |
row_width -= bytes_to_jump; |
if (bytes_to_copy > row_width) |
bytes_to_copy = row_width; |
} |
} |
/* NOT REACHED*/ |
} /* pixel_depth >= 8 */ |
/* Here if pixel_depth < 8 to check 'end_ptr' below. */ |
} |
else |
#endif |
/* If here then the switch above wasn't used so just memcpy the whole row |
* from the temporary row buffer (notice that this overwrites the end of the |
* destination row if it is a partial byte.) |
*/ |
memcpy(dp, sp, PNG_ROWBYTES(pixel_depth, row_width)); |
/* Restore the overwritten bits from the last byte if necessary. */ |
if (end_ptr != NULL) |
*end_ptr = (png_byte)((end_byte & end_mask) | (*end_ptr & ~end_mask)); |
} |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, |
png_uint_32 transformations /* Because these may affect the byte layout */) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
png_uint_32 transformations = png_ptr->transformations; |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
png_debug(1, "in png_do_read_interlace"); |
if (row != NULL && row_info != NULL) |
2931,8 → 3527,9 |
v = (png_byte)((*sp >> sshift) & 0x01); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
unsigned int tmp = *dp & (0x7f7f >> (7 - dshift)); |
tmp |= v << dshift; |
*dp = (png_byte)(tmp & 0xff); |
if (dshift == s_end) |
{ |
2993,8 → 3590,9 |
v = (png_byte)((*sp >> sshift) & 0x03); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
unsigned int tmp = *dp & (0x3f3f >> (6 - dshift)); |
tmp |= v << dshift; |
*dp = (png_byte)(tmp & 0xff); |
if (dshift == s_end) |
{ |
3049,13 → 3647,14 |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v = (png_byte)((*sp >> sshift) & 0xf); |
png_byte v = (png_byte)((*sp >> sshift) & 0x0f); |
int j; |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
unsigned int tmp = *dp & (0xf0f >> (4 - dshift)); |
tmp |= v << dshift; |
*dp = (png_byte)(tmp & 0xff); |
if (dshift == s_end) |
{ |
3078,6 → 3677,7 |
} |
break; |
} |
default: |
{ |
png_size_t pixel_bytes = (row_info->pixel_depth >> 3); |
3092,14 → 3692,14 |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v[8]; |
png_byte v[8]; /* SAFE; pixel_depth does not exceed 64 */ |
int j; |
png_memcpy(v, sp, pixel_bytes); |
memcpy(v, sp, pixel_bytes); |
for (j = 0; j < jstop; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
3108,6 → 3708,7 |
break; |
} |
} |
row_info->width = final_width; |
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width); |
} |
3117,33 → 3718,27 |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row, int filter) |
static void |
png_read_filter_row_sub(png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row) |
{ |
png_debug(1, "in png_read_filter_row"); |
png_debug2(2, "row = %u, filter = %d", png_ptr->row_number, filter); |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
unsigned int bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
PNG_UNUSED(prev_row) |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
*rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_UP: |
static void |
png_read_filter_row_up(png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row) |
{ |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
3155,14 → 3750,15 |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_AVG: |
static void |
png_read_filter_row_avg(png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row) |
{ |
png_size_t i; |
png_bytep rp = row; |
png_const_bytep pp = prev_row; |
png_bytep lp = row; |
unsigned int bpp = (row_info->pixel_depth + 7) >> 3; |
png_size_t istop = row_info->rowbytes - bpp; |
3177,35 → 3773,86 |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
(int)(*pp++ + *lp++) / 2 ) & 0xff); |
(int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_PAETH: |
static void |
png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row) |
{ |
png_size_t i; |
png_bytep rp = row; |
png_const_bytep pp = prev_row; |
png_bytep lp = row; |
png_const_bytep cp = prev_row; |
unsigned int bpp = (row_info->pixel_depth + 7) >> 3; |
png_size_t istop=row_info->rowbytes - bpp; |
png_bytep rp_end = row + row_info->rowbytes; |
int a, c; |
for (i = 0; i < bpp; i++) |
/* First pixel/byte */ |
c = *prev_row++; |
a = *row + c; |
*row++ = (png_byte)a; |
/* Remainder */ |
while (row < rp_end) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
int b, pa, pb, pc, p; |
a &= 0xff; /* From previous iteration or start */ |
b = *prev_row++; |
p = b - c; |
pc = a - c; |
# ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
# else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
# endif |
/* Find the best predictor, the least of pa, pb, pc favoring the earlier |
* ones in the case of a tie. |
*/ |
if (pb < pa) pa = pb, a = b; |
if (pc < pa) a = c; |
/* Calculate the current pixel in a, and move the previous row pixel to c |
* for the next time round the loop |
*/ |
c = b; |
a += *row; |
*row++ = (png_byte)a; |
} |
} |
for (i = 0; i < istop; i++) /* Use leftover rp,pp */ |
static void |
png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row) |
{ |
int bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp_end = row + bpp; |
/* Process the first pixel in the row completely (this is the same as 'up' |
* because there is only one candidate predictor for the first row). |
*/ |
while (row < rp_end) |
{ |
int a = *row + *prev_row++; |
*row++ = (png_byte)a; |
} |
/* Remainder */ |
rp_end += row_info->rowbytes - bpp; |
while (row < rp_end) |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
c = *(prev_row - bpp); |
a = *(row - bpp); |
b = *prev_row++; |
p = b - c; |
pc = a - c; |
3220,49 → 3867,264 |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
if (pb < pa) pa = pb, a = b; |
if (pc < pa) a = c; |
else if (pb <= pc) |
p = b; |
c = b; |
a += *row; |
*row++ = (png_byte)a; |
} |
} |
static void |
png_init_filter_functions(png_structrp pp) |
/* This function is called once for every PNG image (except for PNG images |
* that only use PNG_FILTER_VALUE_NONE for all rows) to set the |
* implementations required to reverse the filtering of PNG rows. Reversing |
* the filter is the first transformation performed on the row data. It is |
* performed in place, therefore an implementation can be selected based on |
* the image pixel format. If the implementation depends on image width then |
* take care to ensure that it works correctly if the image is interlaced - |
* interlacing causes the actual row width to vary. |
*/ |
{ |
unsigned int bpp = (pp->pixel_depth + 7) >> 3; |
pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub; |
pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up; |
pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg; |
if (bpp == 1) |
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = |
png_read_filter_row_paeth_1byte_pixel; |
else |
p = c; |
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = |
png_read_filter_row_paeth_multibyte_pixel; |
#ifdef PNG_FILTER_OPTIMIZATIONS |
/* To use this define PNG_FILTER_OPTIMIZATIONS as the name of a function to |
* call to install hardware optimizations for the above functions; simply |
* replace whatever elements of the pp->read_filter[] array with a hardware |
* specific (or, for that matter, generic) optimization. |
* |
* To see an example of this examine what configure.ac does when |
* --enable-arm-neon is specified on the command line. |
*/ |
PNG_FILTER_OPTIMIZATIONS(pp, bpp); |
#endif |
} |
p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; |
void /* PRIVATE */ |
png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row, int filter) |
{ |
/* OPTIMIZATION: DO NOT MODIFY THIS FUNCTION, instead #define |
* PNG_FILTER_OPTIMIZATIONS to a function that overrides the generic |
* implementations. See png_init_filter_functions above. |
*/ |
if (filter > PNG_FILTER_VALUE_NONE && filter < PNG_FILTER_VALUE_LAST) |
{ |
if (pp->read_filter[0] == NULL) |
png_init_filter_functions(pp); |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
pp->read_filter[filter-1](row_info, row, prev_row); |
} |
break; |
} |
default: |
png_error(png_ptr, "Ignoring bad adaptive filter type"); |
/*NOT REACHED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
void /* PRIVATE */ |
png_read_IDAT_data(png_structrp png_ptr, png_bytep output, |
png_alloc_size_t avail_out) |
{ |
/* Loop reading IDATs and decompressing the result into output[avail_out] */ |
png_ptr->zstream.next_out = output; |
png_ptr->zstream.avail_out = 0; /* safety: set below */ |
if (output == NULL) |
avail_out = 0; |
do |
{ |
int ret; |
png_byte tmpbuf[PNG_INFLATE_BUF_SIZE]; |
if (png_ptr->zstream.avail_in == 0) |
{ |
uInt avail_in; |
png_bytep buffer; |
while (png_ptr->idat_size == 0) |
{ |
png_crc_finish(png_ptr, 0); |
png_ptr->idat_size = png_read_chunk_header(png_ptr); |
/* This is an error even in the 'check' case because the code just |
* consumed a non-IDAT header. |
*/ |
if (png_ptr->chunk_name != png_IDAT) |
png_error(png_ptr, "Not enough image data"); |
} |
avail_in = png_ptr->IDAT_read_size; |
if (avail_in > png_ptr->idat_size) |
avail_in = (uInt)png_ptr->idat_size; |
/* A PNG with a gradually increasing IDAT size will defeat this attempt |
* to minimize memory usage by causing lots of re-allocs, but |
* realistically doing IDAT_read_size re-allocs is not likely to be a |
* big problem. |
*/ |
buffer = png_read_buffer(png_ptr, avail_in, 0/*error*/); |
png_crc_read(png_ptr, buffer, avail_in); |
png_ptr->idat_size -= avail_in; |
png_ptr->zstream.next_in = buffer; |
png_ptr->zstream.avail_in = avail_in; |
} |
/* And set up the output side. */ |
if (output != NULL) /* standard read */ |
{ |
uInt out = ZLIB_IO_MAX; |
if (out > avail_out) |
out = (uInt)avail_out; |
avail_out -= out; |
png_ptr->zstream.avail_out = out; |
} |
else /* after last row, checking for end */ |
{ |
png_ptr->zstream.next_out = tmpbuf; |
png_ptr->zstream.avail_out = (sizeof tmpbuf); |
} |
/* Use NO_FLUSH; this gives zlib the maximum opportunity to optimize the |
* process. If the LZ stream is truncated the sequential reader will |
* terminally damage the stream, above, by reading the chunk header of the |
* following chunk (it then exits with png_error). |
* |
* TODO: deal more elegantly with truncated IDAT lists. |
*/ |
ret = inflate(&png_ptr->zstream, Z_NO_FLUSH); |
/* Take the unconsumed output back. */ |
if (output != NULL) |
avail_out += png_ptr->zstream.avail_out; |
else /* avail_out counts the extra bytes */ |
avail_out += (sizeof tmpbuf) - png_ptr->zstream.avail_out; |
png_ptr->zstream.avail_out = 0; |
if (ret == Z_STREAM_END) |
{ |
/* Do this for safety; we won't read any more into this row. */ |
png_ptr->zstream.next_out = NULL; |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; |
if (png_ptr->zstream.avail_in > 0 || png_ptr->idat_size > 0) |
png_chunk_benign_error(png_ptr, "Extra compressed data"); |
break; |
} |
if (ret != Z_OK) |
{ |
png_zstream_error(png_ptr, ret); |
if (output != NULL) |
png_chunk_error(png_ptr, png_ptr->zstream.msg); |
else /* checking */ |
{ |
png_chunk_benign_error(png_ptr, png_ptr->zstream.msg); |
return; |
} |
} |
} while (avail_out > 0); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
if (avail_out > 0) |
{ |
/* The stream ended before the image; this is the same as too few IDATs so |
* should be handled the same way. |
*/ |
if (output != NULL) |
png_error(png_ptr, "Not enough image data"); |
else /* the deflate stream contained extra data */ |
png_chunk_benign_error(png_ptr, "Too much image data"); |
} |
} |
void /* PRIVATE */ |
png_read_finish_row(png_structp png_ptr) |
png_read_finish_IDAT(png_structrp png_ptr) |
{ |
/* We don't need any more data and the stream should have ended, however the |
* LZ end code may actually not have been processed. In this case we must |
* read it otherwise stray unread IDAT data or, more likely, an IDAT chunk |
* may still remain to be consumed. |
*/ |
if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) |
{ |
/* The NULL causes png_read_IDAT_data to swallow any remaining bytes in |
* the compressed stream, but the stream may be damaged too, so even after |
* this call we may need to terminate the zstream ownership. |
*/ |
png_read_IDAT_data(png_ptr, NULL, 0); |
png_ptr->zstream.next_out = NULL; /* safety */ |
/* Now clear everything out for safety; the following may not have been |
* done. |
*/ |
if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) |
{ |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; |
} |
} |
/* If the zstream has not been released do it now *and* terminate the reading |
* of the final IDAT chunk. |
*/ |
if (png_ptr->zowner == png_IDAT) |
{ |
/* Always do this; the pointers otherwise point into the read buffer. */ |
png_ptr->zstream.next_in = NULL; |
png_ptr->zstream.avail_in = 0; |
/* Now we no longer own the zstream. */ |
png_ptr->zowner = 0; |
/* The slightly weird semantics of the sequential IDAT reading is that we |
* are always in or at the end of an IDAT chunk, so we always need to do a |
* crc_finish here. If idat_size is non-zero we also need to read the |
* spurious bytes at the end of the chunk now. |
*/ |
(void)png_crc_finish(png_ptr, png_ptr->idat_size); |
} |
} |
void /* PRIVATE */ |
png_read_finish_row(png_structrp png_ptr) |
{ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
png_debug(1, "in png_read_finish_row"); |
3275,7 → 4137,10 |
{ |
png_ptr->row_number = 0; |
png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
/* TO DO: don't do this if prev_row isn't needed (requires |
* read-ahead of the next row's filter byte. |
*/ |
memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
do |
{ |
3307,92 → 4172,28 |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
{ |
PNG_IDAT; |
char extra; |
int ret; |
png_ptr->zstream.next_out = (Byte *)&extra; |
png_ptr->zstream.avail_out = (uInt)1; |
for (;;) |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_crc_finish(png_ptr, 0); |
png_ptr->idat_size = png_read_chunk_header(png_ptr); |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
/* Here after at the end of the last row of the last pass. */ |
png_read_finish_IDAT(png_ptr); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret == Z_STREAM_END) |
{ |
if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_warning(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression Error"); |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_warning(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
} |
png_ptr->zstream.avail_out = 0; |
} |
if (png_ptr->idat_size || png_ptr->zstream.avail_in) |
png_warning(png_ptr, "Extra compression data"); |
inflateReset(&png_ptr->zstream); |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
void /* PRIVATE */ |
png_read_start_row(png_structp png_ptr) |
png_read_start_row(png_structrp png_ptr) |
{ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int max_pixel_depth; |
3399,8 → 4200,10 |
png_size_t row_bytes; |
png_debug(1, "in png_read_start_row"); |
png_ptr->zstream.avail_in = 0; |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
png_init_read_transformations(png_ptr); |
#endif |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
if (png_ptr->interlaced) |
{ |
3426,6 → 4229,16 |
max_pixel_depth = png_ptr->pixel_depth; |
/* WARNING: * png_read_transform_info (pngrtran.c) performs a simpliar set of |
* calculations to calculate the final pixel depth, then |
* png_do_read_transforms actually does the transforms. This means that the |
* code which effectively calculates this value is actually repeated in three |
* separate places. They must all match. Innocent changes to the order of |
* transformations can and will break libpng in a way that causes memory |
* overwrites. |
* |
* TODO: fix this. |
*/ |
#ifdef PNG_READ_PACK_SUPPORTED |
if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) |
max_pixel_depth = 8; |
3463,13 → 4276,28 |
} |
#endif |
#ifdef PNG_READ_EXPAND_16_SUPPORTED |
if (png_ptr->transformations & PNG_EXPAND_16) |
{ |
# ifdef PNG_READ_EXPAND_SUPPORTED |
/* In fact it is an error if it isn't supported, but checking is |
* the safe way. |
*/ |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->bit_depth < 16) |
max_pixel_depth *= 2; |
} |
else |
# endif |
png_ptr->transformations &= ~PNG_EXPAND_16; |
} |
#endif |
#ifdef PNG_READ_FILLER_SUPPORTED |
if (png_ptr->transformations & (PNG_FILLER)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
max_pixel_depth = 32; |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (max_pixel_depth <= 8) |
max_pixel_depth = 16; |
3478,7 → 4306,8 |
max_pixel_depth = 32; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB || |
png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (max_pixel_depth <= 32) |
max_pixel_depth = 32; |
3540,6 → 4369,12 |
} |
#endif |
/* This value is stored in png_struct and double checked in the row read |
* code. |
*/ |
png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth; |
png_ptr->transformed_pixel_depth = 0; /* calculated on demand */ |
/* Align the width on the next larger 8 pixels. Mainly used |
* for interlacing |
*/ |
3558,6 → 4393,7 |
if (row_bytes + 48 > png_ptr->old_big_row_buf_size) |
{ |
png_free(png_ptr, png_ptr->big_row_buf); |
png_free(png_ptr, png_ptr->big_prev_row); |
if (png_ptr->interlaced) |
png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, |
3564,22 → 4400,32 |
row_bytes + 48); |
else |
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, |
row_bytes + 48); |
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48); |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48); |
#ifdef PNG_ALIGNED_MEMORY_SUPPORTED |
/* Use 16-byte aligned memory for row_buf with at least 16 bytes |
* of padding before and after row_buf. |
* of padding before and after row_buf; treat prev_row similarly. |
* NOTE: the alignment is to the start of the pixels, one beyond the start |
* of the buffer, because of the filter byte. Prior to libpng 1.5.6 this |
* was incorrect; the filter byte was aligned, which had the exact |
* opposite effect of that intended. |
*/ |
png_ptr->row_buf = png_ptr->big_row_buf + 32 - |
(((png_alloc_size_t)png_ptr->big_row_buf + 15) & 0x0F); |
{ |
png_bytep temp = png_ptr->big_row_buf + 32; |
int extra = (int)((temp - (png_bytep)0) & 0x0f); |
png_ptr->row_buf = temp - extra - 1/*filter byte*/; |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
temp = png_ptr->big_prev_row + 32; |
extra = (int)((temp - (png_bytep)0) & 0x0f); |
png_ptr->prev_row = temp - extra - 1/*filter byte*/; |
} |
#else |
/* Use 32 bytes of padding before and 16 bytes after row_buf. */ |
png_ptr->row_buf = png_ptr->big_row_buf + 32; |
/* Use 31 bytes of padding before and 17 bytes after row_buf. */ |
png_ptr->row_buf = png_ptr->big_row_buf + 31; |
png_ptr->prev_row = png_ptr->big_prev_row + 31; |
#endif |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
} |
3592,17 → 4438,8 |
if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1)) |
png_error(png_ptr, "Row has too many bytes to allocate in memory"); |
if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size) |
{ |
png_free(png_ptr, png_ptr->prev_row); |
memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1); |
png_ptr->old_prev_row_size = png_ptr->rowbytes + 1; |
} |
png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
png_debug1(3, "width = %u,", png_ptr->width); |
png_debug1(3, "height = %u,", png_ptr->height); |
png_debug1(3, "iwidth = %u,", png_ptr->iwidth); |
3611,6 → 4448,27 |
png_debug1(3, "irowbytes = %lu", |
(unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1); |
/* The sequential reader needs a buffer for IDAT, but the progressive reader |
* does not, so free the read buffer now regardless; the sequential reader |
* reallocates it on demand. |
*/ |
if (png_ptr->read_buffer) |
{ |
png_bytep buffer = png_ptr->read_buffer; |
png_ptr->read_buffer_size = 0; |
png_ptr->read_buffer = NULL; |
png_free(png_ptr, buffer); |
} |
/* Finally claim the zstream for the inflate of the IDAT data, use the bits |
* value from the stream (note that this will result in a fatal error if the |
* IDAT stream has a bogus deflate header window_bits value, but this should |
* not be happening any longer!) |
*/ |
if (png_inflate_claim(png_ptr, png_IDAT) != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg); |
png_ptr->flags |= PNG_FLAG_ROW_INIT; |
} |
#endif /* PNG_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngset.c |
---|
1,8 → 1,8 |
/* pngset.c - storage of image information into info struct |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.3 [July 18, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
22,15 → 22,15 |
#ifdef PNG_bKGD_SUPPORTED |
void PNGAPI |
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, |
png_set_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_color_16p background) |
{ |
png_debug1(1, "in %s storage function", "bKGD"); |
if (png_ptr == NULL || info_ptr == NULL) |
if (png_ptr == NULL || info_ptr == NULL || background == NULL) |
return; |
png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16)); |
info_ptr->background = *background; |
info_ptr->valid |= PNG_INFO_bKGD; |
} |
#endif |
37,36 → 37,68 |
#ifdef PNG_cHRM_SUPPORTED |
void PNGFAPI |
png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, |
png_set_cHRM_fixed(png_const_structrp png_ptr, png_inforp info_ptr, |
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, |
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, |
png_fixed_point blue_x, png_fixed_point blue_y) |
{ |
png_xy xy; |
png_debug1(1, "in %s storage function", "cHRM fixed"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
# ifdef PNG_CHECK_cHRM_SUPPORTED |
if (png_check_cHRM_fixed(png_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y)) |
# endif |
xy.redx = red_x; |
xy.redy = red_y; |
xy.greenx = green_x; |
xy.greeny = green_y; |
xy.bluex = blue_x; |
xy.bluey = blue_y; |
xy.whitex = white_x; |
xy.whitey = white_y; |
if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy, |
2/* override with app values*/)) |
info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
void PNGFAPI |
png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_inforp info_ptr, |
png_fixed_point int_red_X, png_fixed_point int_red_Y, |
png_fixed_point int_red_Z, png_fixed_point int_green_X, |
png_fixed_point int_green_Y, png_fixed_point int_green_Z, |
png_fixed_point int_blue_X, png_fixed_point int_blue_Y, |
png_fixed_point int_blue_Z) |
{ |
info_ptr->x_white = white_x; |
info_ptr->y_white = white_y; |
info_ptr->x_red = red_x; |
info_ptr->y_red = red_y; |
info_ptr->x_green = green_x; |
info_ptr->y_green = green_y; |
info_ptr->x_blue = blue_x; |
info_ptr->y_blue = blue_y; |
info_ptr->valid |= PNG_INFO_cHRM; |
png_XYZ XYZ; |
png_debug1(1, "in %s storage function", "cHRM XYZ fixed"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
XYZ.red_X = int_red_X; |
XYZ.red_Y = int_red_Y; |
XYZ.red_Z = int_red_Z; |
XYZ.green_X = int_green_X; |
XYZ.green_Y = int_green_Y; |
XYZ.green_Z = int_green_Z; |
XYZ.blue_X = int_blue_X; |
XYZ.blue_Y = int_blue_Y; |
XYZ.blue_Z = int_blue_Z; |
if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace, &XYZ, 2)) |
info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_cHRM(png_structp png_ptr, png_infop info_ptr, |
png_set_cHRM(png_const_structrp png_ptr, png_inforp info_ptr, |
double white_x, double white_y, double red_x, double red_y, |
double green_x, double green_y, double blue_x, double blue_y) |
{ |
80,6 → 112,23 |
png_fixed(png_ptr, blue_x, "cHRM Blue X"), |
png_fixed(png_ptr, blue_y, "cHRM Blue Y")); |
} |
void PNGAPI |
png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X, |
double red_Y, double red_Z, double green_X, double green_Y, double green_Z, |
double blue_X, double blue_Y, double blue_Z) |
{ |
png_set_cHRM_XYZ_fixed(png_ptr, info_ptr, |
png_fixed(png_ptr, red_X, "cHRM Red X"), |
png_fixed(png_ptr, red_Y, "cHRM Red Y"), |
png_fixed(png_ptr, red_Z, "cHRM Red Z"), |
png_fixed(png_ptr, green_X, "cHRM Red X"), |
png_fixed(png_ptr, green_Y, "cHRM Red Y"), |
png_fixed(png_ptr, green_Z, "cHRM Red Z"), |
png_fixed(png_ptr, blue_X, "cHRM Red X"), |
png_fixed(png_ptr, blue_Y, "cHRM Red Y"), |
png_fixed(png_ptr, blue_Z, "cHRM Red Z")); |
} |
# endif /* PNG_FLOATING_POINT_SUPPORTED */ |
#endif /* PNG_cHRM_SUPPORTED */ |
86,8 → 135,8 |
#ifdef PNG_gAMA_SUPPORTED |
void PNGFAPI |
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point |
file_gamma) |
png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr, |
png_fixed_point file_gamma) |
{ |
png_debug1(1, "in %s storage function", "gAMA"); |
94,26 → 143,13 |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Previously these values were limited, however they must be |
* wrong, therefore storing them (and setting PNG_INFO_gAMA) |
* must be wrong too. |
*/ |
if (file_gamma > (png_fixed_point)PNG_UINT_31_MAX) |
png_warning(png_ptr, "Gamma too large, ignored"); |
else if (file_gamma <= 0) |
png_warning(png_ptr, "Negative or zero gamma ignored"); |
else |
{ |
info_ptr->gamma = file_gamma; |
info_ptr->valid |= PNG_INFO_gAMA; |
png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma); |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) |
png_set_gAMA(png_const_structrp png_ptr, png_inforp info_ptr, double file_gamma) |
{ |
png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma, |
"png_set_gAMA")); |
123,7 → 159,8 |
#ifdef PNG_hIST_SUPPORTED |
void PNGAPI |
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_const_uint_16p hist) |
png_set_hIST(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_uint_16p hist) |
{ |
int i; |
146,26 → 183,26 |
/* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in |
* version 1.2.1 |
*/ |
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, |
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)); |
info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr, |
PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16)))); |
if (png_ptr->hist == NULL) |
if (info_ptr->hist == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for hIST chunk data"); |
return; |
} |
info_ptr->free_me |= PNG_FREE_HIST; |
for (i = 0; i < info_ptr->num_palette; i++) |
png_ptr->hist[i] = hist[i]; |
info_ptr->hist[i] = hist[i]; |
info_ptr->hist = png_ptr->hist; |
info_ptr->valid |= PNG_INFO_hIST; |
info_ptr->free_me |= PNG_FREE_HIST; |
} |
#endif |
void PNGAPI |
png_set_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
int filter_type) |
201,21 → 238,12 |
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); |
/* Check for potential overflow */ |
if (width > |
(PNG_UINT_32_MAX >> 3) /* 8-byte RRGGBBAA pixels */ |
- 48 /* bigrowbuf hack */ |
- 1 /* filter byte */ |
- 7*8 /* rounding of width to multiple of 8 pixels */ |
- 8) /* extra max_pixel_depth pad */ |
info_ptr->rowbytes = 0; |
else |
info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width); |
} |
#ifdef PNG_oFFs_SUPPORTED |
void PNGAPI |
png_set_oFFs(png_structp png_ptr, png_infop info_ptr, |
png_set_oFFs(png_const_structrp png_ptr, png_inforp info_ptr, |
png_int_32 offset_x, png_int_32 offset_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function", "oFFs"); |
232,7 → 260,7 |
#ifdef PNG_pCAL_SUPPORTED |
void PNGAPI |
png_set_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, |
int nparams, png_const_charp units, png_charpp params) |
{ |
241,10 → 269,11 |
png_debug1(1, "in %s storage function", "pCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
if (png_ptr == NULL || info_ptr == NULL || purpose == NULL || units == NULL |
|| (nparams > 0 && params == NULL)) |
return; |
length = png_strlen(purpose) + 1; |
length = strlen(purpose) + 1; |
png_debug1(3, "allocating purpose for info (%lu bytes)", |
(unsigned long)length); |
254,12 → 283,17 |
if (type < 0 || type > 3) |
png_error(png_ptr, "Invalid pCAL equation type"); |
if (nparams < 0 || nparams > 255) |
png_error(png_ptr, "Invalid pCAL parameter count"); |
/* Validate params[nparams] */ |
for (i=0; i<nparams; ++i) |
if (!png_check_fp_string(params[i], png_strlen(params[i]))) |
if (params[i] == NULL || |
!png_check_fp_string(params[i], strlen(params[i]))) |
png_error(png_ptr, "Invalid format for pCAL parameter"); |
info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); |
info_ptr->pcal_purpose = png_voidcast(png_charp, |
png_malloc_warn(png_ptr, length)); |
if (info_ptr->pcal_purpose == NULL) |
{ |
267,7 → 301,7 |
return; |
} |
png_memcpy(info_ptr->pcal_purpose, purpose, length); |
memcpy(info_ptr->pcal_purpose, purpose, length); |
png_debug(3, "storing X0, X1, type, and nparams in info"); |
info_ptr->pcal_X0 = X0; |
275,11 → 309,12 |
info_ptr->pcal_type = (png_byte)type; |
info_ptr->pcal_nparams = (png_byte)nparams; |
length = png_strlen(units) + 1; |
length = strlen(units) + 1; |
png_debug1(3, "allocating units for info (%lu bytes)", |
(unsigned long)length); |
info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); |
info_ptr->pcal_units = png_voidcast(png_charp, |
png_malloc_warn(png_ptr, length)); |
if (info_ptr->pcal_units == NULL) |
{ |
287,10 → 322,10 |
return; |
} |
png_memcpy(info_ptr->pcal_units, units, length); |
memcpy(info_ptr->pcal_units, units, length); |
info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, |
(png_size_t)((nparams + 1) * png_sizeof(png_charp))); |
info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr, |
(png_size_t)((nparams + 1) * (sizeof (png_charp))))); |
if (info_ptr->pcal_params == NULL) |
{ |
298,11 → 333,11 |
return; |
} |
png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp)); |
memset(info_ptr->pcal_params, 0, (nparams + 1) * (sizeof (png_charp))); |
for (i = 0; i < nparams; i++) |
{ |
length = png_strlen(params[i]) + 1; |
length = strlen(params[i]) + 1; |
png_debug2(3, "allocating parameter %d for info (%lu bytes)", i, |
(unsigned long)length); |
314,7 → 349,7 |
return; |
} |
png_memcpy(info_ptr->pcal_params[i], params[i], length); |
memcpy(info_ptr->pcal_params[i], params[i], length); |
} |
info_ptr->valid |= PNG_INFO_pCAL; |
324,7 → 359,7 |
#ifdef PNG_sCAL_SUPPORTED |
void PNGAPI |
png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr, |
int unit, png_const_charp swidth, png_const_charp sheight) |
{ |
png_size_t lengthw = 0, lengthh = 0; |
340,11 → 375,11 |
if (unit != 1 && unit != 2) |
png_error(png_ptr, "Invalid sCAL unit"); |
if (swidth == NULL || (lengthw = png_strlen(swidth)) <= 0 || |
if (swidth == NULL || (lengthw = strlen(swidth)) == 0 || |
swidth[0] == 45 /*'-'*/ || !png_check_fp_string(swidth, lengthw)) |
png_error(png_ptr, "Invalid sCAL width"); |
if (sheight == NULL || (lengthh = png_strlen(sheight)) <= 0 || |
if (sheight == NULL || (lengthh = strlen(sheight)) == 0 || |
sheight[0] == 45 /*'-'*/ || !png_check_fp_string(sheight, lengthh)) |
png_error(png_ptr, "Invalid sCAL height"); |
354,7 → 389,8 |
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw); |
info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, lengthw); |
info_ptr->scal_s_width = png_voidcast(png_charp, |
png_malloc_warn(png_ptr, lengthw)); |
if (info_ptr->scal_s_width == NULL) |
{ |
362,13 → 398,14 |
return; |
} |
png_memcpy(info_ptr->scal_s_width, swidth, lengthw); |
memcpy(info_ptr->scal_s_width, swidth, lengthw); |
++lengthh; |
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh); |
info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, lengthh); |
info_ptr->scal_s_height = png_voidcast(png_charp, |
png_malloc_warn(png_ptr, lengthh)); |
if (info_ptr->scal_s_height == NULL) |
{ |
379,7 → 416,7 |
return; |
} |
png_memcpy(info_ptr->scal_s_height, sheight, lengthh); |
memcpy(info_ptr->scal_s_height, sheight, lengthh); |
info_ptr->valid |= PNG_INFO_sCAL; |
info_ptr->free_me |= PNG_FREE_SCAL; |
387,8 → 424,8 |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL(png_structp png_ptr, png_infop info_ptr, int unit, double width, |
double height) |
png_set_sCAL(png_const_structrp png_ptr, png_inforp info_ptr, int unit, |
double width, double height) |
{ |
png_debug1(1, "in %s storage function", "sCAL"); |
405,9 → 442,9 |
char swidth[PNG_sCAL_MAX_DIGITS+1]; |
char sheight[PNG_sCAL_MAX_DIGITS+1]; |
png_ascii_from_fp(png_ptr, swidth, sizeof swidth, width, |
png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width, |
PNG_sCAL_PRECISION); |
png_ascii_from_fp(png_ptr, sheight, sizeof sheight, height, |
png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height, |
PNG_sCAL_PRECISION); |
png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); |
417,7 → 454,7 |
# ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL_fixed(png_structp png_ptr, png_infop info_ptr, int unit, |
png_set_sCAL_fixed(png_const_structrp png_ptr, png_inforp info_ptr, int unit, |
png_fixed_point width, png_fixed_point height) |
{ |
png_debug1(1, "in %s storage function", "sCAL"); |
435,8 → 472,8 |
char swidth[PNG_sCAL_MAX_DIGITS+1]; |
char sheight[PNG_sCAL_MAX_DIGITS+1]; |
png_ascii_from_fixed(png_ptr, swidth, sizeof swidth, width); |
png_ascii_from_fixed(png_ptr, sheight, sizeof sheight, height); |
png_ascii_from_fixed(png_ptr, swidth, (sizeof swidth), width); |
png_ascii_from_fixed(png_ptr, sheight, (sizeof sheight), height); |
png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); |
} |
446,7 → 483,7 |
#ifdef PNG_pHYs_SUPPORTED |
void PNGAPI |
png_set_pHYs(png_structp png_ptr, png_infop info_ptr, |
png_set_pHYs(png_const_structrp png_ptr, png_inforp info_ptr, |
png_uint_32 res_x, png_uint_32 res_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function", "pHYs"); |
462,7 → 499,7 |
#endif |
void PNGAPI |
png_set_PLTE(png_structp png_ptr, png_infop info_ptr, |
png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr, |
png_const_colorp palette, int num_palette) |
{ |
483,9 → 520,23 |
} |
} |
if ((num_palette > 0 && palette == NULL) || |
(num_palette == 0 |
# ifdef PNG_MNG_FEATURES_SUPPORTED |
&& (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 |
# endif |
)) |
{ |
png_chunk_report(png_ptr, "Invalid palette", PNG_CHUNK_ERROR); |
return; |
} |
/* It may not actually be necessary to set png_ptr->palette here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
* |
* 1.6.0: the above statement appears to be incorrect; something has to set |
* the palette inside png_struct on read. |
*/ |
png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); |
493,10 → 544,11 |
* of num_palette entries, in case of an invalid PNG file that has |
* too-large sample values. |
*/ |
png_ptr->palette = (png_colorp)png_calloc(png_ptr, |
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); |
png_ptr->palette = png_voidcast(png_colorp, png_calloc(png_ptr, |
PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)))); |
png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color)); |
if (num_palette > 0) |
memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color))); |
info_ptr->palette = png_ptr->palette; |
info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; |
507,15 → 559,15 |
#ifdef PNG_sBIT_SUPPORTED |
void PNGAPI |
png_set_sBIT(png_structp png_ptr, png_infop info_ptr, |
png_set_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_color_8p sig_bit) |
{ |
png_debug1(1, "in %s storage function", "sBIT"); |
if (png_ptr == NULL || info_ptr == NULL) |
if (png_ptr == NULL || info_ptr == NULL || sig_bit == NULL) |
return; |
png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8)); |
info_ptr->sig_bit = *sig_bit; |
info_ptr->valid |= PNG_INFO_sBIT; |
} |
#endif |
522,7 → 574,7 |
#ifdef PNG_sRGB_SUPPORTED |
void PNGAPI |
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int srgb_intent) |
png_set_sRGB(png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent) |
{ |
png_debug1(1, "in %s storage function", "sRGB"); |
529,12 → 581,12 |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->srgb_intent = (png_byte)srgb_intent; |
info_ptr->valid |= PNG_INFO_sRGB; |
(void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent); |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
void PNGAPI |
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, |
png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr, |
int srgb_intent) |
{ |
png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM"); |
542,21 → 594,14 |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_set_sRGB(png_ptr, info_ptr, srgb_intent); |
if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent)) |
{ |
/* This causes the gAMA and cHRM to be written too */ |
info_ptr->colorspace.flags |= |
PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM; |
} |
# ifdef PNG_gAMA_SUPPORTED |
png_set_gAMA_fixed(png_ptr, info_ptr, 45455L); |
# endif |
# ifdef PNG_cHRM_SUPPORTED |
png_set_cHRM_fixed(png_ptr, info_ptr, |
/* color x y */ |
/* white */ 31270L, 32900L, |
/* red */ 64000L, 33000L, |
/* green */ 30000L, 60000L, |
/* blue */ 15000L, 6000L |
); |
# endif /* cHRM */ |
png_colorspace_sync_info(png_ptr, info_ptr); |
} |
#endif /* sRGB */ |
563,13 → 608,13 |
#ifdef PNG_iCCP_SUPPORTED |
void PNGAPI |
png_set_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_charp name, int compression_type, |
png_const_bytep profile, png_uint_32 proflen) |
{ |
png_charp new_iccp_name; |
png_bytep new_iccp_profile; |
png_uint_32 length; |
png_size_t length; |
png_debug1(1, "in %s storage function", "iCCP"); |
576,27 → 621,52 |
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) |
return; |
length = png_strlen(name)+1; |
new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length); |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_app_error(png_ptr, "Invalid iCCP compression method"); |
/* Set the colorspace first because this validates the profile; do not |
* override previously set app cHRM or gAMA here (because likely as not the |
* application knows better than libpng what the correct values are.) Pass |
* the info_ptr color_type field to png_colorspace_set_ICC because in the |
* write case it has not yet been stored in png_ptr. |
*/ |
{ |
int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name, |
proflen, profile, info_ptr->color_type); |
png_colorspace_sync_info(png_ptr, info_ptr); |
/* Don't do any of the copying if the profile was bad, or inconsistent. */ |
if (!result) |
return; |
/* But do write the gAMA and cHRM chunks from the profile. */ |
info_ptr->colorspace.flags |= |
PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM; |
} |
length = strlen(name)+1; |
new_iccp_name = png_voidcast(png_charp, png_malloc_warn(png_ptr, length)); |
if (new_iccp_name == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory to process iCCP chunk"); |
png_benign_error(png_ptr, "Insufficient memory to process iCCP chunk"); |
return; |
} |
png_memcpy(new_iccp_name, name, length); |
new_iccp_profile = (png_bytep)png_malloc_warn(png_ptr, proflen); |
memcpy(new_iccp_name, name, length); |
new_iccp_profile = png_voidcast(png_bytep, |
png_malloc_warn(png_ptr, proflen)); |
if (new_iccp_profile == NULL) |
{ |
png_free (png_ptr, new_iccp_name); |
png_warning(png_ptr, |
png_benign_error(png_ptr, |
"Insufficient memory to process iCCP profile"); |
return; |
} |
png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); |
memcpy(new_iccp_profile, profile, proflen); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); |
603,10 → 673,6 |
info_ptr->iccp_proflen = proflen; |
info_ptr->iccp_name = new_iccp_name; |
info_ptr->iccp_profile = new_iccp_profile; |
/* Compression is always zero but is here so the API and info structure |
* does not have to change if we introduce multiple compression types |
*/ |
info_ptr->iccp_compression = (png_byte)compression_type; |
info_ptr->free_me |= PNG_FREE_ICCP; |
info_ptr->valid |= PNG_INFO_iCCP; |
} |
614,8 → 680,8 |
#ifdef PNG_TEXT_SUPPORTED |
void PNGAPI |
png_set_text(png_structp png_ptr, png_infop info_ptr, png_const_textp text_ptr, |
int num_text) |
png_set_text(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_textp text_ptr, int num_text) |
{ |
int ret; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); |
625,63 → 691,70 |
} |
int /* PRIVATE */ |
png_set_text_2(png_structp png_ptr, png_infop info_ptr, |
png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_textp text_ptr, int num_text) |
{ |
int i; |
png_debug1(1, "in %s storage function", ((png_ptr == NULL || |
png_ptr->chunk_name[0] == '\0') ? |
"text" : (png_const_charp)png_ptr->chunk_name)); |
png_debug1(1, "in %lx storage function", png_ptr == NULL ? "unexpected" : |
(unsigned long)png_ptr->chunk_name); |
if (png_ptr == NULL || info_ptr == NULL || num_text == 0) |
if (png_ptr == NULL || info_ptr == NULL || num_text <= 0 || text_ptr == NULL) |
return(0); |
/* Make sure we have enough space in the "text" array in info_struct |
* to hold all of the incoming text_ptr objects. |
* to hold all of the incoming text_ptr objects. This compare can't overflow |
* because max_text >= num_text (anyway, subtract of two positive integers |
* can't overflow in any case.) |
*/ |
if (info_ptr->num_text + num_text > info_ptr->max_text) |
if (num_text > info_ptr->max_text - info_ptr->num_text) |
{ |
if (info_ptr->text != NULL) |
int old_num_text = info_ptr->num_text; |
int max_text; |
png_textp new_text = NULL; |
/* Calculate an appropriate max_text, checking for overflow. */ |
max_text = old_num_text; |
if (num_text <= INT_MAX - max_text) |
{ |
png_textp old_text; |
int old_max; |
max_text += num_text; |
old_max = info_ptr->max_text; |
info_ptr->max_text = info_ptr->num_text + num_text + 8; |
old_text = info_ptr->text; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_size_t)(info_ptr->max_text * png_sizeof(png_text))); |
/* Round up to a multiple of 8 */ |
if (max_text < INT_MAX-8) |
max_text = (max_text + 8) & ~0x7; |
if (info_ptr->text == NULL) |
{ |
png_free(png_ptr, old_text); |
return(1); |
else |
max_text = INT_MAX; |
/* Now allocate a new array and copy the old members in, this does all |
* the overflow checks. |
*/ |
new_text = png_voidcast(png_textp,png_realloc_array(png_ptr, |
info_ptr->text, old_num_text, max_text-old_num_text, |
sizeof *new_text)); |
} |
png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * |
png_sizeof(png_text))); |
png_free(png_ptr, old_text); |
if (new_text == NULL) |
{ |
png_chunk_report(png_ptr, "too many text chunks", |
PNG_CHUNK_WRITE_ERROR); |
return 1; |
} |
else |
{ |
info_ptr->max_text = num_text + 8; |
info_ptr->num_text = 0; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_size_t)(info_ptr->max_text * png_sizeof(png_text))); |
if (info_ptr->text == NULL) |
return(1); |
png_free(png_ptr, info_ptr->text); |
info_ptr->text = new_text; |
info_ptr->free_me |= PNG_FREE_TEXT; |
info_ptr->max_text = max_text; |
/* num_text is adjusted below as the entries are copied in */ |
png_debug1(3, "allocated %d entries for info_ptr->text", max_text); |
} |
png_debug1(3, "allocated %d entries for info_ptr->text", |
info_ptr->max_text); |
} |
for (i = 0; i < num_text; i++) |
{ |
png_size_t text_length, key_len; |
png_size_t lang_len, lang_key_len; |
size_t text_length, key_len; |
size_t lang_len, lang_key_len; |
png_textp textp = &(info_ptr->text[info_ptr->num_text]); |
if (text_ptr[i].key == NULL) |
690,11 → 763,12 |
if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE || |
text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
png_warning(png_ptr, "text compression mode is out of range"); |
png_chunk_report(png_ptr, "text compression mode is out of range", |
PNG_CHUNK_WRITE_ERROR); |
continue; |
} |
key_len = png_strlen(text_ptr[i].key); |
key_len = strlen(text_ptr[i].key); |
if (text_ptr[i].compression <= 0) |
{ |
708,13 → 782,13 |
/* Set iTXt data */ |
if (text_ptr[i].lang != NULL) |
lang_len = png_strlen(text_ptr[i].lang); |
lang_len = strlen(text_ptr[i].lang); |
else |
lang_len = 0; |
if (text_ptr[i].lang_key != NULL) |
lang_key_len = png_strlen(text_ptr[i].lang_key); |
lang_key_len = strlen(text_ptr[i].lang_key); |
else |
lang_key_len = 0; |
721,7 → 795,8 |
} |
# else /* PNG_iTXt_SUPPORTED */ |
{ |
png_warning(png_ptr, "iTXt chunk not supported"); |
png_chunk_report(png_ptr, "iTXt chunk not supported", |
PNG_CHUNK_WRITE_ERROR); |
continue; |
} |
# endif |
740,16 → 815,19 |
else |
{ |
text_length = png_strlen(text_ptr[i].text); |
text_length = strlen(text_ptr[i].text); |
textp->compression = text_ptr[i].compression; |
} |
textp->key = (png_charp)png_malloc_warn(png_ptr, |
(png_size_t) |
(key_len + text_length + lang_len + lang_key_len + 4)); |
textp->key = png_voidcast(png_charp,png_malloc_base(png_ptr, |
key_len + text_length + lang_len + lang_key_len + 4)); |
if (textp->key == NULL) |
return(1); |
{ |
png_chunk_report(png_ptr, "text chunk: out of memory", |
PNG_CHUNK_WRITE_ERROR); |
return 1; |
} |
png_debug2(2, "Allocated %lu bytes at %p in png_set_text", |
(unsigned long)(png_uint_32) |
756,16 → 834,16 |
(key_len + lang_len + lang_key_len + text_length + 4), |
textp->key); |
png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len)); |
memcpy(textp->key, text_ptr[i].key, key_len); |
*(textp->key + key_len) = '\0'; |
if (text_ptr[i].compression > 0) |
{ |
textp->lang = textp->key + key_len + 1; |
png_memcpy(textp->lang, text_ptr[i].lang, lang_len); |
memcpy(textp->lang, text_ptr[i].lang, lang_len); |
*(textp->lang + lang_len) = '\0'; |
textp->lang_key = textp->lang + lang_len + 1; |
png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); |
memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); |
*(textp->lang_key + lang_key_len) = '\0'; |
textp->text = textp->lang_key + lang_key_len + 1; |
} |
778,8 → 856,7 |
} |
if (text_length) |
png_memcpy(textp->text, text_ptr[i].text, |
(png_size_t)(text_length)); |
memcpy(textp->text, text_ptr[i].text, text_length); |
*(textp->text + text_length) = '\0'; |
800,6 → 877,7 |
info_ptr->num_text++; |
png_debug1(3, "transferred text chunk %d", info_ptr->num_text); |
} |
return(0); |
} |
#endif |
806,15 → 884,25 |
#ifdef PNG_tIME_SUPPORTED |
void PNGAPI |
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time) |
png_set_tIME(png_const_structrp png_ptr, png_inforp info_ptr, |
png_const_timep mod_time) |
{ |
png_debug1(1, "in %s storage function", "tIME"); |
if (png_ptr == NULL || info_ptr == NULL || |
if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL || |
(png_ptr->mode & PNG_WROTE_tIME)) |
return; |
png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time)); |
if (mod_time->month == 0 || mod_time->month > 12 || |
mod_time->day == 0 || mod_time->day > 31 || |
mod_time->hour > 23 || mod_time->minute > 59 || |
mod_time->second > 60) |
{ |
png_warning(png_ptr, "Ignoring invalid time value"); |
return; |
} |
info_ptr->mod_time = *mod_time; |
info_ptr->valid |= PNG_INFO_tIME; |
} |
#endif |
821,7 → 909,7 |
#ifdef PNG_tRNS_SUPPORTED |
void PNGAPI |
png_set_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr, |
png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color) |
{ |
png_debug1(1, "in %s storage function", "tRNS"); |
834,16 → 922,20 |
/* It may not actually be necessary to set png_ptr->trans_alpha here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
* |
* 1.6.0: The above statement is incorrect; png_handle_tRNS effectively |
* relies on png_set_tRNS storing the information in png_struct |
* (otherwise it won't be there for the code in pngrtran.c). |
*/ |
png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); |
/* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */ |
png_ptr->trans_alpha = info_ptr->trans_alpha = |
(png_bytep)png_malloc(png_ptr, (png_size_t)PNG_MAX_PALETTE_LENGTH); |
png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep, |
png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH)); |
if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) |
png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans); |
memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans); |
} |
if (trans_color != NULL) |
851,16 → 943,15 |
int sample_max = (1 << info_ptr->bit_depth); |
if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY && |
(int)trans_color->gray > sample_max) || |
trans_color->gray > sample_max) || |
(info_ptr->color_type == PNG_COLOR_TYPE_RGB && |
((int)trans_color->red > sample_max || |
(int)trans_color->green > sample_max || |
(int)trans_color->blue > sample_max))) |
(trans_color->red > sample_max || |
trans_color->green > sample_max || |
trans_color->blue > sample_max))) |
png_warning(png_ptr, |
"tRNS chunk has out-of-range samples for bit_depth"); |
png_memcpy(&(info_ptr->trans_color), trans_color, |
png_sizeof(png_color_16)); |
info_ptr->trans_color = *trans_color; |
if (num_trans == 0) |
num_trans = 1; |
878,8 → 969,8 |
#ifdef PNG_sPLT_SUPPORTED |
void PNGAPI |
png_set_sPLT(png_structp png_ptr, |
png_infop info_ptr, png_const_sPLT_tp entries, int nentries) |
png_set_sPLT(png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_sPLT_tp entries, int nentries) |
/* |
* entries - array of png_sPLT_t structures |
* to be added to the list of palettes |
890,220 → 981,447 |
*/ |
{ |
png_sPLT_tp np; |
int i; |
if (png_ptr == NULL || info_ptr == NULL) |
if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL) |
return; |
np = (png_sPLT_tp)png_malloc_warn(png_ptr, |
(info_ptr->splt_palettes_num + nentries) * |
(png_size_t)png_sizeof(png_sPLT_t)); |
/* Use the internal realloc function, which checks for all the possible |
* overflows. Notice that the parameters are (int) and (size_t) |
*/ |
np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr, |
info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries, |
sizeof *np)); |
if (np == NULL) |
{ |
png_warning(png_ptr, "No memory for sPLT palettes"); |
/* Out of memory or too many chunks */ |
png_chunk_report(png_ptr, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR); |
return; |
} |
png_memcpy(np, info_ptr->splt_palettes, |
info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t)); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes=NULL; |
info_ptr->splt_palettes = np; |
info_ptr->free_me |= PNG_FREE_SPLT; |
for (i = 0; i < nentries; i++) |
np += info_ptr->splt_palettes_num; |
do |
{ |
png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; |
png_const_sPLT_tp from = entries + i; |
png_uint_32 length; |
png_size_t length; |
length = png_strlen(from->name) + 1; |
to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length); |
if (to->name == NULL) |
/* Skip invalid input entries */ |
if (entries->name == NULL || entries->entries == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing sPLT chunk"); |
/* png_handle_sPLT doesn't do this, so this is an app error */ |
png_app_error(png_ptr, "png_set_sPLT: invalid sPLT"); |
/* Just skip the invalid entry */ |
continue; |
} |
png_memcpy(to->name, from->name, length); |
to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr, |
(png_size_t)(from->nentries * png_sizeof(png_sPLT_entry))); |
np->depth = entries->depth; |
if (to->entries == NULL) |
/* In the even of out-of-memory just return - there's no point keeping on |
* trying to add sPLT chunks. |
*/ |
length = strlen(entries->name) + 1; |
np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length)); |
if (np->name == NULL) |
break; |
memcpy(np->name, entries->name, length); |
/* IMPORTANT: we have memory now that won't get freed if something else |
* goes wrong, this code must free it. png_malloc_array produces no |
* warnings, use a png_chunk_report (below) if there is an error. |
*/ |
np->entries = png_voidcast(png_sPLT_entryp, png_malloc_array(png_ptr, |
entries->nentries, sizeof (png_sPLT_entry))); |
if (np->entries == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing sPLT chunk"); |
png_free(png_ptr, to->name); |
to->name = NULL; |
continue; |
png_free(png_ptr, np->name); |
break; |
} |
png_memcpy(to->entries, from->entries, |
from->nentries * png_sizeof(png_sPLT_entry)); |
np->nentries = entries->nentries; |
/* This multiply can't overflow because png_malloc_array has already |
* checked it when doing the allocation. |
*/ |
memcpy(np->entries, entries->entries, |
entries->nentries * sizeof (png_sPLT_entry)); |
to->nentries = from->nentries; |
to->depth = from->depth; |
/* Note that 'continue' skips the advance of the out pointer and out |
* count, so an invalid entry is not added. |
*/ |
info_ptr->valid |= PNG_INFO_sPLT; |
++(info_ptr->splt_palettes_num); |
++np; |
} |
while (++entries, --nentries); |
info_ptr->splt_palettes = np; |
info_ptr->splt_palettes_num += nentries; |
info_ptr->valid |= PNG_INFO_sPLT; |
info_ptr->free_me |= PNG_FREE_SPLT; |
if (nentries > 0) |
png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR); |
} |
#endif /* PNG_sPLT_SUPPORTED */ |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED |
static png_byte |
check_location(png_const_structrp png_ptr, int location) |
{ |
location &= (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT); |
/* New in 1.6.0; copy the location and check it. This is an API |
* change, previously the app had to use the |
* png_set_unknown_chunk_location API below for each chunk. |
*/ |
if (location == 0 && !(png_ptr->mode & PNG_IS_READ_STRUCT)) |
{ |
/* Write struct, so unknown chunks come from the app */ |
png_app_warning(png_ptr, |
"png_set_unknown_chunks now expects a valid location"); |
/* Use the old behavior */ |
location = (png_byte)(png_ptr->mode & |
(PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)); |
} |
/* This need not be an internal error - if the app calls |
* png_set_unknown_chunks on a read pointer it must get the location right. |
*/ |
if (location == 0) |
png_error(png_ptr, "invalid location in png_set_unknown_chunks"); |
/* Now reduce the location to the top-most set bit by removing each least |
* significant bit in turn. |
*/ |
while (location != (location & -location)) |
location &= ~(location & -location); |
/* The cast is safe because 'location' is a bit mask and only the low four |
* bits are significant. |
*/ |
return (png_byte)location; |
} |
void PNGAPI |
png_set_unknown_chunks(png_structp png_ptr, |
png_infop info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns) |
png_set_unknown_chunks(png_const_structrp png_ptr, |
png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns) |
{ |
png_unknown_chunkp np; |
int i; |
if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) |
if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 || |
unknowns == NULL) |
return; |
np = (png_unknown_chunkp)png_malloc_warn(png_ptr, |
(png_size_t)(info_ptr->unknown_chunks_num + num_unknowns) * |
png_sizeof(png_unknown_chunk)); |
/* Check for the failure cases where support has been disabled at compile |
* time. This code is hardly ever compiled - it's here because |
* STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this |
* code) but may be meaningless if the read or write handling of unknown |
* chunks is not compiled in. |
*/ |
# if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \ |
defined(PNG_READ_SUPPORTED) |
if (png_ptr->mode & PNG_IS_READ_STRUCT) |
{ |
png_app_error(png_ptr, "no unknown chunk support on read"); |
return; |
} |
# endif |
# if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \ |
defined(PNG_WRITE_SUPPORTED) |
if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) |
{ |
png_app_error(png_ptr, "no unknown chunk support on write"); |
return; |
} |
# endif |
/* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that |
* unknown critical chunks could be lost with just a warning resulting in |
* undefined behavior. Now png_chunk_report is used to provide behavior |
* appropriate to read or write. |
*/ |
np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr, |
info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns, |
sizeof *np)); |
if (np == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing unknown chunk"); |
png_chunk_report(png_ptr, "too many unknown chunks", |
PNG_CHUNK_WRITE_ERROR); |
return; |
} |
png_memcpy(np, info_ptr->unknown_chunks, |
(png_size_t)info_ptr->unknown_chunks_num * |
png_sizeof(png_unknown_chunk)); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks = NULL; |
info_ptr->unknown_chunks = np; /* safe because it is initialized */ |
info_ptr->free_me |= PNG_FREE_UNKN; |
for (i = 0; i < num_unknowns; i++) |
np += info_ptr->unknown_chunks_num; |
/* Increment unknown_chunks_num each time round the loop to protect the |
* just-allocated chunk data. |
*/ |
for (; num_unknowns > 0; --num_unknowns, ++unknowns) |
{ |
png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; |
png_const_unknown_chunkp from = unknowns + i; |
memcpy(np->name, unknowns->name, (sizeof np->name)); |
np->name[(sizeof np->name)-1] = '\0'; |
np->location = check_location(png_ptr, unknowns->location); |
png_memcpy(to->name, from->name, png_sizeof(from->name)); |
to->name[png_sizeof(to->name)-1] = '\0'; |
to->size = from->size; |
if (unknowns->size == 0) |
{ |
np->data = NULL; |
np->size = 0; |
} |
/* Note our location in the read or write sequence */ |
to->location = (png_byte)(png_ptr->mode & 0xff); |
if (from->size == 0) |
to->data=NULL; |
else |
{ |
to->data = (png_bytep)png_malloc_warn(png_ptr, |
(png_size_t)from->size); |
np->data = png_voidcast(png_bytep, |
png_malloc_base(png_ptr, unknowns->size)); |
if (to->data == NULL) |
if (np->data == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing unknown chunk"); |
to->size = 0; |
png_chunk_report(png_ptr, "unknown chunk: out of memory", |
PNG_CHUNK_WRITE_ERROR); |
/* But just skip storing the unknown chunk */ |
continue; |
} |
else |
png_memcpy(to->data, from->data, from->size); |
memcpy(np->data, unknowns->data, unknowns->size); |
np->size = unknowns->size; |
} |
} |
info_ptr->unknown_chunks = np; |
info_ptr->unknown_chunks_num += num_unknowns; |
info_ptr->free_me |= PNG_FREE_UNKN; |
/* These increments are skipped on out-of-memory for the data - the |
* unknown chunk entry gets overwritten if the png_chunk_report returns. |
* This is correct in the read case (the chunk is just dropped.) |
*/ |
++np; |
++(info_ptr->unknown_chunks_num); |
} |
} |
void PNGAPI |
png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, |
png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr, |
int chunk, int location) |
{ |
if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < |
info_ptr->unknown_chunks_num) |
info_ptr->unknown_chunks[chunk].location = (png_byte)location; |
/* This API is pretty pointless in 1.6.0 because the location can be set |
* before the call to png_set_unknown_chunks. |
* |
* TODO: add a png_app_warning in 1.7 |
*/ |
if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && |
chunk < info_ptr->unknown_chunks_num) |
{ |
if ((location & (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)) == 0) |
{ |
png_app_error(png_ptr, "invalid unknown chunk location"); |
/* Fake out the pre 1.6.0 behavior: */ |
if ((location & PNG_HAVE_IDAT)) /* undocumented! */ |
location = PNG_AFTER_IDAT; |
else |
location = PNG_HAVE_IHDR; /* also undocumented */ |
} |
info_ptr->unknown_chunks[chunk].location = |
check_location(png_ptr, location); |
} |
} |
#endif |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
png_uint_32 PNGAPI |
png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) |
png_permit_mng_features (png_structrp png_ptr, png_uint_32 mng_features) |
{ |
png_debug(1, "in png_permit_mng_features"); |
if (png_ptr == NULL) |
return (png_uint_32)0; |
return 0; |
png_ptr->mng_features_permitted = |
(png_byte)(mng_features & PNG_ALL_MNG_FEATURES); |
png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES; |
return (png_uint_32)png_ptr->mng_features_permitted; |
return png_ptr->mng_features_permitted; |
} |
#endif |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
static unsigned int |
add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep) |
{ |
unsigned int i; |
/* Utility function: update the 'keep' state of a chunk if it is already in |
* the list, otherwise add it to the list. |
*/ |
for (i=0; i<count; ++i, list += 5) if (memcmp(list, add, 4) == 0) |
{ |
list[4] = (png_byte)keep; |
return count; |
} |
if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT) |
{ |
++count; |
memcpy(list, add, 4); |
list[4] = (png_byte)keep; |
} |
return count; |
} |
void PNGAPI |
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_const_bytep |
chunk_list, int num_chunks) |
png_set_keep_unknown_chunks(png_structrp png_ptr, int keep, |
png_const_bytep chunk_list, int num_chunks_in) |
{ |
png_bytep new_list, p; |
int i, old_num_chunks; |
png_bytep new_list; |
unsigned int num_chunks, old_num_chunks; |
if (png_ptr == NULL) |
return; |
if (num_chunks == 0) |
if (keep < 0 || keep >= PNG_HANDLE_CHUNK_LAST) |
{ |
if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) |
png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
png_app_error(png_ptr, "png_set_keep_unknown_chunks: invalid keep"); |
return; |
} |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
if (num_chunks_in <= 0) |
{ |
png_ptr->unknown_default = keep; |
if (keep == PNG_HANDLE_CHUNK_ALWAYS) |
png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
/* '0' means just set the flags, so stop here */ |
if (num_chunks_in == 0) |
return; |
} |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
if (num_chunks_in < 0) |
{ |
/* Ignore all unknown chunks and all chunks recognized by |
* libpng except for IHDR, PLTE, tRNS, IDAT, and IEND |
*/ |
static PNG_CONST png_byte chunks_to_ignore[] = { |
98, 75, 71, 68, '\0', /* bKGD */ |
99, 72, 82, 77, '\0', /* cHRM */ |
103, 65, 77, 65, '\0', /* gAMA */ |
104, 73, 83, 84, '\0', /* hIST */ |
105, 67, 67, 80, '\0', /* iCCP */ |
105, 84, 88, 116, '\0', /* iTXt */ |
111, 70, 70, 115, '\0', /* oFFs */ |
112, 67, 65, 76, '\0', /* pCAL */ |
112, 72, 89, 115, '\0', /* pHYs */ |
115, 66, 73, 84, '\0', /* sBIT */ |
115, 67, 65, 76, '\0', /* sCAL */ |
115, 80, 76, 84, '\0', /* sPLT */ |
115, 84, 69, 82, '\0', /* sTER */ |
115, 82, 71, 66, '\0', /* sRGB */ |
116, 69, 88, 116, '\0', /* tEXt */ |
116, 73, 77, 69, '\0', /* tIME */ |
122, 84, 88, 116, '\0' /* zTXt */ |
}; |
return; |
chunk_list = chunks_to_ignore; |
num_chunks = (sizeof chunks_to_ignore)/5; |
} |
else /* num_chunks_in > 0 */ |
{ |
if (chunk_list == NULL) |
{ |
/* Prior to 1.6.0 this was silently ignored, now it is an app_error |
* which can be switched off. |
*/ |
png_app_error(png_ptr, "png_set_keep_unknown_chunks: no chunk list"); |
return; |
} |
num_chunks = num_chunks_in; |
} |
old_num_chunks = png_ptr->num_chunk_list; |
new_list=(png_bytep)png_malloc(png_ptr, |
(png_size_t)(5*(num_chunks + old_num_chunks))); |
if (png_ptr->chunk_list == NULL) |
old_num_chunks = 0; |
if (png_ptr->chunk_list != NULL) |
/* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow. |
*/ |
if (num_chunks + old_num_chunks > UINT_MAX/5) |
{ |
png_memcpy(new_list, png_ptr->chunk_list, |
(png_size_t)(5*old_num_chunks)); |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
png_app_error(png_ptr, "png_set_keep_unknown_chunks: too many chunks"); |
return; |
} |
png_memcpy(new_list + 5*old_num_chunks, chunk_list, |
(png_size_t)(5*num_chunks)); |
/* If these chunks are being reset to the default then no more memory is |
* required because add_one_chunk above doesn't extend the list if the 'keep' |
* parameter is the default. |
*/ |
if (keep) |
{ |
new_list = png_voidcast(png_bytep, png_malloc(png_ptr, |
5 * (num_chunks + old_num_chunks))); |
for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5) |
*p=(png_byte)keep; |
if (old_num_chunks > 0) |
memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks); |
} |
png_ptr->num_chunk_list = old_num_chunks + num_chunks; |
else if (old_num_chunks > 0) |
new_list = png_ptr->chunk_list; |
else |
new_list = NULL; |
/* Add the new chunks together with each one's handling code. If the chunk |
* already exists the code is updated, otherwise the chunk is added to the |
* end. (In libpng 1.6.0 order no longer matters because this code enforces |
* the earlier convention that the last setting is the one that is used.) |
*/ |
if (new_list != NULL) |
{ |
png_const_bytep inlist; |
png_bytep outlist; |
unsigned int i; |
for (i=0; i<num_chunks; ++i) |
old_num_chunks = add_one_chunk(new_list, old_num_chunks, |
chunk_list+5*i, keep); |
/* Now remove any spurious 'default' entries. */ |
num_chunks = 0; |
for (i=0, inlist=outlist=new_list; i<old_num_chunks; ++i, inlist += 5) |
if (inlist[4]) |
{ |
if (outlist != inlist) |
memcpy(outlist, inlist, 5); |
outlist += 5; |
++num_chunks; |
} |
/* This means the application has removed all the specialized handling. */ |
if (num_chunks == 0) |
{ |
if (png_ptr->chunk_list != new_list) |
png_free(png_ptr, new_list); |
new_list = NULL; |
} |
} |
else |
num_chunks = 0; |
png_ptr->num_chunk_list = num_chunks; |
if (png_ptr->chunk_list != new_list) |
{ |
if (png_ptr->chunk_list != NULL) |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list = new_list; |
png_ptr->free_me |= PNG_FREE_LIST; |
} |
} |
#endif |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
void PNGAPI |
png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, |
png_set_read_user_chunk_fn(png_structrp png_ptr, png_voidp user_chunk_ptr, |
png_user_chunk_ptr read_user_chunk_fn) |
{ |
png_debug(1, "in png_set_read_user_chunk_fn"); |
1118,7 → 1436,8 |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
void PNGAPI |
png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) |
png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr, |
png_bytepp row_pointers) |
{ |
png_debug1(1, "in %s storage function", "rows"); |
1136,35 → 1455,60 |
#endif |
void PNGAPI |
png_set_compression_buffer_size(png_structp png_ptr, png_size_t size) |
png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size) |
{ |
if (png_ptr == NULL) |
return; |
png_free(png_ptr, png_ptr->zbuf); |
if (size == 0 || size > PNG_UINT_31_MAX) |
png_error(png_ptr, "invalid compression buffer size"); |
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
if (png_ptr->mode & PNG_IS_READ_STRUCT) |
{ |
png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */ |
return; |
} |
# endif |
# ifdef PNG_WRITE_SUPPORTED |
if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) |
{ |
if (png_ptr->zowner != 0) |
{ |
png_warning(png_ptr, |
"Compression buffer size cannot be changed because it is in use"); |
return; |
} |
if (size > ZLIB_IO_MAX) |
{ |
png_warning(png_ptr, "Attempt to set buffer size beyond max ignored"); |
png_ptr->zbuf_size = ZLIB_IO_MAX; |
png_warning(png_ptr, |
"Compression buffer size limited to system maximum"); |
size = ZLIB_IO_MAX; /* must fit */ |
} |
else |
png_ptr->zbuf_size = (uInt)size; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); |
/* The following ensures a relatively safe failure if this gets called while |
* the buffer is actually in use. |
else if (size < 6) |
{ |
/* Deflate will potentially go into an infinite loop on a SYNC_FLUSH |
* if this is permitted. |
*/ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = 0; |
png_ptr->zstream.avail_in = 0; |
png_warning(png_ptr, |
"Compression buffer size cannot be reduced below 6"); |
return; |
} |
if (png_ptr->zbuffer_size != size) |
{ |
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list); |
png_ptr->zbuffer_size = (uInt)size; |
} |
} |
# endif |
} |
void PNGAPI |
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) |
png_set_invalid(png_const_structrp png_ptr, png_inforp info_ptr, int mask) |
{ |
if (png_ptr && info_ptr) |
info_ptr->valid &= ~mask; |
1171,11 → 1515,10 |
} |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
/* This function was added to libpng 1.2.6 */ |
void PNGAPI |
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, |
png_set_user_limits (png_structrp png_ptr, png_uint_32 user_width_max, |
png_uint_32 user_height_max) |
{ |
/* Images with dimensions larger than these limits will be |
1191,8 → 1534,7 |
/* This function was added to libpng 1.4.0 */ |
void PNGAPI |
png_set_chunk_cache_max (png_structp png_ptr, |
png_uint_32 user_chunk_cache_max) |
png_set_chunk_cache_max (png_structrp png_ptr, png_uint_32 user_chunk_cache_max) |
{ |
if (png_ptr) |
png_ptr->user_chunk_cache_max = user_chunk_cache_max; |
1200,7 → 1542,7 |
/* This function was added to libpng 1.4.1 */ |
void PNGAPI |
png_set_chunk_malloc_max (png_structp png_ptr, |
png_set_chunk_malloc_max (png_structrp png_ptr, |
png_alloc_size_t user_chunk_malloc_max) |
{ |
if (png_ptr) |
1211,15 → 1553,45 |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_set_benign_errors(png_structp png_ptr, int allowed) |
png_set_benign_errors(png_structrp png_ptr, int allowed) |
{ |
png_debug(1, "in png_set_benign_errors"); |
/* If allowed is 1, png_benign_error() is treated as a warning. |
* |
* If allowed is 0, png_benign_error() is treated as an error (which |
* is the default behavior if png_set_benign_errors() is not called). |
*/ |
if (allowed) |
png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; |
png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN | |
PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN; |
else |
png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN; |
png_ptr->flags &= ~(PNG_FLAG_BENIGN_ERRORS_WARN | |
PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN); |
} |
#endif /* PNG_BENIGN_ERRORS_SUPPORTED */ |
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
/* Whether to report invalid palette index; added at libng-1.5.10. |
* It is possible for an indexed (color-type==3) PNG file to contain |
* pixels with invalid (out-of-range) indexes if the PLTE chunk has |
* fewer entries than the image's bit-depth would allow. We recover |
* from this gracefully by filling any incomplete palette with zeroes |
* (opaque black). By default, when this occurs libpng will issue |
* a benign error. This API can be used to override that behavior. |
*/ |
void PNGAPI |
png_set_check_for_invalid_index(png_structrp png_ptr, int allowed) |
{ |
png_debug(1, "in png_set_check_for_invalid_index"); |
if (allowed > 0) |
png_ptr->num_palette_max = 0; |
else |
png_ptr->num_palette_max = -1; |
} |
#endif |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngstruct.h |
---|
1,11 → 1,11 |
/* pngstruct.h - header file for PNG reference library |
* |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Last changed in libpng 1.6.1 [March 28, 2013] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
24,16 → 24,135 |
* in this structure and is required for decompressing the LZ compressed |
* data in PNG files. |
*/ |
#ifndef ZLIB_CONST |
/* We must ensure that zlib uses 'const' in declarations. */ |
# define ZLIB_CONST |
#endif |
#include "zlib.h" |
#ifdef const |
/* zlib.h sometimes #defines const to nothing, undo this. */ |
# undef const |
#endif |
/* zlib.h has mediocre z_const use before 1.2.6, this stuff is for compatibility |
* with older builds. |
*/ |
#if ZLIB_VERNUM < 0x1260 |
# define PNGZ_MSG_CAST(s) png_constcast(char*,s) |
# define PNGZ_INPUT_CAST(b) png_constcast(png_bytep,b) |
#else |
# define PNGZ_MSG_CAST(s) (s) |
# define PNGZ_INPUT_CAST(b) (b) |
#endif |
/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib |
* can handle at once. This type need be no larger than 16 bits (so maximum of |
* 65535), this define allows us to discover how big it is, but limited by the |
* maximuum for png_size_t. The value can be overriden in a library build |
* (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably |
* lower value (e.g. 255 works). A lower value may help memory usage (slightly) |
* and may even improve performance on some systems (and degrade it on others.) |
*/ |
#ifndef ZLIB_IO_MAX |
# define ZLIB_IO_MAX ((uInt)-1) |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
/* The type of a compression buffer list used by the write code. */ |
typedef struct png_compression_buffer |
{ |
struct png_compression_buffer *next; |
png_byte output[1]; /* actually zbuf_size */ |
} png_compression_buffer, *png_compression_bufferp; |
#define PNG_COMPRESSION_BUFFER_SIZE(pp)\ |
(offsetof(png_compression_buffer, output) + (pp)->zbuffer_size) |
#endif |
/* Colorspace support; structures used in png_struct, png_info and in internal |
* functions to hold and communicate information about the color space. |
* |
* PNG_COLORSPACE_SUPPORTED is only required if the application will perform |
* colorspace corrections, otherwise all the colorspace information can be |
* skipped and the size of libpng can be reduced (significantly) by compiling |
* out the colorspace support. |
*/ |
#ifdef PNG_COLORSPACE_SUPPORTED |
/* The chromaticities of the red, green and blue colorants and the chromaticity |
* of the corresponding white point (i.e. of rgb(1.0,1.0,1.0)). |
*/ |
typedef struct png_xy |
{ |
png_fixed_point redx, redy; |
png_fixed_point greenx, greeny; |
png_fixed_point bluex, bluey; |
png_fixed_point whitex, whitey; |
} png_xy; |
/* The same data as above but encoded as CIE XYZ values. When this data comes |
* from chromaticities the sum of the Y values is assumed to be 1.0 |
*/ |
typedef struct png_XYZ |
{ |
png_fixed_point red_X, red_Y, red_Z; |
png_fixed_point green_X, green_Y, green_Z; |
png_fixed_point blue_X, blue_Y, blue_Z; |
} png_XYZ; |
#endif /* COLORSPACE */ |
#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED) |
/* A colorspace is all the above plus, potentially, profile information, |
* however at present libpng does not use the profile internally so it is only |
* stored in the png_info struct (if iCCP is supported.) The rendering intent |
* is retained here and is checked. |
* |
* The file gamma encoding information is also stored here and gamma correction |
* is done by libpng, whereas color correction must currently be done by the |
* application. |
*/ |
typedef struct png_colorspace |
{ |
#ifdef PNG_GAMMA_SUPPORTED |
png_fixed_point gamma; /* File gamma */ |
#endif |
#ifdef PNG_COLORSPACE_SUPPORTED |
png_xy end_points_xy; /* End points as chromaticities */ |
png_XYZ end_points_XYZ; /* End points as CIE XYZ colorant values */ |
png_uint_16 rendering_intent; /* Rendering intent of a profile */ |
#endif |
/* Flags are always defined to simplify the code. */ |
png_uint_16 flags; /* As defined below */ |
} png_colorspace, * PNG_RESTRICT png_colorspacerp; |
typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp; |
/* General flags for the 'flags' field */ |
#define PNG_COLORSPACE_HAVE_GAMMA 0x0001 |
#define PNG_COLORSPACE_HAVE_ENDPOINTS 0x0002 |
#define PNG_COLORSPACE_HAVE_INTENT 0x0004 |
#define PNG_COLORSPACE_FROM_gAMA 0x0008 |
#define PNG_COLORSPACE_FROM_cHRM 0x0010 |
#define PNG_COLORSPACE_FROM_sRGB 0x0020 |
#define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0040 |
#define PNG_COLORSPACE_MATCHES_sRGB 0x0080 /* exact match on profile */ |
#define PNG_COLORSPACE_INVALID 0x8000 |
#define PNG_COLORSPACE_CANCEL(flags) (0xffff ^ (flags)) |
#endif /* COLORSPACE || GAMMA */ |
struct png_struct_def |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf png_jmpbuf; /* used in png_error */ |
jmp_buf jmp_buf_local; /* New name in 1.6.0 for jmp_buf in png_struct */ |
png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */ |
jmp_buf *jmp_buf_ptr; /* passed to longjmp_fn */ |
size_t jmp_buf_size; /* size of the above, if allocated */ |
#endif |
png_error_ptr error_fn; /* function for printing errors and aborting */ |
#ifdef PNG_WARNINGS_SUPPORTED |
png_error_ptr warning_fn; /* function for printing warnings */ |
#endif |
png_voidp error_ptr; /* user supplied struct for error functions */ |
png_rw_ptr write_data_fn; /* function for writing output data */ |
png_rw_ptr read_data_fn; /* function for reading input data */ |
61,14 → 180,36 |
png_uint_32 flags; /* flags indicating various things to libpng */ |
png_uint_32 transformations; /* which transformations to perform */ |
z_stream zstream; /* pointer to decompression structure (below) */ |
png_bytep zbuf; /* buffer for zlib */ |
uInt zbuf_size; /* size of zbuf (typically 65536) */ |
png_uint_32 zowner; /* ID (chunk type) of zstream owner, 0 if none */ |
z_stream zstream; /* decompression structure */ |
#ifdef PNG_WRITE_SUPPORTED |
png_compression_bufferp zbuffer_list; /* Created on demand during write */ |
uInt zbuffer_size; /* size of the actual buffer */ |
int zlib_level; /* holds zlib compression level */ |
int zlib_method; /* holds zlib compression method */ |
int zlib_window_bits; /* holds zlib compression window bits */ |
int zlib_mem_level; /* holds zlib compression memory level */ |
int zlib_strategy; /* holds zlib compression strategy */ |
#endif |
/* Added at libpng 1.5.4 */ |
#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED |
int zlib_text_level; /* holds zlib compression level */ |
int zlib_text_method; /* holds zlib compression method */ |
int zlib_text_window_bits; /* holds zlib compression window bits */ |
int zlib_text_mem_level; /* holds zlib compression memory level */ |
int zlib_text_strategy; /* holds zlib compression strategy */ |
#endif |
/* End of material added at libpng 1.5.4 */ |
/* Added at libpng 1.6.0 */ |
#ifdef PNG_WRITE_SUPPORTED |
int zlib_set_level; /* Actual values set into the zstream on write */ |
int zlib_set_method; |
int zlib_set_window_bits; |
int zlib_set_mem_level; |
int zlib_set_strategy; |
#endif |
png_uint_32 width; /* width of image in pixels */ |
png_uint_32 height; /* height of image in pixels */ |
77,20 → 218,32 |
png_size_t rowbytes; /* size of row in bytes */ |
png_uint_32 iwidth; /* width of current interlaced row in pixels */ |
png_uint_32 row_number; /* current row in interlace pass */ |
png_bytep prev_row; /* buffer to save previous (unfiltered) row */ |
png_bytep row_buf; /* buffer to save current (unfiltered) row */ |
png_uint_32 chunk_name; /* PNG_CHUNK() id of current chunk */ |
png_bytep prev_row; /* buffer to save previous (unfiltered) row. |
* This is a pointer into big_prev_row |
*/ |
png_bytep row_buf; /* buffer to save current (unfiltered) row. |
* This is a pointer into big_row_buf |
*/ |
#ifdef PNG_WRITE_SUPPORTED |
png_bytep sub_row; /* buffer to save "sub" row when filtering */ |
png_bytep up_row; /* buffer to save "up" row when filtering */ |
png_bytep avg_row; /* buffer to save "avg" row when filtering */ |
png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ |
png_row_info row_info; /* used for transformation routines */ |
#endif |
png_size_t info_rowbytes; /* Added in 1.5.4: cache of updated row bytes */ |
png_uint_32 idat_size; /* current IDAT size for read */ |
png_uint_32 crc; /* current chunk CRC value */ |
png_colorp palette; /* palette from the input file */ |
png_uint_16 num_palette; /* number of color entries in palette */ |
/* Added at libpng-1.5.10 */ |
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED |
int num_palette_max; /* maximum palette index found in IDAT */ |
#endif |
png_uint_16 num_trans; /* number of transparency values */ |
png_byte chunk_name[5]; /* null-terminated name of current chunk */ |
png_byte compression; /* file compression type (always 0) */ |
png_byte filter; /* file filter type (always 0) */ |
png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
98,17 → 251,23 |
png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ |
png_byte color_type; /* color type of file */ |
png_byte bit_depth; /* bit depth of file */ |
png_byte usr_bit_depth; /* bit depth of users row */ |
png_byte usr_bit_depth; /* bit depth of users row: write only */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte channels; /* number of channels in file */ |
png_byte usr_channels; /* channels at start of write */ |
#ifdef PNG_WRITE_SUPPORTED |
png_byte usr_channels; /* channels at start of write: write only */ |
#endif |
png_byte sig_bytes; /* magic bytes read/written from start of file */ |
png_byte maximum_pixel_depth; |
/* pixel depth used for the row buffers */ |
png_byte transformed_pixel_depth; |
/* pixel depth after read/write transforms */ |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
png_uint_16 filler; /* filler bytes for pixel expansion */ |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) |
png_byte background_gamma_type; |
png_fixed_point background_gamma; |
png_color_16 background; /* background color in screen gamma space */ |
123,19 → 282,20 |
png_uint_32 flush_rows; /* number of rows written since last flush */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
#ifdef PNG_READ_GAMMA_SUPPORTED |
int gamma_shift; /* number of "insignificant" bits in 16-bit gamma */ |
png_fixed_point gamma; /* file gamma value */ |
png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_bytep gamma_table; /* gamma table for 8-bit depth files */ |
png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_bytep gamma_from_1; /* converts from 1.0 to screen */ |
png_bytep gamma_to_1; /* converts from file to 1.0 */ |
png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ |
png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ |
png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ |
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) |
171,13 → 331,6 |
int process_mode; /* what push library is currently doing */ |
int cur_palette; /* current push library palette index */ |
# ifdef PNG_TEXT_SUPPORTED |
png_size_t current_text_size; /* current size of text input data */ |
png_size_t current_text_left; /* how much text left to read in input */ |
png_charp current_text; /* current text chunk buffer */ |
png_charp current_text_ptr; /* current location in current_text */ |
# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
194,10 → 347,6 |
png_bytep quantize_index; /* index translation for palette files */ |
#endif |
#if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED) |
png_uint_16p hist; /* histogram */ |
#endif |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
png_byte heuristic_method; /* heuristic for row filter selection */ |
png_byte num_prev_filters; /* number of weights for previous rows */ |
208,9 → 357,17 |
png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ |
#endif |
/* Options */ |
#ifdef PNG_SET_OPTION_SUPPORTED |
png_byte options; /* On/off state (up to 4 options) */ |
#endif |
#if PNG_LIBPNG_VER < 10700 |
/* To do: remove this from libpng-1.7 */ |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
png_charp time_buffer; /* String to hold RFC 1123 time text */ |
char time_buffer[29]; /* String to hold RFC 1123 time text */ |
#endif |
#endif |
/* New members added in libpng-1.0.6 */ |
218,27 → 375,31 |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
png_voidp user_chunk_ptr; |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ |
#endif |
#endif |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int num_chunk_list; |
png_bytep chunk_list; |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
int unknown_default; /* As PNG_HANDLE_* */ |
unsigned int num_chunk_list; /* Number of entries in the list */ |
png_bytep chunk_list; /* List of png_byte[5]; the textual chunk name |
* followed by a PNG_HANDLE_* byte */ |
#endif |
/* New members added in libpng-1.0.3 */ |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
png_byte rgb_to_gray_status; |
/* Added in libpng 1.5.5 to record setting of coefficients: */ |
png_byte rgb_to_gray_coefficients_set; |
/* These were changed from png_byte in libpng-1.0.6 */ |
png_uint_16 rgb_to_gray_red_coeff; |
png_uint_16 rgb_to_gray_green_coeff; |
png_uint_16 rgb_to_gray_blue_coeff; |
/* deleted in 1.5.5: rgb_to_gray_blue_coeff; */ |
#endif |
/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ |
defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* Changed from png_byte to png_uint_32 at version 1.2.0 */ |
png_uint_32 mng_features_permitted; |
#endif |
288,21 → 449,41 |
#endif |
/* New member added in libpng-1.0.25 and 1.2.17 */ |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
/* Storage for unknown chunk that the library doesn't recognize. */ |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
/* Temporary storage for unknown chunk that the library doesn't recognize, |
* used while reading the chunk. |
*/ |
png_unknown_chunk unknown_chunk; |
#endif |
/* New members added in libpng-1.2.26 */ |
/* New member added in libpng-1.2.26 */ |
png_size_t old_big_row_buf_size; |
png_size_t old_prev_row_size; |
#ifdef PNG_READ_SUPPORTED |
/* New member added in libpng-1.2.30 */ |
png_charp chunkdata; /* buffer for reading chunk data */ |
png_bytep read_buffer; /* buffer for reading chunk data */ |
png_alloc_size_t read_buffer_size; /* current size of the buffer */ |
#endif |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
uInt IDAT_read_size; /* limit on read buffer size for IDAT */ |
#endif |
#ifdef PNG_IO_STATE_SUPPORTED |
/* New member added in libpng-1.4.0 */ |
png_uint_32 io_state; |
#endif |
/* New member added in libpng-1.5.6 */ |
png_bytep big_prev_row; |
/* New member added in libpng-1.5.7 */ |
void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info, |
png_bytep row, png_const_bytep prev_row); |
#ifdef PNG_READ_SUPPORTED |
#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED) |
png_colorspace colorspace; |
#endif |
#endif |
}; |
#endif /* PNGSTRUCT_H */ |
/programs/develop/libraries/libpng/pngtrans.c |
---|
1,8 → 1,8 |
/* pngtrans.c - transforms the data in a row (used by both readers and writers) |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.2 [April 25, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
18,7 → 18,7 |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* Turn on BGR-to-RGB mapping */ |
void PNGAPI |
png_set_bgr(png_structp png_ptr) |
png_set_bgr(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_bgr"); |
32,7 → 32,7 |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* Turn on 16 bit byte swapping */ |
void PNGAPI |
png_set_swap(png_structp png_ptr) |
png_set_swap(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_swap"); |
47,7 → 47,7 |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* Turn on pixel packing */ |
void PNGAPI |
png_set_packing(png_structp png_ptr) |
png_set_packing(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_packing"); |
65,7 → 65,7 |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* Turn on packed pixel swapping */ |
void PNGAPI |
png_set_packswap(png_structp png_ptr) |
png_set_packswap(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_packswap"); |
79,7 → 79,7 |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
void PNGAPI |
png_set_shift(png_structp png_ptr, png_const_color_8p true_bits) |
png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits) |
{ |
png_debug(1, "in png_set_shift"); |
94,7 → 94,7 |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
int PNGAPI |
png_set_interlace_handling(png_structp png_ptr) |
png_set_interlace_handling(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_interlace handling"); |
115,7 → 115,7 |
* that don't like bytes as parameters. |
*/ |
void PNGAPI |
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) |
png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc) |
{ |
png_debug(1, "in png_set_filler"); |
122,37 → 122,84 |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_FILLER; |
/* In libpng 1.6 it is possible to determine whether this is a read or write |
* operation and therefore to do more checking here for a valid call. |
*/ |
if (png_ptr->mode & PNG_IS_READ_STRUCT) |
{ |
# ifdef PNG_READ_FILLER_SUPPORTED |
/* On read png_set_filler is always valid, regardless of the base PNG |
* format, because other transformations can give a format where the |
* filler code can execute (basically an 8 or 16-bit component RGB or G |
* format.) |
* |
* NOTE: usr_channels is not used by the read code! (This has led to |
* confusion in the past.) The filler is only used in the read code. |
*/ |
png_ptr->filler = (png_uint_16)filler; |
# else |
png_app_error(png_ptr, "png_set_filler not supported on read"); |
PNG_UNUSED(filler) /* not used in the write case */ |
return; |
# endif |
} |
if (filler_loc == PNG_FILLER_AFTER) |
png_ptr->flags |= PNG_FLAG_FILLER_AFTER; |
else |
png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; |
/* This should probably go in the "do_read_filler" routine. |
* I attempted to do that in libpng-1.0.1a but that caused problems |
* so I restored it in libpng-1.0.2a |
else /* write */ |
{ |
# ifdef PNG_WRITE_FILLER_SUPPORTED |
/* On write the usr_channels parameter must be set correctly at the |
* start to record the number of channels in the app-supplied data. |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
switch (png_ptr->color_type) |
{ |
case PNG_COLOR_TYPE_RGB: |
png_ptr->usr_channels = 4; |
} |
break; |
/* Also I added this in libpng-1.0.2a (what happens when we expand |
* a less-than-8-bit grayscale to GA?) */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) |
case PNG_COLOR_TYPE_GRAY: |
if (png_ptr->bit_depth >= 8) |
{ |
png_ptr->usr_channels = 2; |
break; |
} |
else |
{ |
/* There simply isn't any code in libpng to strip out bits |
* from bytes when the components are less than a byte in |
* size! |
*/ |
png_app_error(png_ptr, |
"png_set_filler is invalid for low bit depth gray output"); |
return; |
} |
default: |
png_app_error(png_ptr, |
"png_set_filler: inappropriate color type"); |
return; |
} |
# else |
png_app_error(png_ptr, "png_set_filler not supported on write"); |
return; |
# endif |
} |
/* Here on success - libpng supports the operation, set the transformation |
* and the flag to say where the filler channel is. |
*/ |
png_ptr->transformations |= PNG_FILLER; |
if (filler_loc == PNG_FILLER_AFTER) |
png_ptr->flags |= PNG_FLAG_FILLER_AFTER; |
else |
png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; |
} |
/* Added to libpng-1.2.7 */ |
void PNGAPI |
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) |
png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc) |
{ |
png_debug(1, "in png_set_add_alpha"); |
160,6 → 207,8 |
return; |
png_set_filler(png_ptr, filler, filler_loc); |
/* The above may fail to do anything. */ |
if (png_ptr->transformations & PNG_FILLER) |
png_ptr->transformations |= PNG_ADD_ALPHA; |
} |
168,7 → 217,7 |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_swap_alpha(png_structp png_ptr) |
png_set_swap_alpha(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_swap_alpha"); |
182,7 → 231,7 |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_invert_alpha(png_structp png_ptr) |
png_set_invert_alpha(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_invert_alpha"); |
195,7 → 244,7 |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
void PNGAPI |
png_set_invert_mono(png_structp png_ptr) |
png_set_invert_mono(png_structrp png_ptr) |
{ |
png_debug(1, "in png_set_invert_mono"); |
424,171 → 473,120 |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
/* Remove filler or alpha byte(s) */ |
/* Remove a channel - this used to be 'png_do_strip_filler' but it used a |
* somewhat weird combination of flags to determine what to do. All the calls |
* to png_do_strip_filler are changed in 1.5.2 to call this instead with the |
* correct arguments. |
* |
* The routine isn't general - the channel must be the channel at the start or |
* end (not in the middle) of each pixel. |
*/ |
void /* PRIVATE */ |
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) |
png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start) |
{ |
png_debug(1, "in png_do_strip_filler"); |
png_bytep sp = row; /* source pointer */ |
png_bytep dp = row; /* destination pointer */ |
png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */ |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 row_width = row_info->width; |
png_uint_32 i; |
/* At the start sp will point to the first byte to copy and dp to where |
* it is copied to. ep always points just beyond the end of the row, so |
* the loop simply copies (channels-1) channels until sp reaches ep. |
* |
* at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc. |
* nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc. |
*/ |
if ((row_info->color_type == PNG_COLOR_TYPE_RGB || |
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
(flags & PNG_FLAG_STRIP_ALPHA))) && |
row_info->channels == 4) |
/* GA, GX, XG cases */ |
if (row_info->channels == 2) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from RGBX or RGBA to RGB */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
dp += 3; sp += 4; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp++; |
} |
} |
if (at_start) /* Skip initial filler */ |
++sp; |
else /* Skip initial channel and, for sp, the filler */ |
sp += 2, ++dp; |
/* This converts from XRGB or ARGB to RGB */ |
else |
{ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
/* For a 1 pixel wide image there is nothing to do */ |
while (sp < ep) |
*dp++ = *sp, sp += 2; |
row_info->pixel_depth = 8; |
} |
} |
row_info->pixel_depth = 24; |
row_info->rowbytes = row_width * 3; |
} |
else /* if (row_info->bit_depth == 16) */ |
else if (row_info->bit_depth == 16) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ |
sp += 8; dp += 6; |
for (i = 1; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
if (at_start) /* Skip initial filler */ |
sp += 2; |
else /* Skip initial channel and, for sp, the filler */ |
sp += 4, dp += 2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp += 2; |
while (sp < ep) |
*dp++ = *sp++, *dp++ = *sp, sp += 3; |
row_info->pixel_depth = 16; |
} |
} |
else |
{ |
/* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ |
for (i = 0; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
return; /* bad bit depth */ |
sp += 2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->channels = 1; |
row_info->pixel_depth = 48; |
row_info->rowbytes = row_width * 6; |
/* Finally fix the color type if it records an alpha channel */ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
row_info->color_type = PNG_COLOR_TYPE_GRAY; |
} |
row_info->channels = 3; |
} |
else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY || |
(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
(flags & PNG_FLAG_STRIP_ALPHA))) && |
row_info->channels == 2) |
/* RGBA, RGBX, XRGB cases */ |
else if (row_info->channels == 4) |
{ |
if (row_info->bit_depth == 8) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from GX or GA to G */ |
for (i = 0; i < row_width; i++) |
{ |
*dp++ = *sp++; |
sp++; |
} |
} |
if (at_start) /* Skip initial filler */ |
++sp; |
else /* Skip initial channels and, for sp, the filler */ |
sp += 4, dp += 3; |
else |
{ |
/* This converts from XG or AG to G */ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
} |
} |
/* Note that the loop adds 3 to dp and 4 to sp each time. */ |
while (sp < ep) |
*dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
row_info->pixel_depth = 24; |
} |
else /* if (row_info->bit_depth == 16) */ |
else if (row_info->bit_depth == 16) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from GGXX or GGAA to GG */ |
sp += 4; dp += 2; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
if (at_start) /* Skip initial filler */ |
sp += 2; |
} |
} |
else /* Skip initial channels and, for sp, the filler */ |
sp += 8, dp += 6; |
else |
while (sp < ep) |
{ |
/* This converts from XXGG or AAGG to GG */ |
for (i = 0; i < row_width; i++) |
{ |
sp += 2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
/* Copy 6 bytes, skip 2 */ |
*dp++ = *sp++, *dp++ = *sp++; |
*dp++ = *sp++, *dp++ = *sp++; |
*dp++ = *sp++, *dp++ = *sp, sp += 3; |
} |
row_info->pixel_depth = 48; |
} |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
else |
return; /* bad bit depth */ |
row_info->channels = 3; |
/* Finally fix the color type if it records an alpha channel */ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
row_info->color_type = PNG_COLOR_TYPE_RGB; |
} |
row_info->channels = 1; |
} |
if (flags & PNG_FLAG_STRIP_ALPHA) |
row_info->color_type = (png_byte)(row_info->color_type & |
~PNG_COLOR_MASK_ALPHA); |
else |
return; /* The filler channel has gone already */ |
/* Fix the rowbytes value. */ |
row_info->rowbytes = dp-row; |
} |
} |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
670,11 → 668,114 |
} |
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ |
#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ |
defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) |
/* Added at libpng-1.5.10 */ |
void /* PRIVATE */ |
png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info) |
{ |
if (png_ptr->num_palette < (1 << row_info->bit_depth) && |
png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */ |
{ |
/* Calculations moved outside switch in an attempt to stop different |
* compiler warnings. 'padding' is in *bits* within the last byte, it is |
* an 'int' because pixel_depth becomes an 'int' in the expression below, |
* and this calculation is used because it avoids warnings that other |
* forms produced on either GCC or MSVC. |
*/ |
int padding = (-row_info->pixel_depth * row_info->width) & 7; |
png_bytep rp = png_ptr->row_buf + row_info->rowbytes; |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
/* in this case, all bytes must be 0 so we don't need |
* to unpack the pixels except for the rightmost one. |
*/ |
for (; rp > png_ptr->row_buf; rp--) |
{ |
if (*rp >> padding != 0) |
png_ptr->num_palette_max = 1; |
padding = 0; |
} |
break; |
} |
case 2: |
{ |
for (; rp > png_ptr->row_buf; rp--) |
{ |
int i = ((*rp >> padding) & 0x03); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
i = (((*rp >> padding) >> 2) & 0x03); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
i = (((*rp >> padding) >> 4) & 0x03); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
i = (((*rp >> padding) >> 6) & 0x03); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
padding = 0; |
} |
break; |
} |
case 4: |
{ |
for (; rp > png_ptr->row_buf; rp--) |
{ |
int i = ((*rp >> padding) & 0x0f); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
i = (((*rp >> padding) >> 4) & 0x0f); |
if (i > png_ptr->num_palette_max) |
png_ptr->num_palette_max = i; |
padding = 0; |
} |
break; |
} |
case 8: |
{ |
for (; rp > png_ptr->row_buf; rp--) |
{ |
if (*rp > png_ptr->num_palette_max) |
png_ptr->num_palette_max = (int) *rp; |
} |
break; |
} |
default: |
break; |
} |
} |
} |
#endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
void PNGAPI |
png_set_user_transform_info(png_structp png_ptr, png_voidp |
png_set_user_transform_info(png_structrp png_ptr, png_voidp |
user_transform_ptr, int user_transform_depth, int user_transform_channels) |
{ |
png_debug(1, "in png_set_user_transform_info"); |
681,6 → 782,17 |
if (png_ptr == NULL) |
return; |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && |
(png_ptr->flags & PNG_FLAG_ROW_INIT) != 0) |
{ |
png_app_error(png_ptr, |
"info change after png_start_read_image or png_read_update_info"); |
return; |
} |
#endif |
png_ptr->user_transform_ptr = user_transform_ptr; |
png_ptr->user_transform_depth = (png_byte)user_transform_depth; |
png_ptr->user_transform_channels = (png_byte)user_transform_channels; |
694,30 → 806,36 |
*/ |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
png_voidp PNGAPI |
png_get_user_transform_ptr(png_const_structp png_ptr) |
png_get_user_transform_ptr(png_const_structrp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return ((png_voidp)png_ptr->user_transform_ptr); |
return png_ptr->user_transform_ptr; |
} |
#endif |
#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED |
png_uint_32 PNGAPI |
png_get_current_row_number(png_const_structp png_ptr) |
png_get_current_row_number(png_const_structrp png_ptr) |
{ |
/* See the comments in png.h - this is the sub-image row when reading and |
* interlaced image. |
*/ |
if (png_ptr != NULL) |
return png_ptr->row_number; |
return PNG_UINT_32_MAX; /* help the app not to fail silently */ |
} |
png_byte PNGAPI |
png_get_current_pass_number(png_const_structp png_ptr) |
png_get_current_pass_number(png_const_structrp png_ptr) |
{ |
if (png_ptr != NULL) |
return png_ptr->pass; |
return 8; /* invalid */ |
} |
#endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */ |
#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED || |
PNG_WRITE_USER_TRANSFORM_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwio.c |
---|
1,8 → 1,8 |
/* pngwio.c - functions for data output |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.0 [February 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
30,11 → 30,12 |
*/ |
void /* PRIVATE */ |
png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length) |
png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length) |
{ |
/* NOTE: write_data_fn must not change the buffer! */ |
if (png_ptr->write_data_fn != NULL ) |
(*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length); |
(*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data), |
length); |
else |
png_error(png_ptr, "Call to NULL write function"); |
46,7 → 47,6 |
* write_data function and use it at run time with png_set_write_fn(), rather |
* than changing the library. |
*/ |
#ifndef USE_FAR_KEYWORD |
void PNGCBAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
60,65 → 60,7 |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#else |
/* This is the model-independent version. Since the standard I/O library |
* can't handle far buffers in the medium and small models, we have to copy |
* the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
void PNGCBAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ |
png_FILE_p io_ptr; |
if (png_ptr == NULL) |
return; |
/* Check if data really is near. If so, use usual code. */ |
near_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)near_data == data) |
{ |
check = fwrite(near_data, 1, length, io_ptr); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t written, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
written = MIN(NEAR_BUF_SIZE, remaining); |
png_memcpy(buf, data, written); /* Copy far buffer to near buffer */ |
err = fwrite(buf, 1, written, io_ptr); |
if (err != written) |
break; |
else |
check += err; |
data += written; |
remaining -= written; |
} |
while (remaining != 0); |
} |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#endif |
#endif |
/* This function is called to output any data pending writing (normally |
* to disk). After png_flush is called, there should be no data pending |
126,7 → 68,7 |
*/ |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
void /* PRIVATE */ |
png_flush(png_structp png_ptr) |
png_flush(png_structrp png_ptr) |
{ |
if (png_ptr->output_flush_fn != NULL) |
(*(png_ptr->output_flush_fn))(png_ptr); |
141,7 → 83,7 |
if (png_ptr == NULL) |
return; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr)); |
fflush(io_ptr); |
} |
# endif |
177,7 → 119,7 |
* *FILE structure. |
*/ |
void PNGAPI |
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, |
png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr, |
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) |
{ |
if (png_ptr == NULL) |
219,36 → 161,4 |
" same structure"); |
} |
} |
#ifdef USE_FAR_KEYWORD |
# ifdef _MSC_VER |
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
FP_OFF(near_ptr) = FP_OFF(ptr); |
far_ptr = (void FAR *)near_ptr; |
if (check != 0) |
if (FP_SEG(ptr) != FP_SEG(far_ptr)) |
png_error(png_ptr, "segment lost in conversion"); |
return(near_ptr); |
} |
# else |
void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
near_ptr = (void FAR *)ptr; |
far_ptr = (void FAR *)near_ptr; |
if (check != 0) |
if (far_ptr != ptr) |
png_error(png_ptr, "segment lost in conversion"); |
return(near_ptr); |
} |
# endif |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwrite.c |
---|
1,8 → 1,8 |
/* pngwrite.c - general routines to write a PNG file |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.2 [April 25, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
12,9 → 12,65 |
*/ |
#include "pngpriv.h" |
#if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) |
# include <errno.h> |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
/* Write out all the unknown chunks for the current given location */ |
static void |
write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr, |
unsigned int where) |
{ |
if (info_ptr->unknown_chunks_num) |
{ |
png_const_unknown_chunkp up; |
png_debug(5, "writing extra chunks"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
++up) |
if (up->location & where) |
{ |
/* If per-chunk unknown chunk handling is enabled use it, otherwise |
* just write the chunks the application has set. |
*/ |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
int keep = png_handle_as_unknown(png_ptr, up->name); |
/* NOTE: this code is radically different from the read side in the |
* matter of handling an ancillary unknown chunk. In the read side |
* the default behavior is to discard it, in the code below the default |
* behavior is to write it. Critical chunks are, however, only |
* written if explicitly listed or if the default is set to write all |
* unknown chunks. |
* |
* The default handling is also slightly weird - it is not possible to |
* stop the writing of all unsafe-to-copy chunks! |
* |
* TODO: REVIEW: this would seem to be a bug. |
*/ |
if (keep != PNG_HANDLE_CHUNK_NEVER && |
((up->name[3] & 0x20) /* safe-to-copy overrides everything */ || |
keep == PNG_HANDLE_CHUNK_ALWAYS || |
(keep == PNG_HANDLE_CHUNK_AS_DEFAULT && |
png_ptr->unknown_default == PNG_HANDLE_CHUNK_ALWAYS))) |
#endif |
{ |
/* TODO: review, what is wrong with a zero length unknown chunk? */ |
if (up->size == 0) |
png_warning(png_ptr, "Writing zero-length unknown chunk"); |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
} |
#endif /* PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED */ |
/* Writes all the PNG information. This is the suggested way to use the |
* library. If you have a new chunk to add, make a function to write it, |
* and put it in the correct location here. If you want the chunk written |
25,7 → 81,7 |
* them in png_write_end(), and compressing them. |
*/ |
void PNGAPI |
png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) |
png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr) |
{ |
png_debug(1, "in png_write_info_before_PLTE"); |
51,73 → 107,88 |
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, |
info_ptr->filter_type, |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
info_ptr->interlace_type); |
info_ptr->interlace_type |
#else |
0); |
0 |
#endif |
); |
/* The rest of these check to see if the valid field has the appropriate |
* flag set, and if it does, writes the chunk. |
* |
* 1.6.0: COLORSPACE support controls the writing of these chunks too, and |
* the chunks will be written if the WRITE routine is there and information |
* is available in the COLORSPACE. (See png_colorspace_sync_info in png.c |
* for where the valid flags get set.) |
* |
* Under certain circumstances the colorspace can be invalidated without |
* syncing the info_struct 'valid' flags; this happens if libpng detects and |
* error and calls png_error while the color space is being set, yet the |
* application continues writing the PNG. So check the 'invalid' flag here |
* too. |
*/ |
#ifdef PNG_GAMMA_SUPPORTED |
#ifdef PNG_WRITE_gAMA_SUPPORTED |
if (info_ptr->valid & PNG_INFO_gAMA) |
png_write_gAMA_fixed(png_ptr, info_ptr->gamma); |
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) && |
(info_ptr->valid & PNG_INFO_gAMA)) |
png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma); |
#endif |
#endif |
#ifdef PNG_COLORSPACE_SUPPORTED |
/* Write only one of sRGB or an ICC profile. If a profile was supplied |
* and it matches one of the known sRGB ones issue a warning. |
*/ |
# ifdef PNG_WRITE_iCCP_SUPPORTED |
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && |
(info_ptr->valid & PNG_INFO_iCCP)) |
{ |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
if (info_ptr->valid & PNG_INFO_sRGB) |
png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); |
png_app_warning(png_ptr, |
"profile matches sRGB but writing iCCP instead"); |
#endif |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
if (info_ptr->valid & PNG_INFO_iCCP) |
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, |
(png_charp)info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); |
png_write_iCCP(png_ptr, info_ptr->iccp_name, |
info_ptr->iccp_profile); |
} |
# ifdef PNG_WRITE_sRGB_SUPPORTED |
else |
#endif |
# endif |
# ifdef PNG_WRITE_sRGB_SUPPORTED |
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && |
(info_ptr->valid & PNG_INFO_sRGB)) |
png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent); |
# endif /* WRITE_sRGB */ |
#endif /* COLORSPACE */ |
#ifdef PNG_WRITE_sBIT_SUPPORTED |
if (info_ptr->valid & PNG_INFO_sBIT) |
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); |
#endif |
#ifdef PNG_COLORSPACE_SUPPORTED |
#ifdef PNG_WRITE_cHRM_SUPPORTED |
if (info_ptr->valid & PNG_INFO_cHRM) |
png_write_cHRM_fixed(png_ptr, |
info_ptr->x_white, info_ptr->y_white, |
info_ptr->x_red, info_ptr->y_red, |
info_ptr->x_green, info_ptr->y_green, |
info_ptr->x_blue, info_ptr->y_blue); |
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && |
(info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) && |
(info_ptr->valid & PNG_INFO_cHRM)) |
png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy); |
#endif |
#endif |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR); |
#endif |
png_debug(5, "writing extra chunks"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep = png_handle_as_unknown(png_ptr, up->name); |
if (keep != PNG_HANDLE_CHUNK_NEVER && |
up->location && !(up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
if (up->size == 0) |
png_warning(png_ptr, "Writing zero-length unknown chunk"); |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; |
} |
} |
void PNGAPI |
png_write_info(png_structp png_ptr, png_infop info_ptr) |
png_write_info(png_structrp png_ptr, png_const_inforp info_ptr) |
{ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
int i; |
261,27 → 332,7 |
#endif /* tEXt */ |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep = png_handle_as_unknown(png_ptr, up->name); |
if (keep != PNG_HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE); |
#endif |
} |
291,7 → 342,7 |
* comments, I suggest writing them here, and compressing them. |
*/ |
void PNGAPI |
png_write_end(png_structp png_ptr, png_infop info_ptr) |
png_write_end(png_structrp png_ptr, png_inforp info_ptr) |
{ |
png_debug(1, "in png_write_end"); |
301,6 → 352,11 |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "No IDATs written into file"); |
#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED |
if (png_ptr->num_palette_max > png_ptr->num_palette) |
png_benign_error(png_ptr, "Wrote palette index exceeding num_palette"); |
#endif |
/* See if user wants us to write information chunks */ |
if (info_ptr != NULL) |
{ |
368,26 → 424,7 |
} |
#endif |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep = png_handle_as_unknown(png_ptr, up->name); |
if (keep != PNG_HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_AFTER_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT); |
#endif |
} |
410,9 → 447,8 |
} |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* "tm" structure is not supported on WindowsCE */ |
void PNGAPI |
png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm FAR * ttime) |
png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime) |
{ |
png_debug(1, "in png_convert_from_struct_tm"); |
441,148 → 477,78 |
png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL)); |
#ifndef PNG_USER_MEM_SUPPORTED |
png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr, |
error_fn, warn_fn, NULL, NULL, NULL); |
#else |
return png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL); |
} |
/* Alternate initialize png_ptr structure, and allocate any memory needed */ |
static void png_reset_filter_heuristics(png_structp png_ptr); /* forward decl */ |
PNG_FUNCTION(png_structp,PNGAPI |
png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) |
{ |
png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr, |
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
volatile int png_cleanup_needed = 0; |
#ifdef PNG_SETJMP_SUPPORTED |
volatile |
#endif |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf png_jmpbuf; |
#endif |
#endif |
int i; |
if (png_ptr != NULL) |
{ |
/* Set the zlib control values to defaults; they can be overridden by the |
* application after the struct has been created. |
*/ |
png_ptr->zbuffer_size = PNG_ZBUF_SIZE; |
png_debug(1, "in png_create_write_struct"); |
/* The 'zlib_strategy' setting is irrelevant because png_default_claim in |
* pngwutil.c defaults it according to whether or not filters will be |
* used, and ignores this setting. |
*/ |
png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY; |
png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION; |
png_ptr->zlib_mem_level = 8; |
png_ptr->zlib_window_bits = 15; |
png_ptr->zlib_method = 8; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL) |
return (NULL); |
#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED |
png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY; |
png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION; |
png_ptr->zlib_text_mem_level = 8; |
png_ptr->zlib_text_window_bits = 15; |
png_ptr->zlib_text_method = 8; |
#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ |
/* Added at libpng-1.2.6 */ |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
png_ptr->user_width_max = PNG_USER_WIDTH_MAX; |
png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; |
/* This is a highly dubious configuration option; by default it is off, |
* but it may be appropriate for private builds that are testing |
* extensions not conformant to the current specification, or of |
* applications that must not fail to write at all costs! |
*/ |
#ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED |
png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; |
/* In stable builds only warn if an application error can be completely |
* handled. |
*/ |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then |
encounter a png_error() will longjmp here. Since the jmpbuf is |
then meaningless we abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(png_jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */ |
/* App warnings are warnings in release (or release candidate) builds but |
* are errors during development. |
*/ |
#if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC |
png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN; |
#endif |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(png_ptr), png_jmpbuf, png_sizeof(jmp_buf)); |
#endif |
PNG_ABORT(); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
if (user_png_ver) |
{ |
i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
} |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
/* TODO: delay this, it can be done in png_init_io() (if the app doesn't |
* do it itself) avoiding setting the default function if it is not |
* required. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[80]; |
if (user_png_ver) |
{ |
png_snprintf2(msg, 80, |
"Application built with libpng-%.20s" |
" but running with %.20s", |
user_png_ver, |
png_libpng_ver); |
png_warning(png_ptr, msg); |
png_set_write_fn(png_ptr, NULL, NULL, NULL); |
} |
#else |
png_warning(png_ptr, |
"Incompatible libpng version in application and library"); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags = 0; |
#endif |
png_cleanup_needed = 1; |
} |
} |
/* Initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
if (!png_cleanup_needed) |
{ |
png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, |
png_ptr->zbuf_size); |
if (png_ptr->zbuf == NULL) |
png_cleanup_needed = 1; |
return png_ptr; |
} |
if (png_cleanup_needed) |
{ |
/* Clean up PNG structure and deallocate any memory. */ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, |
(png_free_ptr)free_fn, (png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
return (NULL); |
} |
png_set_write_fn(png_ptr, NULL, NULL, NULL); |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
png_reset_filter_heuristics(png_ptr); |
#endif |
return (png_ptr); |
} |
/* Write a few rows of image data. If the image is interlaced, |
* either you will have to write the 7 sub images, or, if you |
* have called png_set_interlace_handling(), you will have to |
589,7 → 555,7 |
* "write" the image seven times. |
*/ |
void PNGAPI |
png_write_rows(png_structp png_ptr, png_bytepp row, |
png_write_rows(png_structrp png_ptr, png_bytepp row, |
png_uint_32 num_rows) |
{ |
png_uint_32 i; /* row counter */ |
611,7 → 577,7 |
* if you are writing an interlaced image. |
*/ |
void PNGAPI |
png_write_image(png_structp png_ptr, png_bytepp image) |
png_write_image(png_structrp png_ptr, png_bytepp image) |
{ |
png_uint_32 i; /* row index */ |
int pass, num_pass; /* pass variables */ |
643,8 → 609,11 |
/* Called by user to write a row of image data */ |
void PNGAPI |
png_write_row(png_structp png_ptr, png_const_bytep row) |
png_write_row(png_structrp png_ptr, png_const_bytep row) |
{ |
/* 1.5.6: moved from png_struct to be a local structure: */ |
png_row_info row_info; |
if (png_ptr == NULL) |
return; |
768,26 → 737,22 |
#endif |
/* Set up row info for transformations */ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->usr_width; |
png_ptr->row_info.channels = png_ptr->usr_channels; |
png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
row_info.color_type = png_ptr->color_type; |
row_info.width = png_ptr->usr_width; |
row_info.channels = png_ptr->usr_channels; |
row_info.bit_depth = png_ptr->usr_bit_depth; |
row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels); |
row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); |
png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
png_debug1(3, "row_info->color_type = %d", row_info.color_type); |
png_debug1(3, "row_info->width = %u", row_info.width); |
png_debug1(3, "row_info->channels = %d", row_info.channels); |
png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth); |
png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth); |
png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes); |
png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type); |
png_debug1(3, "row_info->width = %u", png_ptr->row_info.width); |
png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels); |
png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth); |
png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth); |
png_debug1(3, "row_info->rowbytes = %lu", |
(unsigned long)png_ptr->row_info.rowbytes); |
/* Copy user's row into buffer, leaving room for filter byte. */ |
png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes); |
memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes); |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Handle interlacing */ |
794,10 → 759,9 |
if (png_ptr->interlaced && png_ptr->pass < 6 && |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_do_write_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass); |
png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass); |
/* This should always get caught above, but still ... */ |
if (!(png_ptr->row_info.width)) |
if (!(row_info.width)) |
{ |
png_write_finish_row(png_ptr); |
return; |
805,10 → 769,19 |
} |
#endif |
#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED |
/* Handle other transformations */ |
if (png_ptr->transformations) |
png_do_write_transformations(png_ptr); |
png_do_write_transformations(png_ptr, &row_info); |
#endif |
/* At this point the row_info pixel depth must match the 'transformed' depth, |
* which is also the output depth. |
*/ |
if (row_info.pixel_depth != png_ptr->pixel_depth || |
row_info.pixel_depth != png_ptr->transformed_pixel_depth) |
png_error(png_ptr, "internal write transform logic error"); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
/* Write filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
823,12 → 796,20 |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1); |
} |
#endif |
/* Added at libpng-1.5.10 */ |
#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED |
/* Check for out-of-range palette index */ |
if (row_info.color_type == PNG_COLOR_TYPE_PALETTE && |
png_ptr->num_palette_max >= 0) |
png_do_check_palette_indexes(png_ptr, &row_info); |
#endif |
/* Find a filter if necessary, filter the row and write it out. */ |
png_write_find_filter(png_ptr, &(png_ptr->row_info)); |
png_write_find_filter(png_ptr, &row_info); |
if (png_ptr->write_row_fn != NULL) |
(*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
837,7 → 818,7 |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
/* Set the automatic flush interval or 0 to turn flushing off */ |
void PNGAPI |
png_set_flush(png_structp png_ptr, int nrows) |
png_set_flush(png_structrp png_ptr, int nrows) |
{ |
png_debug(1, "in png_set_flush"); |
849,10 → 830,8 |
/* Flush the current output buffers now */ |
void PNGAPI |
png_write_flush(png_structp png_ptr) |
png_write_flush(png_structrp png_ptr) |
{ |
int wrote_IDAT; |
png_debug(1, "in png_write_flush"); |
if (png_ptr == NULL) |
862,140 → 841,28 |
if (png_ptr->row_number >= png_ptr->num_rows) |
return; |
do |
{ |
int ret; |
/* Compress the data */ |
ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); |
wrote_IDAT = 0; |
/* Check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* Write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
wrote_IDAT = 1; |
} |
} while (wrote_IDAT == 1); |
/* If there is any data left to be output, write it into a new IDAT */ |
if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) |
{ |
/* Write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH); |
png_ptr->flush_rows = 0; |
png_flush(png_ptr); |
} |
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
/* Free all memory used by the write */ |
void PNGAPI |
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
static void png_reset_filter_heuristics(png_structrp png_ptr);/* forward decl */ |
#endif |
png_debug(1, "in png_destroy_write_struct"); |
if (png_ptr_ptr != NULL) |
/* Free any memory used in png_ptr struct without freeing the struct itself. */ |
static void |
png_write_destroy(png_structrp png_ptr) |
{ |
png_ptr = *png_ptr_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr != NULL) |
{ |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
} |
#endif |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (info_ptr != NULL) |
{ |
if (png_ptr != NULL) |
{ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->num_chunk_list = 0; |
} |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
png_write_destroy(png_ptr); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* Free any memory used in png_ptr struct (old method) */ |
void /* PRIVATE */ |
png_write_destroy(png_structp png_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* Save jump buffer */ |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_write_destroy"); |
/* Free any memory zlib uses */ |
if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) |
deflateEnd(&png_ptr->zstream); |
/* Free our memory. png_free checks NULL for us. */ |
png_free(png_ptr, png_ptr->zbuf); |
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list); |
png_free(png_ptr, png_ptr->row_buf); |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
png_free(png_ptr, png_ptr->prev_row); |
1005,10 → 872,6 |
png_free(png_ptr, png_ptr->paeth_row); |
#endif |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
/* Use this to save a little code space, it doesn't free the filter_costs */ |
png_reset_filter_heuristics(png_ptr); |
1016,35 → 879,46 |
png_free(png_ptr, png_ptr->inv_filter_costs); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Reset structure */ |
png_memcpy(tmp_jmp, png_ptr->png_jmpbuf, png_sizeof(jmp_buf)); |
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED |
png_free(png_ptr, png_ptr->chunk_list); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#endif |
/* The error handling and memory handling information is left intact at this |
* point: the jmp_buf may still have to be freed. See png_destroy_png_struct |
* for how this happens. |
*/ |
} |
png_memset(png_ptr, 0, png_sizeof(png_struct)); |
/* Free all memory used by the write. |
* In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for |
* *png_ptr_ptr. Prior to 1.6.0 it would accept such a value and it would free |
* the passed in info_structs but it would quietly fail to free any of the data |
* inside them. In 1.6.0 it quietly does nothing (it has to be quiet because it |
* has no png_ptr.) |
*/ |
void PNGAPI |
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) |
{ |
png_debug(1, "in png_destroy_write_struct"); |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
if (png_ptr_ptr != NULL) |
{ |
png_structrp png_ptr = *png_ptr_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->png_jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); |
#endif |
if (png_ptr != NULL) /* added in libpng 1.6.0 */ |
{ |
png_destroy_info_struct(png_ptr, info_ptr_ptr); |
*png_ptr_ptr = NULL; |
png_write_destroy(png_ptr); |
png_destroy_png_struct(png_ptr); |
} |
} |
} |
/* Allow the application to select one or more row filters to use. */ |
void PNGAPI |
png_set_filter(png_structp png_ptr, int method, int filters) |
png_set_filter(png_structrp png_ptr, int method, int filters) |
{ |
png_debug(1, "in png_set_filter"); |
1064,7 → 938,8 |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
case 5: |
case 6: |
case 7: png_warning(png_ptr, "Unknown row filter for method 0"); |
case 7: png_app_error(png_ptr, "Unknown row filter for method 0"); |
/* FALL THROUGH */ |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
case PNG_FILTER_VALUE_NONE: |
png_ptr->do_filter = PNG_FILTER_NONE; break; |
1086,7 → 961,7 |
png_ptr->do_filter = (png_byte)filters; break; |
#else |
default: |
png_warning(png_ptr, "Unknown row filter for method 0"); |
png_app_error(png_ptr, "Unknown row filter for method 0"); |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
} |
1177,9 → 1052,9 |
* better compression. |
*/ |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* GRR 970116 */ |
/* Conveneince reset API. */ |
/* Convenience reset API. */ |
static void |
png_reset_filter_heuristics(png_structp png_ptr) |
png_reset_filter_heuristics(png_structrp png_ptr) |
{ |
/* Clear out any old values in the 'weights' - this must be done because if |
* the app calls set_filter_heuristics multiple times with different |
1212,7 → 1087,7 |
} |
static int |
png_init_filter_heuristics(png_structp png_ptr, int heuristic_method, |
png_init_filter_heuristics(png_structrp png_ptr, int heuristic_method, |
int num_weights) |
{ |
if (png_ptr == NULL) |
1232,7 → 1107,7 |
if (num_weights > 0) |
{ |
png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_byte) * num_weights)); |
(png_uint_32)((sizeof (png_byte)) * num_weights)); |
/* To make sure that the weighting starts out fairly */ |
for (i = 0; i < num_weights; i++) |
1241,10 → 1116,10 |
} |
png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_uint_16) * num_weights)); |
(png_uint_32)((sizeof (png_uint_16)) * num_weights)); |
png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_uint_16) * num_weights)); |
(png_uint_32)((sizeof (png_uint_16)) * num_weights)); |
for (i = 0; i < num_weights; i++) |
{ |
1262,10 → 1137,10 |
if (png_ptr->filter_costs == NULL) |
{ |
png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
(png_uint_32)((sizeof (png_uint_16)) * PNG_FILTER_VALUE_LAST)); |
png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
(png_uint_32)((sizeof (png_uint_16)) * PNG_FILTER_VALUE_LAST)); |
} |
for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
1295,7 → 1170,7 |
/* Provide floating and fixed point APIs */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, |
png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method, |
int num_weights, png_const_doublep filter_weights, |
png_const_doublep filter_costs) |
{ |
1350,7 → 1225,7 |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_filter_heuristics_fixed(png_structp png_ptr, int heuristic_method, |
png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method, |
int num_weights, png_const_fixed_point_p filter_weights, |
png_const_fixed_point_p filter_costs) |
{ |
1416,7 → 1291,7 |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
void PNGAPI |
png_set_compression_level(png_structp png_ptr, int level) |
png_set_compression_level(png_structrp png_ptr, int level) |
{ |
png_debug(1, "in png_set_compression_level"); |
1423,12 → 1298,11 |
if (png_ptr == NULL) |
return; |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; |
png_ptr->zlib_level = level; |
} |
void PNGAPI |
png_set_compression_mem_level(png_structp png_ptr, int mem_level) |
png_set_compression_mem_level(png_structrp png_ptr, int mem_level) |
{ |
png_debug(1, "in png_set_compression_mem_level"); |
1435,12 → 1309,11 |
if (png_ptr == NULL) |
return; |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; |
png_ptr->zlib_mem_level = mem_level; |
} |
void PNGAPI |
png_set_compression_strategy(png_structp png_ptr, int strategy) |
png_set_compression_strategy(png_structrp png_ptr, int strategy) |
{ |
png_debug(1, "in png_set_compression_strategy"); |
1447,37 → 1320,44 |
if (png_ptr == NULL) |
return; |
/* The flag setting here prevents the libpng dynamic selection of strategy. |
*/ |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; |
png_ptr->zlib_strategy = strategy; |
} |
/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a |
* smaller value of window_bits if it can do so safely. |
*/ |
void PNGAPI |
png_set_compression_window_bits(png_structp png_ptr, int window_bits) |
png_set_compression_window_bits(png_structrp png_ptr, int window_bits) |
{ |
if (png_ptr == NULL) |
return; |
/* Prior to 1.6.0 this would warn but then set the window_bits value, this |
* meant that negative window bits values could be selected which would cause |
* libpng to write a non-standard PNG file with raw deflate or gzip |
* compressed IDAT or ancillary chunks. Such files can be read and there is |
* no warning on read, so this seems like a very bad idea. |
*/ |
if (window_bits > 15) |
{ |
png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); |
window_bits = 15; |
} |
else if (window_bits < 8) |
{ |
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); |
#ifndef WBITS_8_OK |
/* Avoid libpng bug with 256-byte windows */ |
if (window_bits == 8) |
{ |
png_warning(png_ptr, "Compression window is being reset to 512"); |
window_bits = 9; |
window_bits = 8; |
} |
#endif |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; |
png_ptr->zlib_window_bits = window_bits; |
} |
void PNGAPI |
png_set_compression_method(png_structp png_ptr, int method) |
png_set_compression_method(png_structrp png_ptr, int method) |
{ |
png_debug(1, "in png_set_compression_method"); |
1484,25 → 1364,102 |
if (png_ptr == NULL) |
return; |
/* This would produce an invalid PNG file if it worked, but it doesn't and |
* deflate will fault it, so it is harmless to just warn here. |
*/ |
if (method != 8) |
png_warning(png_ptr, "Only compression method 8 is supported by PNG"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; |
png_ptr->zlib_method = method; |
} |
/* The following were added to libpng-1.5.4 */ |
#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED |
void PNGAPI |
png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) |
png_set_text_compression_level(png_structrp png_ptr, int level) |
{ |
png_debug(1, "in png_set_text_compression_level"); |
if (png_ptr == NULL) |
return; |
png_ptr->zlib_text_level = level; |
} |
void PNGAPI |
png_set_text_compression_mem_level(png_structrp png_ptr, int mem_level) |
{ |
png_debug(1, "in png_set_text_compression_mem_level"); |
if (png_ptr == NULL) |
return; |
png_ptr->zlib_text_mem_level = mem_level; |
} |
void PNGAPI |
png_set_text_compression_strategy(png_structrp png_ptr, int strategy) |
{ |
png_debug(1, "in png_set_text_compression_strategy"); |
if (png_ptr == NULL) |
return; |
png_ptr->zlib_text_strategy = strategy; |
} |
/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a |
* smaller value of window_bits if it can do so safely. |
*/ |
void PNGAPI |
png_set_text_compression_window_bits(png_structrp png_ptr, int window_bits) |
{ |
if (png_ptr == NULL) |
return; |
if (window_bits > 15) |
{ |
png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); |
window_bits = 15; |
} |
else if (window_bits < 8) |
{ |
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); |
window_bits = 8; |
} |
png_ptr->zlib_text_window_bits = window_bits; |
} |
void PNGAPI |
png_set_text_compression_method(png_structrp png_ptr, int method) |
{ |
png_debug(1, "in png_set_text_compression_method"); |
if (png_ptr == NULL) |
return; |
if (method != 8) |
png_warning(png_ptr, "Only compression method 8 is supported by PNG"); |
png_ptr->zlib_text_method = method; |
} |
#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ |
/* end of API added to libpng-1.5.4 */ |
void PNGAPI |
png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn) |
{ |
if (png_ptr == NULL) |
return; |
png_ptr->write_row_fn = write_row_fn; |
} |
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED |
void PNGAPI |
png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr |
write_user_transform_fn) |
{ |
png_debug(1, "in png_set_write_user_transform_fn"); |
1518,7 → 1475,7 |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
void PNGAPI |
png_write_png(png_structp png_ptr, png_infop info_ptr, |
png_write_png(png_structrp png_ptr, png_inforp info_ptr, |
int transforms, voidp params) |
{ |
if (png_ptr == NULL || info_ptr == NULL) |
1557,7 → 1514,7 |
#endif |
#ifdef PNG_WRITE_FILLER_SUPPORTED |
/* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */ |
/* Pack XRGB/RGBX/ARGB/RGBA into RGB (4 channels -> 3 channels) */ |
if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) |
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); |
1602,4 → 1559,772 |
PNG_UNUSED(params) |
} |
#endif |
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED |
#ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */ |
/* Initialize the write structure - general purpose utility. */ |
static int |
png_image_write_init(png_imagep image) |
{ |
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image, |
png_safe_error, png_safe_warning); |
if (png_ptr != NULL) |
{ |
png_infop info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr != NULL) |
{ |
png_controlp control = png_voidcast(png_controlp, |
png_malloc_warn(png_ptr, (sizeof *control))); |
if (control != NULL) |
{ |
memset(control, 0, (sizeof *control)); |
control->png_ptr = png_ptr; |
control->info_ptr = info_ptr; |
control->for_write = 1; |
image->opaque = control; |
return 1; |
} |
/* Error clean up */ |
png_destroy_info_struct(png_ptr, &info_ptr); |
} |
png_destroy_write_struct(&png_ptr, NULL); |
} |
return png_image_error(image, "png_image_write_: out of memory"); |
} |
/* Arguments to png_image_write_main: */ |
typedef struct |
{ |
/* Arguments: */ |
png_imagep image; |
png_const_voidp buffer; |
png_int_32 row_stride; |
png_const_voidp colormap; |
int convert_to_8bit; |
/* Local variables: */ |
png_const_voidp first_row; |
ptrdiff_t row_bytes; |
png_voidp local_row; |
} png_image_write_control; |
/* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to |
* do any necessary byte swapping. The component order is defined by the |
* png_image format value. |
*/ |
static int |
png_write_image_16bit(png_voidp argument) |
{ |
png_image_write_control *display = png_voidcast(png_image_write_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
png_const_uint_16p input_row = png_voidcast(png_const_uint_16p, |
display->first_row); |
png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row); |
png_uint_16p row_end; |
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; |
int aindex = 0; |
png_uint_32 y = image->height; |
if (image->format & PNG_FORMAT_FLAG_ALPHA) |
{ |
if (image->format & PNG_FORMAT_FLAG_AFIRST) |
{ |
aindex = -1; |
++input_row; /* To point to the first component */ |
++output_row; |
} |
else |
aindex = channels; |
} |
else |
png_error(png_ptr, "png_write_image: internal call error"); |
/* Work out the output row end and count over this, note that the increment |
* above to 'row' means that row_end can actually be beyond the end of the |
* row; this is correct. |
*/ |
row_end = output_row + image->width * (channels+1); |
while (y-- > 0) |
{ |
png_const_uint_16p in_ptr = input_row; |
png_uint_16p out_ptr = output_row; |
while (out_ptr < row_end) |
{ |
const png_uint_16 alpha = in_ptr[aindex]; |
png_uint_32 reciprocal = 0; |
int c; |
out_ptr[aindex] = alpha; |
/* Calculate a reciprocal. The correct calculation is simply |
* component/alpha*65535 << 15. (I.e. 15 bits of precision); this |
* allows correct rounding by adding .5 before the shift. 'reciprocal' |
* is only initialized when required. |
*/ |
if (alpha > 0 && alpha < 65535) |
reciprocal = ((0xffff<<15)+(alpha>>1))/alpha; |
c = channels; |
do /* always at least one channel */ |
{ |
png_uint_16 component = *in_ptr++; |
/* The following gives 65535 for an alpha of 0, which is fine, |
* otherwise if 0/0 is represented as some other value there is more |
* likely to be a discontinuity which will probably damage |
* compression when moving from a fully transparent area to a |
* nearly transparent one. (The assumption here is that opaque |
* areas tend not to be 0 intensity.) |
*/ |
if (component >= alpha) |
component = 65535; |
/* component<alpha, so component/alpha is less than one and |
* component*reciprocal is less than 2^31. |
*/ |
else if (component > 0 && alpha < 65535) |
{ |
png_uint_32 calc = component * reciprocal; |
calc += 16384; /* round to nearest */ |
component = (png_uint_16)(calc >> 15); |
} |
*out_ptr++ = component; |
} |
while (--c > 0); |
/* Skip to next component (skip the intervening alpha channel) */ |
++in_ptr; |
++out_ptr; |
} |
png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row)); |
input_row += display->row_bytes/(sizeof (png_uint_16)); |
} |
return 1; |
} |
/* Given 16-bit input (1 to 4 channels) write 8-bit output. If an alpha channel |
* is present it must be removed from the components, the components are then |
* written in sRGB encoding. No components are added or removed. |
* |
* Calculate an alpha reciprocal to reverse pre-multiplication. As above the |
* calculation can be done to 15 bits of accuracy; however, the output needs to |
* be scaled in the range 0..255*65535, so include that scaling here. |
*/ |
#define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha) |
static png_byte |
png_unpremultiply(png_uint_32 component, png_uint_32 alpha, |
png_uint_32 reciprocal/*from the above macro*/) |
{ |
/* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0 |
* is represented as some other value there is more likely to be a |
* discontinuity which will probably damage compression when moving from a |
* fully transparent area to a nearly transparent one. (The assumption here |
* is that opaque areas tend not to be 0 intensity.) |
* |
* There is a rounding problem here; if alpha is less than 128 it will end up |
* as 0 when scaled to 8 bits. To avoid introducing spurious colors into the |
* output change for this too. |
*/ |
if (component >= alpha || alpha < 128) |
return 255; |
/* component<alpha, so component/alpha is less than one and |
* component*reciprocal is less than 2^31. |
*/ |
else if (component > 0) |
{ |
/* The test is that alpha/257 (rounded) is less than 255, the first value |
* that becomes 255 is 65407. |
* NOTE: this must agree with the PNG_DIV257 macro (which must, therefore, |
* be exact!) [Could also test reciprocal != 0] |
*/ |
if (alpha < 65407) |
{ |
component *= reciprocal; |
component += 64; /* round to nearest */ |
component >>= 7; |
} |
else |
component *= 255; |
/* Convert the component to sRGB. */ |
return (png_byte)PNG_sRGB_FROM_LINEAR(component); |
} |
else |
return 0; |
} |
static int |
png_write_image_8bit(png_voidp argument) |
{ |
png_image_write_control *display = png_voidcast(png_image_write_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
png_const_uint_16p input_row = png_voidcast(png_const_uint_16p, |
display->first_row); |
png_bytep output_row = png_voidcast(png_bytep, display->local_row); |
png_uint_32 y = image->height; |
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; |
if (image->format & PNG_FORMAT_FLAG_ALPHA) |
{ |
png_bytep row_end; |
int aindex; |
if (image->format & PNG_FORMAT_FLAG_AFIRST) |
{ |
aindex = -1; |
++input_row; /* To point to the first component */ |
++output_row; |
} |
else |
aindex = channels; |
/* Use row_end in place of a loop counter: */ |
row_end = output_row + image->width * (channels+1); |
while (y-- > 0) |
{ |
png_const_uint_16p in_ptr = input_row; |
png_bytep out_ptr = output_row; |
while (out_ptr < row_end) |
{ |
png_uint_16 alpha = in_ptr[aindex]; |
png_byte alphabyte = (png_byte)PNG_DIV257(alpha); |
png_uint_32 reciprocal = 0; |
int c; |
/* Scale and write the alpha channel. */ |
out_ptr[aindex] = alphabyte; |
if (alphabyte > 0 && alphabyte < 255) |
reciprocal = UNP_RECIPROCAL(alpha); |
c = channels; |
do /* always at least one channel */ |
*out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal); |
while (--c > 0); |
/* Skip to next component (skip the intervening alpha channel) */ |
++in_ptr; |
++out_ptr; |
} /* while out_ptr < row_end */ |
png_write_row(png_ptr, png_voidcast(png_const_bytep, |
display->local_row)); |
input_row += display->row_bytes/(sizeof (png_uint_16)); |
} /* while y */ |
} |
else |
{ |
/* No alpha channel, so the row_end really is the end of the row and it |
* is sufficient to loop over the components one by one. |
*/ |
png_bytep row_end = output_row + image->width * channels; |
while (y-- > 0) |
{ |
png_const_uint_16p in_ptr = input_row; |
png_bytep out_ptr = output_row; |
while (out_ptr < row_end) |
{ |
png_uint_32 component = *in_ptr++; |
component *= 255; |
*out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component); |
} |
png_write_row(png_ptr, output_row); |
input_row += display->row_bytes/(sizeof (png_uint_16)); |
} |
} |
return 1; |
} |
static void |
png_image_set_PLTE(png_image_write_control *display) |
{ |
const png_imagep image = display->image; |
const void *cmap = display->colormap; |
const int entries = image->colormap_entries > 256 ? 256 : |
(int)image->colormap_entries; |
/* NOTE: the caller must check for cmap != NULL and entries != 0 */ |
const png_uint_32 format = image->format; |
const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format); |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 && |
(format & PNG_FORMAT_FLAG_ALPHA) != 0; |
# else |
# define afirst 0 |
# endif |
# ifdef PNG_FORMAT_BGR_SUPPORTED |
const int bgr = (format & PNG_FORMAT_FLAG_BGR) ? 2 : 0; |
# else |
# define bgr 0 |
# endif |
int i, num_trans; |
png_color palette[256]; |
png_byte tRNS[256]; |
memset(tRNS, 255, (sizeof tRNS)); |
memset(palette, 0, (sizeof palette)); |
for (i=num_trans=0; i<entries; ++i) |
{ |
/* This gets automatically converted to sRGB with reversal of the |
* pre-multiplication if the color-map has an alpha channel. |
*/ |
if (format & PNG_FORMAT_FLAG_LINEAR) |
{ |
png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap); |
entry += i * channels; |
if (channels & 1) /* no alpha */ |
{ |
if (channels >= 3) /* RGB */ |
{ |
palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 * |
entry[(2 ^ bgr)]); |
palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 * |
entry[1]); |
palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 * |
entry[bgr]); |
} |
else /* Gray */ |
palette[i].blue = palette[i].red = palette[i].green = |
(png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry); |
} |
else /* alpha */ |
{ |
png_uint_16 alpha = entry[afirst ? 0 : channels-1]; |
png_byte alphabyte = (png_byte)PNG_DIV257(alpha); |
png_uint_32 reciprocal = 0; |
/* Calculate a reciprocal, as in the png_write_image_8bit code above |
* this is designed to produce a value scaled to 255*65535 when |
* divided by 128 (i.e. asr 7). |
*/ |
if (alphabyte > 0 && alphabyte < 255) |
reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha; |
tRNS[i] = alphabyte; |
if (alphabyte < 255) |
num_trans = i+1; |
if (channels >= 3) /* RGB */ |
{ |
palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)], |
alpha, reciprocal); |
palette[i].green = png_unpremultiply(entry[afirst + 1], alpha, |
reciprocal); |
palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha, |
reciprocal); |
} |
else /* gray */ |
palette[i].blue = palette[i].red = palette[i].green = |
png_unpremultiply(entry[afirst], alpha, reciprocal); |
} |
} |
else /* Color-map has sRGB values */ |
{ |
png_const_bytep entry = png_voidcast(png_const_bytep, cmap); |
entry += i * channels; |
switch (channels) |
{ |
case 4: |
tRNS[i] = entry[afirst ? 0 : 3]; |
if (tRNS[i] < 255) |
num_trans = i+1; |
/* FALL THROUGH */ |
case 3: |
palette[i].blue = entry[afirst + (2 ^ bgr)]; |
palette[i].green = entry[afirst + 1]; |
palette[i].red = entry[afirst + bgr]; |
break; |
case 2: |
tRNS[i] = entry[1 ^ afirst]; |
if (tRNS[i] < 255) |
num_trans = i+1; |
/* FALL THROUGH */ |
case 1: |
palette[i].blue = palette[i].red = palette[i].green = |
entry[afirst]; |
break; |
default: |
break; |
} |
} |
} |
# ifdef afirst |
# undef afirst |
# endif |
# ifdef bgr |
# undef bgr |
# endif |
png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette, |
entries); |
if (num_trans > 0) |
png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS, |
num_trans, NULL); |
image->colormap_entries = entries; |
} |
static int |
png_image_write_main(png_voidp argument) |
{ |
png_image_write_control *display = png_voidcast(png_image_write_control*, |
argument); |
png_imagep image = display->image; |
png_structrp png_ptr = image->opaque->png_ptr; |
png_inforp info_ptr = image->opaque->info_ptr; |
png_uint_32 format = image->format; |
int colormap = (format & PNG_FORMAT_FLAG_COLORMAP) != 0; |
int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR) != 0; /* input */ |
int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA) != 0; |
int write_16bit = linear && !colormap && !display->convert_to_8bit; |
# ifdef PNG_BENIGN_ERRORS_SUPPORTED |
/* Make sure we error out on any bad situation */ |
png_set_benign_errors(png_ptr, 0/*error*/); |
# endif |
/* Default the 'row_stride' parameter if required. */ |
if (display->row_stride == 0) |
display->row_stride = PNG_IMAGE_ROW_STRIDE(*image); |
/* Set the required transforms then write the rows in the correct order. */ |
if (format & PNG_FORMAT_FLAG_COLORMAP) |
{ |
if (display->colormap != NULL && image->colormap_entries > 0) |
{ |
png_uint_32 entries = image->colormap_entries; |
png_set_IHDR(png_ptr, info_ptr, image->width, image->height, |
entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)), |
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, |
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); |
png_image_set_PLTE(display); |
} |
else |
png_error(image->opaque->png_ptr, |
"no color-map for color-mapped image"); |
} |
else |
png_set_IHDR(png_ptr, info_ptr, image->width, image->height, |
write_16bit ? 16 : 8, |
((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) + |
((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0), |
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); |
/* Counter-intuitively the data transformations must be called *after* |
* png_write_info, not before as in the read code, but the 'set' functions |
* must still be called before. Just set the color space information, never |
* write an interlaced image. |
*/ |
if (write_16bit) |
{ |
/* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */ |
png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR); |
if (!(image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB)) |
png_set_cHRM_fixed(png_ptr, info_ptr, |
/* color x y */ |
/* white */ 31270, 32900, |
/* red */ 64000, 33000, |
/* green */ 30000, 60000, |
/* blue */ 15000, 6000 |
); |
} |
else if (!(image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB)) |
png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL); |
/* Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit |
* space must still be gamma encoded. |
*/ |
else |
png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE); |
/* Write the file header. */ |
png_write_info(png_ptr, info_ptr); |
/* Now set up the data transformations (*after* the header is written), |
* remove the handled transformations from the 'format' flags for checking. |
* |
* First check for a little endian system if writing 16 bit files. |
*/ |
if (write_16bit) |
{ |
PNG_CONST png_uint_16 le = 0x0001; |
if (*(png_const_bytep)&le) |
png_set_swap(png_ptr); |
} |
# ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED |
if (format & PNG_FORMAT_FLAG_BGR) |
{ |
if (!colormap && (format & PNG_FORMAT_FLAG_COLOR) != 0) |
png_set_bgr(png_ptr); |
format &= ~PNG_FORMAT_FLAG_BGR; |
} |
# endif |
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED |
if (format & PNG_FORMAT_FLAG_AFIRST) |
{ |
if (!colormap && (format & PNG_FORMAT_FLAG_ALPHA) != 0) |
png_set_swap_alpha(png_ptr); |
format &= ~PNG_FORMAT_FLAG_AFIRST; |
} |
# endif |
/* If there are 16 or fewer color-map entries we wrote a lower bit depth |
* above, but the application data is still byte packed. |
*/ |
if (colormap && image->colormap_entries <= 16) |
png_set_packing(png_ptr); |
/* That should have handled all (both) the transforms. */ |
if ((format & ~(png_uint_32)(PNG_FORMAT_FLAG_COLOR | PNG_FORMAT_FLAG_LINEAR | |
PNG_FORMAT_FLAG_ALPHA | PNG_FORMAT_FLAG_COLORMAP)) != 0) |
png_error(png_ptr, "png_write_image: unsupported transformation"); |
{ |
png_const_bytep row = png_voidcast(png_const_bytep, display->buffer); |
ptrdiff_t row_bytes = display->row_stride; |
if (linear) |
row_bytes *= (sizeof (png_uint_16)); |
if (row_bytes < 0) |
row += (image->height-1) * (-row_bytes); |
display->first_row = row; |
display->row_bytes = row_bytes; |
} |
/* Apply 'fast' options if the flag is set. */ |
if ((image->flags & PNG_IMAGE_FLAG_FAST) != 0) |
{ |
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS); |
/* NOTE: determined by experiment using pngstest, this reflects some |
* balance between the time to write the image once and the time to read |
* it about 50 times. The speed-up in pngstest was about 10-20% of the |
* total (user) time on a heavily loaded system. |
*/ |
png_set_compression_level(png_ptr, 3); |
} |
/* Check for the cases that currently require a pre-transform on the row |
* before it is written. This only applies when the input is 16-bit and |
* either there is an alpha channel or it is converted to 8-bit. |
*/ |
if ((linear && alpha) || (!colormap && display->convert_to_8bit)) |
{ |
png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr, |
png_get_rowbytes(png_ptr, info_ptr))); |
int result; |
display->local_row = row; |
if (write_16bit) |
result = png_safe_execute(image, png_write_image_16bit, display); |
else |
result = png_safe_execute(image, png_write_image_8bit, display); |
display->local_row = NULL; |
png_free(png_ptr, row); |
/* Skip the 'write_end' on error: */ |
if (!result) |
return 0; |
} |
/* Otherwise this is the case where the input is in a format currently |
* supported by the rest of the libpng write code; call it directly. |
*/ |
else |
{ |
png_const_bytep row = png_voidcast(png_const_bytep, display->first_row); |
ptrdiff_t row_bytes = display->row_bytes; |
png_uint_32 y = image->height; |
while (y-- > 0) |
{ |
png_write_row(png_ptr, row); |
row += row_bytes; |
} |
} |
png_write_end(png_ptr, info_ptr); |
return 1; |
} |
int PNGAPI |
png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit, |
const void *buffer, png_int_32 row_stride, const void *colormap) |
{ |
/* Write the image to the given (FILE*). */ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
if (file != NULL) |
{ |
if (png_image_write_init(image)) |
{ |
png_image_write_control display; |
int result; |
/* This is slightly evil, but png_init_io doesn't do anything other |
* than this and we haven't changed the standard IO functions so |
* this saves a 'safe' function. |
*/ |
image->opaque->png_ptr->io_ptr = file; |
memset(&display, 0, (sizeof display)); |
display.image = image; |
display.buffer = buffer; |
display.row_stride = row_stride; |
display.colormap = colormap; |
display.convert_to_8bit = convert_to_8bit; |
result = png_safe_execute(image, png_image_write_main, &display); |
png_image_free(image); |
return result; |
} |
else |
return 0; |
} |
else |
return png_image_error(image, |
"png_image_write_to_stdio: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION"); |
else |
return 0; |
} |
int PNGAPI |
png_image_write_to_file(png_imagep image, const char *file_name, |
int convert_to_8bit, const void *buffer, png_int_32 row_stride, |
const void *colormap) |
{ |
/* Write the image to the named file. */ |
if (image != NULL && image->version == PNG_IMAGE_VERSION) |
{ |
if (file_name != NULL) |
{ |
FILE *fp = fopen(file_name, "wb"); |
if (fp != NULL) |
{ |
if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer, |
row_stride, colormap)) |
{ |
int error; /* from fflush/fclose */ |
/* Make sure the file is flushed correctly. */ |
if (fflush(fp) == 0 && ferror(fp) == 0) |
{ |
if (fclose(fp) == 0) |
return 1; |
error = errno; /* from fclose */ |
} |
else |
{ |
error = errno; /* from fflush or ferror */ |
(void)fclose(fp); |
} |
(void)remove(file_name); |
/* The image has already been cleaned up; this is just used to |
* set the error (because the original write succeeded). |
*/ |
return png_image_error(image, strerror(error)); |
} |
else |
{ |
/* Clean up: just the opened file. */ |
(void)fclose(fp); |
(void)remove(file_name); |
return 0; |
} |
} |
else |
return png_image_error(image, strerror(errno)); |
} |
else |
return png_image_error(image, |
"png_image_write_to_file: invalid argument"); |
} |
else if (image != NULL) |
return png_image_error(image, |
"png_image_write_to_file: incorrect PNG_IMAGE_VERSION"); |
else |
return 0; |
} |
#endif /* PNG_STDIO_SUPPORTED */ |
#endif /* SIMPLIFIED_WRITE */ |
#endif /* PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwtran.c |
---|
1,8 → 1,8 |
/* pngwtran.c - transforms the data in a row for PNG writers |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.0 [February 14, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
15,11 → 15,12 |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED |
/* Transform the data according to the user's wishes. The order of |
* transformations is significant. |
*/ |
void /* PRIVATE */ |
png_do_write_transformations(png_structp png_ptr) |
png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info) |
{ |
png_debug(1, "in png_do_write_transformations"); |
32,7 → 33,7 |
(*(png_ptr->write_user_transform_fn)) /* User write transform |
function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
row_info, /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_size_t rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
44,50 → 45,50 |
#ifdef PNG_WRITE_FILLER_SUPPORTED |
if (png_ptr->transformations & PNG_FILLER) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->flags); |
png_do_strip_channel(row_info, png_ptr->row_buf + 1, |
!(png_ptr->flags & PNG_FLAG_FILLER_AFTER)); |
#endif |
#ifdef PNG_WRITE_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_packswap(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_PACK_SUPPORTED |
if (png_ptr->transformations & PNG_PACK) |
png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_pack(row_info, png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->bit_depth); |
#endif |
#ifdef PNG_WRITE_SWAP_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_swap(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_SHIFT_SUPPORTED |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_do_shift(row_info, png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_BGR_SUPPORTED |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_bgr(row_info, png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_INVERT_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
png_do_invert(row_info, png_ptr->row_buf + 1); |
#endif |
} |
286,7 → 287,7 |
{ |
png_bytep bp = row; |
png_size_t i; |
png_byte mask; |
unsigned int mask; |
png_size_t row_bytes = row_info->rowbytes; |
if (bit_depth->gray == 1 && row_info->bit_depth == 2) |
300,20 → 301,22 |
for (i = 0; i < row_bytes; i++, bp++) |
{ |
png_uint_16 v; |
int j; |
unsigned int v, out; |
v = *bp; |
*bp = 0; |
out = 0; |
for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
out |= v << j; |
else |
*bp |= (png_byte)((v >> (-j)) & mask); |
out |= (v >> (-j)) & mask; |
} |
*bp = (png_byte)(out & 0xff); |
} |
} |
326,21 → 329,23 |
for (i = 0; i < istop; i++, bp++) |
{ |
png_uint_16 v; |
const unsigned int c = i%channels; |
int j; |
int c = (int)(i%channels); |
unsigned int v, out; |
v = *bp; |
*bp = 0; |
out = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
out |= v << j; |
else |
*bp |= (png_byte)((v >> (-j)) & 0xff); |
out |= v >> (-j); |
} |
*bp = (png_byte)(out & 0xff); |
} |
} |
352,22 → 357,22 |
for (bp = row, i = 0; i < istop; i++) |
{ |
int c = (int)(i%channels); |
png_uint_16 value, v; |
const unsigned int c = i%channels; |
int j; |
unsigned int value, v; |
v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); |
v = png_get_uint_16(bp); |
value = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); |
value |= v << j; |
else |
value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); |
value |= v >> (-j); |
} |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)((value >> 8) & 0xff); |
*bp++ = (png_byte)(value & 0xff); |
} |
} |
563,6 → 568,7 |
} |
} |
#endif |
#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
/* Undoes intrapixel differencing */ |
/programs/develop/libraries/libpng/pngwutil.c |
---|
1,8 → 1,8 |
/* pngwutil.c - utilities to write a PNG file |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 Glenn Randers-Pehrson |
* Last changed in libpng 1.6.2 [April 25, 2013] |
* Copyright (c) 1998-2013 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
29,23 → 29,6 |
buf[3] = (png_byte)(i & 0xff); |
} |
#ifdef PNG_SAVE_INT_32_SUPPORTED |
/* The png_save_int_32 function assumes integers are stored in two's |
* complement format. If this isn't the case, then this routine needs to |
* be modified to write data in two's complement format. Note that, |
* the following works correctly even if png_int_32 has more than 32 bits |
* (compare the more complex code required on read for sign extention.) |
*/ |
void PNGAPI |
png_save_int_32(png_bytep buf, png_int_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#endif |
/* Place a 16-bit number into a buffer in PNG byte order. |
* The parameter is declared unsigned int, not png_uint_16, |
* just to avoid potential problems on pre-ANSI C compilers. |
65,7 → 48,7 |
* bytes have already been written. |
*/ |
void PNGAPI |
png_write_sig(png_structp png_ptr) |
png_write_sig(png_structrp png_ptr) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
82,39 → 65,20 |
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; |
} |
/* Write a PNG chunk all at once. The type is an array of ASCII characters |
* representing the chunk name. The array must be at least 4 bytes in |
* length, and does not need to be null terminated. To be safe, pass the |
* pre-defined chunk names here, and if you need a new one, define it |
* where the others are defined. The length is the length of the data. |
* All the data must be present. If that is not possible, use the |
* png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() |
* functions instead. |
*/ |
void PNGAPI |
png_write_chunk(png_structp png_ptr, png_const_bytep chunk_name, |
png_const_bytep data, png_size_t length) |
{ |
if (png_ptr == NULL) |
return; |
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); |
png_write_chunk_data(png_ptr, data, (png_size_t)length); |
png_write_chunk_end(png_ptr); |
} |
/* Write the start of a PNG chunk. The type is the chunk type. |
* The total_length is the sum of the lengths of all the data you will be |
* passing in png_write_chunk_data(). |
*/ |
void PNGAPI |
png_write_chunk_start(png_structp png_ptr, png_const_bytep chunk_name, |
static void |
png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name, |
png_uint_32 length) |
{ |
png_byte buf[8]; |
png_debug2(0, "Writing %s chunk, length = %lu", chunk_name, |
(unsigned long)length); |
#if defined(PNG_DEBUG) && (PNG_DEBUG > 0) |
PNG_CSTRING_FROM_CHUNK(buf, chunk_name); |
png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length); |
#endif |
if (png_ptr == NULL) |
return; |
128,16 → 92,16 |
/* Write the length and the chunk name */ |
png_save_uint_32(buf, length); |
png_memcpy(buf + 4, chunk_name, 4); |
png_write_data(png_ptr, buf, (png_size_t)8); |
png_save_uint_32(buf + 4, chunk_name); |
png_write_data(png_ptr, buf, 8); |
/* Put the chunk name into png_ptr->chunk_name */ |
png_memcpy(png_ptr->chunk_name, chunk_name, 4); |
png_ptr->chunk_name = chunk_name; |
/* Reset the crc and run it over the chunk name */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, chunk_name, 4); |
png_calculate_crc(png_ptr, buf + 4, 4); |
#ifdef PNG_IO_STATE_SUPPORTED |
/* Inform the I/O callback that chunk data will (possibly) be written. |
147,13 → 111,20 |
#endif |
} |
/* Write the data of a PNG chunk started with png_write_chunk_start(). |
void PNGAPI |
png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string, |
png_uint_32 length) |
{ |
png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length); |
} |
/* Write the data of a PNG chunk started with png_write_chunk_header(). |
* Note that multiple calls to this function are allowed, and that the |
* sum of the lengths from these calls *must* add up to the total_length |
* given to png_write_chunk_start(). |
* given to png_write_chunk_header(). |
*/ |
void PNGAPI |
png_write_chunk_data(png_structp png_ptr, png_const_bytep data, |
png_write_chunk_data(png_structrp png_ptr, png_const_bytep data, |
png_size_t length) |
{ |
/* Write the data, and run the CRC over it */ |
171,9 → 142,9 |
} |
} |
/* Finish a chunk started with png_write_chunk_start(). */ |
/* Finish a chunk started with png_write_chunk_header(). */ |
void PNGAPI |
png_write_chunk_end(png_structp png_ptr) |
png_write_chunk_end(png_structrp png_ptr) |
{ |
png_byte buf[4]; |
192,253 → 163,587 |
png_write_data(png_ptr, buf, (png_size_t)4); |
} |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) |
/* This pair of functions encapsulates the operation of (a) compressing a |
* text string, and (b) issuing it later as a series of chunk data writes. |
* The compression_state structure is shared context for these functions |
* set up by the caller in order to make the whole mess thread-safe. |
/* Write a PNG chunk all at once. The type is an array of ASCII characters |
* representing the chunk name. The array must be at least 4 bytes in |
* length, and does not need to be null terminated. To be safe, pass the |
* pre-defined chunk names here, and if you need a new one, define it |
* where the others are defined. The length is the length of the data. |
* All the data must be present. If that is not possible, use the |
* png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() |
* functions instead. |
*/ |
static void |
png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name, |
png_const_bytep data, png_size_t length) |
{ |
if (png_ptr == NULL) |
return; |
typedef struct |
/* On 64 bit architectures 'length' may not fit in a png_uint_32. */ |
if (length > PNG_UINT_31_MAX) |
png_error(png_ptr, "length exceeds PNG maxima"); |
png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length); |
png_write_chunk_data(png_ptr, data, length); |
png_write_chunk_end(png_ptr); |
} |
/* This is the API that calls the internal function above. */ |
void PNGAPI |
png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string, |
png_const_bytep data, png_size_t length) |
{ |
png_const_bytep input; /* The uncompressed input data */ |
png_size_t input_len; /* Its length */ |
int num_output_ptr; /* Number of output pointers used */ |
int max_output_ptr; /* Size of output_ptr */ |
png_bytep *output_ptr; /* Array of pointers to output */ |
} compression_state; |
png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data, |
length); |
} |
/* Compress given text into storage in the png_ptr structure */ |
static int /* PRIVATE */ |
png_text_compress(png_structp png_ptr, |
png_const_charp text, png_size_t text_len, int compression, |
compression_state *comp) |
/* This is used below to find the size of an image to pass to png_deflate_claim, |
* so it only needs to be accurate if the size is less than 16384 bytes (the |
* point at which a lower LZ window size can be used.) |
*/ |
static png_alloc_size_t |
png_image_size(png_structrp png_ptr) |
{ |
int ret; |
/* Only return sizes up to the maximum of a png_uint_32, do this by limiting |
* the width and height used to 15 bits. |
*/ |
png_uint_32 h = png_ptr->height; |
comp->num_output_ptr = 0; |
comp->max_output_ptr = 0; |
comp->output_ptr = NULL; |
comp->input = NULL; |
comp->input_len = 0; |
if (png_ptr->rowbytes < 32768 && h < 32768) |
{ |
if (png_ptr->interlaced) |
{ |
/* Interlacing makes the image larger because of the replication of |
* both the filter byte and the padding to a byte boundary. |
*/ |
png_uint_32 w = png_ptr->width; |
unsigned int pd = png_ptr->pixel_depth; |
png_alloc_size_t cb_base; |
int pass; |
/* We may just want to pass the text right through */ |
if (compression == PNG_TEXT_COMPRESSION_NONE) |
for (cb_base=0, pass=0; pass<=6; ++pass) |
{ |
comp->input = (png_const_bytep)text; |
comp->input_len = text_len; |
return((int)text_len); |
png_uint_32 pw = PNG_PASS_COLS(w, pass); |
if (pw > 0) |
cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass); |
} |
if (compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[50]; |
png_snprintf(msg, 50, "Unknown compression type %d", compression); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "Unknown compression type"); |
#endif |
return cb_base; |
} |
/* We can't write the chunk until we find out how much data we have, |
* which means we need to run the compressor first and save the |
* output. This shouldn't be a problem, as the vast majority of |
* comments should be reasonable, but we will set up an array of |
* malloc'd pointers to be sure. |
* |
* If we knew the application was well behaved, we could simplify this |
* greatly by assuming we can always malloc an output buffer large |
* enough to hold the compressed text ((1001 * text_len / 1000) + 12) |
* and malloc this directly. The only time this would be a bad idea is |
* if we can't malloc more than 64K and we have 64K of random input |
* data, or if the input string is incredibly large (although this |
* wouldn't cause a failure, just a slowdown due to swapping). |
else |
return (png_ptr->rowbytes+1) * h; |
} |
else |
return 0xffffffffU; |
} |
#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED |
/* This is the code to hack the first two bytes of the deflate stream (the |
* deflate header) to correct the windowBits value to match the actual data |
* size. Note that the second argument is the *uncompressed* size but the |
* first argument is the *compressed* data (and it must be deflate |
* compressed.) |
*/ |
static void |
optimize_cmf(png_bytep data, png_alloc_size_t data_size) |
{ |
/* Optimize the CMF field in the zlib stream. The resultant zlib stream is |
* still compliant to the stream specification. |
*/ |
if (data_size <= 16384) /* else windowBits must be 15 */ |
{ |
unsigned int z_cmf = data[0]; /* zlib compression method and flags */ |
/* Set up the compression buffers */ |
/* TODO: the following cast hides a potential overflow problem. */ |
png_ptr->zstream.avail_in = (uInt)text_len; |
/* NOTE: assume zlib doesn't overwrite the input */ |
png_ptr->zstream.next_in = (Bytef *)text; |
png_ptr->zstream.avail_out = png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) |
{ |
unsigned int z_cinfo; |
unsigned int half_z_window_size; |
/* This is the same compression loop as in png_write_row() */ |
z_cinfo = z_cmf >> 4; |
half_z_window_size = 1U << (z_cinfo + 7); |
if (data_size <= half_z_window_size) /* else no change */ |
{ |
unsigned int tmp; |
do |
{ |
/* Compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
half_z_window_size >>= 1; |
--z_cinfo; |
} |
while (z_cinfo > 0 && data_size <= half_z_window_size); |
if (ret != Z_OK) |
z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); |
data[0] = (png_byte)z_cmf; |
tmp = data[1] & 0xe0; |
tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; |
data[1] = (png_byte)tmp; |
} |
} |
} |
} |
#else |
# define optimize_cmf(dp,dl) ((void)0) |
#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */ |
/* Initialize the compressor for the appropriate type of compression. */ |
static int |
png_deflate_claim(png_structrp png_ptr, png_uint_32 owner, |
png_alloc_size_t data_size) |
{ |
/* Error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
if (png_ptr->zowner != 0) |
{ |
char msg[64]; |
PNG_STRING_FROM_CHUNK(msg, owner); |
msg[4] = ':'; |
msg[5] = ' '; |
PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner); |
/* So the message that results is "<chunk> using zstream"; this is an |
* internal error, but is very useful for debugging. i18n requirements |
* are minimal. |
*/ |
(void)png_safecat(msg, (sizeof msg), 10, " using zstream"); |
# if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC |
png_warning(png_ptr, msg); |
/* Attempt sane error recovery */ |
if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */ |
{ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT"); |
return Z_STREAM_ERROR; |
} |
png_ptr->zowner = 0; |
# else |
png_error(png_ptr, msg); |
# endif |
} |
{ |
int level = png_ptr->zlib_level; |
int method = png_ptr->zlib_method; |
int windowBits = png_ptr->zlib_window_bits; |
int memLevel = png_ptr->zlib_mem_level; |
int strategy; /* set below */ |
int ret; /* zlib return code */ |
if (owner == png_IDAT) |
{ |
if (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) |
strategy = png_ptr->zlib_strategy; |
else if (png_ptr->do_filter != PNG_FILTER_NONE) |
strategy = PNG_Z_DEFAULT_STRATEGY; |
else |
png_error(png_ptr, "zlib error"); |
strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY; |
} |
/* Check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
else |
{ |
/* Make sure the output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
# ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED |
level = png_ptr->zlib_text_level; |
method = png_ptr->zlib_text_method; |
windowBits = png_ptr->zlib_text_window_bits; |
memLevel = png_ptr->zlib_text_mem_level; |
strategy = png_ptr->zlib_text_strategy; |
# else |
/* If customization is not supported the values all come from the |
* IDAT values except for the strategy, which is fixed to the |
* default. (This is the pre-1.6.0 behavior too, although it was |
* implemented in a very different way.) |
*/ |
strategy = Z_DEFAULT_STRATEGY; |
# endif |
} |
/* Adjust 'windowBits' down if larger than 'data_size'; to stop this |
* happening just pass 32768 as the data_size parameter. Notice that zlib |
* requires an extra 262 bytes in the window in addition to the data to be |
* able to see the whole of the data, so if data_size+262 takes us to the |
* next windowBits size we need to fix up the value later. (Because even |
* though deflate needs the extra window, inflate does not!) |
*/ |
if (data_size <= 16384) |
{ |
int old_max; |
/* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to |
* work round a Microsoft Visual C misbehavior which, contrary to C-90, |
* widens the result of the following shift to 64-bits if (and, |
* apparently, only if) it is used in a test. |
*/ |
unsigned int half_window_size = 1U << (windowBits-1); |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
while (data_size + 262 <= half_window_size) |
{ |
png_bytepp old_ptr; |
half_window_size >>= 1; |
--windowBits; |
} |
} |
old_ptr = comp->output_ptr; |
/* Check against the previous initialized values, if any. */ |
if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) && |
(png_ptr->zlib_set_level != level || |
png_ptr->zlib_set_method != method || |
png_ptr->zlib_set_window_bits != windowBits || |
png_ptr->zlib_set_mem_level != memLevel || |
png_ptr->zlib_set_strategy != strategy)) |
{ |
if (deflateEnd(&png_ptr->zstream) != Z_OK) |
png_warning(png_ptr, "deflateEnd failed (ignored)"); |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t) |
(comp->max_output_ptr * png_sizeof(png_charpp))); |
png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED; |
} |
png_memcpy(comp->output_ptr, old_ptr, old_max |
* png_sizeof(png_charp)); |
/* For safety clear out the input and output pointers (currently zlib |
* doesn't use them on Init, but it might in the future). |
*/ |
png_ptr->zstream.next_in = NULL; |
png_ptr->zstream.avail_in = 0; |
png_ptr->zstream.next_out = NULL; |
png_ptr->zstream.avail_out = 0; |
png_free(png_ptr, old_ptr); |
/* Now initialize if required, setting the new parameters, otherwise just |
* to a simple reset to the previous parameters. |
*/ |
if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) |
ret = deflateReset(&png_ptr->zstream); |
else |
{ |
ret = deflateInit2(&png_ptr->zstream, level, method, windowBits, |
memLevel, strategy); |
if (ret == Z_OK) |
png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED; |
} |
/* The return code is from either deflateReset or deflateInit2; they have |
* pretty much the same set of error codes. |
*/ |
if (ret == Z_OK) |
png_ptr->zowner = owner; |
else |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t) |
(comp->max_output_ptr * png_sizeof(png_charp))); |
png_zstream_error(png_ptr, ret); |
return ret; |
} |
} |
/* Save the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)png_ptr->zbuf_size); |
/* Clean up (or trim) a linked list of compression buffers. */ |
void /* PRIVATE */ |
png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp) |
{ |
png_compression_bufferp list = *listp; |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
if (list != NULL) |
{ |
*listp = NULL; |
comp->num_output_ptr++; |
do |
{ |
png_compression_bufferp next = list->next; |
/* and reset the buffer */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_free(png_ptr, list); |
list = next; |
} |
/* Continue until we don't have any more to compress */ |
} while (png_ptr->zstream.avail_in); |
while (list != NULL); |
} |
} |
/* Finish the compression */ |
do |
#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED |
/* This pair of functions encapsulates the operation of (a) compressing a |
* text string, and (b) issuing it later as a series of chunk data writes. |
* The compression_state structure is shared context for these functions |
* set up by the caller to allow access to the relevant local variables. |
* |
* compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size |
* temporary buffers. From 1.6.0 it is retained in png_struct so that it will |
* be correctly freed in the event of a write error (previous implementations |
* just leaked memory.) |
*/ |
typedef struct |
{ |
/* Tell zlib we are finished */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
png_const_bytep input; /* The uncompressed input data */ |
png_alloc_size_t input_len; /* Its length */ |
png_uint_32 output_len; /* Final compressed length */ |
png_byte output[1024]; /* First block of output */ |
} compression_state; |
if (ret == Z_OK) |
static void |
png_text_compress_init(compression_state *comp, png_const_bytep input, |
png_alloc_size_t input_len) |
{ |
/* Check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
comp->input = input; |
comp->input_len = input_len; |
comp->output_len = 0; |
} |
/* Compress the data in the compression state input */ |
static int |
png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name, |
compression_state *comp, png_uint_32 prefix_len) |
{ |
/* Check to make sure our output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
int ret; |
/* To find the length of the output it is necessary to first compress the |
* input, the result is buffered rather than using the two-pass algorithm |
* that is used on the inflate side; deflate is assumed to be slower and a |
* PNG writer is assumed to have more memory available than a PNG reader. |
* |
* IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an |
* upper limit on the output size, but it is always bigger than the input |
* size so it is likely to be more efficient to use this linked-list |
* approach. |
*/ |
ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len); |
if (ret != Z_OK) |
return ret; |
/* Set up the compression buffers, we need a loop here to avoid overflowing a |
* uInt. Use ZLIB_IO_MAX to limit the input. The output is always limited |
* by the output buffer size, so there is no need to check that. Since this |
* is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits |
* in size. |
*/ |
{ |
int old_max; |
png_compression_bufferp *end = &png_ptr->zbuffer_list; |
png_alloc_size_t input_len = comp->input_len; /* may be zero! */ |
png_uint_32 output_len; |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
/* zlib updates these for us: */ |
png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input); |
png_ptr->zstream.avail_in = 0; /* Set below */ |
png_ptr->zstream.next_out = comp->output; |
png_ptr->zstream.avail_out = (sizeof comp->output); |
output_len = png_ptr->zstream.avail_out; |
do |
{ |
png_bytepp old_ptr; |
uInt avail_in = ZLIB_IO_MAX; |
old_ptr = comp->output_ptr; |
if (avail_in > input_len) |
avail_in = (uInt)input_len; |
/* This could be optimized to realloc() */ |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t)(comp->max_output_ptr * |
png_sizeof(png_charp))); |
input_len -= avail_in; |
png_memcpy(comp->output_ptr, old_ptr, |
old_max * png_sizeof(png_charp)); |
png_ptr->zstream.avail_in = avail_in; |
png_free(png_ptr, old_ptr); |
if (png_ptr->zstream.avail_out == 0) |
{ |
png_compression_buffer *next; |
/* Chunk data is limited to 2^31 bytes in length, so the prefix |
* length must be counted here. |
*/ |
if (output_len + prefix_len > PNG_UINT_31_MAX) |
{ |
ret = Z_MEM_ERROR; |
break; |
} |
else |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t)(comp->max_output_ptr * |
png_sizeof(png_charp))); |
/* Need a new (malloc'ed) buffer, but there may be one present |
* already. |
*/ |
next = *end; |
if (next == NULL) |
{ |
next = png_voidcast(png_compression_bufferp, png_malloc_base |
(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); |
if (next == NULL) |
{ |
ret = Z_MEM_ERROR; |
break; |
} |
/* Save the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)png_ptr->zbuf_size); |
/* Link in this buffer (so that it will be freed later) */ |
next->next = NULL; |
*end = next; |
} |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
png_ptr->zstream.next_out = next->output; |
png_ptr->zstream.avail_out = png_ptr->zbuffer_size; |
output_len += png_ptr->zstream.avail_out; |
comp->num_output_ptr++; |
/* Move 'end' to the next buffer pointer. */ |
end = &next->next; |
} |
/* and reset the buffer pointers */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
/* Compress the data */ |
ret = deflate(&png_ptr->zstream, |
input_len > 0 ? Z_NO_FLUSH : Z_FINISH); |
/* Claw back input data that was not consumed (because avail_in is |
* reset above every time round the loop). |
*/ |
input_len += png_ptr->zstream.avail_in; |
png_ptr->zstream.avail_in = 0; /* safety */ |
} |
while (ret == Z_OK); |
/* There may be some space left in the last output buffer, this needs to |
* be subtracted from output_len. |
*/ |
output_len -= png_ptr->zstream.avail_out; |
png_ptr->zstream.avail_out = 0; /* safety */ |
comp->output_len = output_len; |
/* Now double check the output length, put in a custom message if it is |
* too long. Otherwise ensure the z_stream::msg pointer is set to |
* something. |
*/ |
if (output_len + prefix_len >= PNG_UINT_31_MAX) |
{ |
png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long"); |
ret = Z_MEM_ERROR; |
} |
else if (ret != Z_STREAM_END) |
{ |
/* We got an error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
png_zstream_error(png_ptr, ret); |
/* Text length is number of buffers plus last buffer */ |
text_len = png_ptr->zbuf_size * comp->num_output_ptr; |
/* Reset zlib for another zTXt/iTXt or image data */ |
png_ptr->zowner = 0; |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; |
/* The only success case is Z_STREAM_END, input_len must be 0, if not this |
* is an internal error. |
*/ |
if (ret == Z_STREAM_END && input_len == 0) |
{ |
/* Fix up the deflate header, if required */ |
optimize_cmf(comp->output, comp->input_len); |
return((int)text_len); |
/* But Z_OK is returned, not Z_STREAM_END; this allows the claim |
* function above to return Z_STREAM_END on an error (though it never |
* does in the current versions of zlib.) |
*/ |
return Z_OK; |
} |
else |
return ret; |
} |
} |
/* Ship the compressed text out via chunk writes */ |
static void /* PRIVATE */ |
png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) |
static void |
png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp) |
{ |
int i; |
png_uint_32 output_len = comp->output_len; |
png_const_bytep output = comp->output; |
png_uint_32 avail = (sizeof comp->output); |
png_compression_buffer *next = png_ptr->zbuffer_list; |
/* Handle the no-compression case */ |
if (comp->input) |
for (;;) |
{ |
png_write_chunk_data(png_ptr, comp->input, comp->input_len); |
if (avail > output_len) |
avail = output_len; |
return; |
png_write_chunk_data(png_ptr, output, avail); |
output_len -= avail; |
if (output_len == 0 || next == NULL) |
break; |
avail = png_ptr->zbuffer_size; |
output = next->output; |
next = next->next; |
} |
/* Write saved output buffers, if any */ |
for (i = 0; i < comp->num_output_ptr; i++) |
/* This is an internal error; 'next' must have been NULL! */ |
if (output_len > 0) |
png_error(png_ptr, "error writing ancillary chunked compressed data"); |
} |
#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, |
* and if invalid, correct the keyword rather than discarding the entire |
* chunk. The PNG 1.0 specification requires keywords 1-79 characters in |
* length, forbids leading or trailing whitespace, multiple internal spaces, |
* and the non-break space (0x80) from ISO 8859-1. Returns keyword length. |
* |
* The 'new_key' buffer must be 80 characters in size (for the keyword plus a |
* trailing '\0'). If this routine returns 0 then there was no keyword, or a |
* valid one could not be generated, and the caller must png_error. |
*/ |
static png_uint_32 |
png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key) |
{ |
png_write_chunk_data(png_ptr, comp->output_ptr[i], |
(png_size_t)png_ptr->zbuf_size); |
png_const_charp orig_key = key; |
png_uint_32 key_len = 0; |
int bad_character = 0; |
int space = 1; |
png_free(png_ptr, comp->output_ptr[i]); |
png_debug(1, "in png_check_keyword"); |
if (key == NULL) |
{ |
*new_key = 0; |
return 0; |
} |
if (comp->max_output_ptr != 0) |
png_free(png_ptr, comp->output_ptr); |
while (*key && key_len < 79) |
{ |
png_byte ch = (png_byte)(0xff & *key++); |
/* Write anything left in zbuf */ |
if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) |
png_write_chunk_data(png_ptr, png_ptr->zbuf, |
(png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); |
if ((ch > 32 && ch <= 126) || (ch >= 161 /*&& ch <= 255*/)) |
*new_key++ = ch, ++key_len, space = 0; |
/* Reset zlib for another zTXt/iTXt or image data */ |
deflateReset(&png_ptr->zstream); |
png_ptr->zstream.data_type = Z_BINARY; |
else if (!space) |
{ |
/* A space or an invalid character when one wasn't seen immediately |
* before; output just a space. |
*/ |
*new_key++ = 32, ++key_len, space = 1; |
/* If the character was not a space then it is invalid. */ |
if (ch != 32) |
bad_character = ch; |
} |
else if (!bad_character) |
bad_character = ch; /* just skip it, record the first error */ |
} |
if (key_len > 0 && space) /* trailing space */ |
{ |
--key_len, --new_key; |
if (!bad_character) |
bad_character = 32; |
} |
/* Terminate the keyword */ |
*new_key = 0; |
if (key_len == 0) |
return 0; |
/* Try to only output one warning per keyword: */ |
if (*key) /* keyword too long */ |
png_warning(png_ptr, "keyword truncated"); |
else if (bad_character) |
{ |
PNG_WARNING_PARAMETERS(p) |
png_warning_parameter(p, 1, orig_key); |
png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_02x, bad_character); |
png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'"); |
} |
return key_len; |
} |
#endif |
/* Write the IHDR chunk, and update the png_struct with the necessary |
446,13 → 751,10 |
* information being correct. |
*/ |
void /* PRIVATE */ |
png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, |
png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height, |
int bit_depth, int color_type, int compression_type, int filter_type, |
int interlace_type) |
{ |
PNG_IHDR; |
int ret; |
png_byte buf[13]; /* Buffer to store the IHDR info */ |
png_debug(1, "in png_write_IHDR"); |
594,13 → 896,8 |
buf[12] = (png_byte)interlace_type; |
/* Write the chunk */ |
png_write_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); |
png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); |
/* Initialize zlib with PNG info */ |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
if (!(png_ptr->do_filter)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || |
611,67 → 908,17 |
png_ptr->do_filter = PNG_ALL_FILTERS; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) |
{ |
if (png_ptr->do_filter != PNG_FILTER_NONE) |
png_ptr->zlib_strategy = Z_FILTERED; |
else |
png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; |
png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */ |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) |
png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) |
png_ptr->zlib_mem_level = 8; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) |
png_ptr->zlib_window_bits = 15; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) |
png_ptr->zlib_method = 8; |
ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, |
png_ptr->zlib_method, png_ptr->zlib_window_bits, |
png_ptr->zlib_mem_level, png_ptr->zlib_strategy); |
if (ret != Z_OK) |
{ |
if (ret == Z_VERSION_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- version error"); |
if (ret == Z_STREAM_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- stream error"); |
if (ret == Z_MEM_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- mem error"); |
png_error(png_ptr, "zlib failed to initialize compressor"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
/* libpng is not interested in zstream.data_type, so set it |
* to a predefined value, to avoid its evaluation inside zlib |
*/ |
png_ptr->zstream.data_type = Z_BINARY; |
png_ptr->mode = PNG_HAVE_IHDR; |
} |
/* Write the palette. We are careful not to trust png_color to be in the |
* correct order for PNG, so people can redefine it to any convenient |
* structure. |
*/ |
void /* PRIVATE */ |
png_write_PLTE(png_structp png_ptr, png_const_colorp palette, |
png_write_PLTE(png_structrp png_ptr, png_const_colorp palette, |
png_uint_32 num_pal) |
{ |
PNG_PLTE; |
png_uint_32 i; |
png_const_colorp pal_ptr; |
png_byte buf[3]; |
707,7 → 954,7 |
png_ptr->num_palette = (png_uint_16)num_pal; |
png_debug1(3, "num_palette = %d", png_ptr->num_palette); |
png_write_chunk_start(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3)); |
png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3)); |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) |
737,73 → 984,169 |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
/* Write an IDAT chunk */ |
/* This is similar to png_text_compress, above, except that it does not require |
* all of the data at once and, instead of buffering the compressed result, |
* writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out |
* because it calls the write interface. As a result it does its own error |
* reporting and does not return an error code. In the event of error it will |
* just call png_error. The input data length may exceed 32-bits. The 'flush' |
* parameter is exactly the same as that to deflate, with the following |
* meanings: |
* |
* Z_NO_FLUSH: normal incremental output of compressed data |
* Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush |
* Z_FINISH: this is the end of the input, do a Z_FINISH and clean up |
* |
* The routine manages the acquire and release of the png_ptr->zstream by |
* checking and (at the end) clearing png_ptr->zowner, it does some sanity |
* checks on the 'mode' flags while doing this. |
*/ |
void /* PRIVATE */ |
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) |
png_compress_IDAT(png_structrp png_ptr, png_const_bytep input, |
png_alloc_size_t input_len, int flush) |
{ |
PNG_IDAT; |
if (png_ptr->zowner != png_IDAT) |
{ |
/* First time. Ensure we have a temporary buffer for compression and |
* trim the buffer list if it has more than one entry to free memory. |
* If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been |
* created at this point, but the check here is quick and safe. |
*/ |
if (png_ptr->zbuffer_list == NULL) |
{ |
png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp, |
png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); |
png_ptr->zbuffer_list->next = NULL; |
} |
png_debug(1, "in png_write_IDAT"); |
else |
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next); |
/* Optimize the CMF field in the zlib stream. */ |
/* This hack of the zlib stream is compliant to the stream specification. */ |
/* It is a terminal error if we can't claim the zstream. */ |
if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg); |
/* The output state is maintained in png_ptr->zstream, so it must be |
* initialized here after the claim. |
*/ |
png_ptr->zstream.next_out = png_ptr->zbuffer_list->output; |
png_ptr->zstream.avail_out = png_ptr->zbuffer_size; |
} |
/* Now loop reading and writing until all the input is consumed or an error |
* terminates the operation. The _out values are maintained across calls to |
* this function, but the input must be reset each time. |
*/ |
png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input); |
png_ptr->zstream.avail_in = 0; /* set below */ |
for (;;) |
{ |
int ret; |
/* INPUT: from the row data */ |
uInt avail = ZLIB_IO_MAX; |
if (avail > input_len) |
avail = (uInt)input_len; /* safe because of the check */ |
png_ptr->zstream.avail_in = avail; |
input_len -= avail; |
ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush); |
/* Include as-yet unconsumed input */ |
input_len += png_ptr->zstream.avail_in; |
png_ptr->zstream.avail_in = 0; |
/* OUTPUT: write complete IDAT chunks when avail_out drops to zero, note |
* that these two zstream fields are preserved across the calls, therefore |
* there is no need to set these up on entry to the loop. |
*/ |
if (png_ptr->zstream.avail_out == 0) |
{ |
png_bytep data = png_ptr->zbuffer_list->output; |
uInt size = png_ptr->zbuffer_size; |
/* Write an IDAT containing the data then reset the buffer. The |
* first IDAT may need deflate header optimization. |
*/ |
# ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED |
if (!(png_ptr->mode & PNG_HAVE_IDAT) && |
png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) |
optimize_cmf(data, png_image_size(png_ptr)); |
# endif |
png_write_complete_chunk(png_ptr, png_IDAT, data, size); |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_ptr->zstream.next_out = data; |
png_ptr->zstream.avail_out = size; |
/* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with |
* the same flush parameter until it has finished output, for NO_FLUSH |
* it doesn't matter. |
*/ |
if (ret == Z_OK && flush != Z_NO_FLUSH) |
continue; |
} |
/* The order of these checks doesn't matter much; it just effect which |
* possible error might be detected if multiple things go wrong at once. |
*/ |
if (ret == Z_OK) /* most likely return code! */ |
{ |
unsigned int z_cmf = data[0]; /* zlib compression method and flags */ |
if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) |
{ |
/* Avoid memory underflows and multiplication overflows. |
* |
* The conditions below are practically always satisfied; |
* however, they still must be checked. |
/* If all the input has been consumed then just return. If Z_FINISH |
* was used as the flush parameter something has gone wrong if we get |
* here. |
*/ |
if (length >= 2 && |
png_ptr->height < 16384 && png_ptr->width < 16384) |
if (input_len == 0) |
{ |
png_uint_32 uncompressed_idat_size = png_ptr->height * |
((png_ptr->width * |
png_ptr->channels * png_ptr->bit_depth + 15) >> 3); |
unsigned int z_cinfo = z_cmf >> 4; |
unsigned int half_z_window_size = 1 << (z_cinfo + 7); |
while (uncompressed_idat_size <= half_z_window_size && |
half_z_window_size >= 256) |
{ |
z_cinfo--; |
half_z_window_size >>= 1; |
if (flush == Z_FINISH) |
png_error(png_ptr, "Z_OK on Z_FINISH with output space"); |
return; |
} |
} |
z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); |
else if (ret == Z_STREAM_END && flush == Z_FINISH) |
{ |
/* This is the end of the IDAT data; any pending output must be |
* flushed. For small PNG files we may still be at the beginning. |
*/ |
png_bytep data = png_ptr->zbuffer_list->output; |
uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out; |
if (data[0] != z_cmf) |
{ |
int tmp; |
data[0] = (png_byte)z_cmf; |
tmp = data[1] & 0xe0; |
tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; |
data[1] = (png_byte)tmp; |
# ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED |
if (!(png_ptr->mode & PNG_HAVE_IDAT) && |
png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) |
optimize_cmf(data, png_image_size(png_ptr)); |
# endif |
png_write_complete_chunk(png_ptr, png_IDAT, data, size); |
png_ptr->zstream.avail_out = 0; |
png_ptr->zstream.next_out = NULL; |
png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT; |
png_ptr->zowner = 0; /* Release the stream */ |
return; |
} |
} |
} |
else |
png_error(png_ptr, |
"Invalid zlib compression method or flags in IDAT"); |
{ |
/* This is an error condition. */ |
png_zstream_error(png_ptr, ret); |
png_error(png_ptr, png_ptr->zstream.msg); |
} |
png_write_chunk(png_ptr, png_IDAT, data, length); |
png_ptr->mode |= PNG_HAVE_IDAT; |
} |
} |
/* Write an IEND chunk */ |
void /* PRIVATE */ |
png_write_IEND(png_structp png_ptr) |
png_write_IEND(png_structrp png_ptr) |
{ |
PNG_IEND; |
png_debug(1, "in png_write_IEND"); |
png_write_chunk(png_ptr, png_IEND, NULL, (png_size_t)0); |
png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0); |
png_ptr->mode |= PNG_HAVE_IEND; |
} |
810,9 → 1153,8 |
#ifdef PNG_WRITE_gAMA_SUPPORTED |
/* Write a gAMA chunk */ |
void /* PRIVATE */ |
png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) |
png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma) |
{ |
PNG_gAMA; |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA"); |
819,7 → 1161,7 |
/* file_gamma is saved in 1/100,000ths */ |
png_save_uint_32(buf, (png_uint_32)file_gamma); |
png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); |
png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); |
} |
#endif |
826,9 → 1168,8 |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
/* Write a sRGB chunk */ |
void /* PRIVATE */ |
png_write_sRGB(png_structp png_ptr, int srgb_intent) |
png_write_sRGB(png_structrp png_ptr, int srgb_intent) |
{ |
PNG_sRGB; |
png_byte buf[1]; |
png_debug(1, "in png_write_sRGB"); |
838,7 → 1179,7 |
"Invalid sRGB rendering intent specified"); |
buf[0]=(png_byte)srgb_intent; |
png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); |
png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); |
} |
#endif |
845,83 → 1186,60 |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
/* Write an iCCP chunk */ |
void /* PRIVATE */ |
png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type, |
png_const_charp profile, int profile_len) |
png_write_iCCP(png_structrp png_ptr, png_const_charp name, |
png_const_bytep profile) |
{ |
PNG_iCCP; |
png_size_t name_len; |
png_charp new_name; |
png_uint_32 name_len; |
png_uint_32 profile_len; |
png_byte new_name[81]; /* 1 byte for the compression byte */ |
compression_state comp; |
int embedded_profile_len = 0; |
png_debug(1, "in png_write_iCCP"); |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
comp.input_len = 0; |
if ((name_len = png_check_keyword(png_ptr, name, &new_name)) == 0) |
return; |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_warning(png_ptr, "Unknown compression type in iCCP chunk"); |
/* These are all internal problems: the profile should have been checked |
* before when it was stored. |
*/ |
if (profile == NULL) |
profile_len = 0; |
png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */ |
if (profile_len > 3) |
embedded_profile_len = |
((*( (png_const_bytep)profile ))<<24) | |
((*( (png_const_bytep)profile + 1))<<16) | |
((*( (png_const_bytep)profile + 2))<< 8) | |
((*( (png_const_bytep)profile + 3)) ); |
profile_len = png_get_uint_32(profile); |
if (embedded_profile_len < 0) |
{ |
png_warning(png_ptr, |
"Embedded profile length in iCCP chunk is negative"); |
if (profile_len < 132) |
png_error(png_ptr, "ICC profile too short"); |
png_free(png_ptr, new_name); |
return; |
} |
if (profile_len & 0x03) |
png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)"); |
if (profile_len < embedded_profile_len) |
{ |
png_warning(png_ptr, |
"Embedded profile length too large in iCCP chunk"); |
png_uint_32 embedded_profile_len = png_get_uint_32(profile); |
png_free(png_ptr, new_name); |
return; |
if (profile_len != embedded_profile_len) |
png_error(png_ptr, "Profile length does not match profile"); |
} |
if (profile_len > embedded_profile_len) |
{ |
png_warning(png_ptr, |
"Truncating profile to actual length in iCCP chunk"); |
name_len = png_check_keyword(png_ptr, name, new_name); |
profile_len = embedded_profile_len; |
} |
if (name_len == 0) |
png_error(png_ptr, "iCCP: invalid keyword"); |
if (profile_len) |
profile_len = png_text_compress(png_ptr, profile, |
(png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp); |
new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE; |
/* Make sure we include the NULL after the name and the compression type */ |
png_write_chunk_start(png_ptr, png_iCCP, |
(png_uint_32)(name_len + profile_len + 2)); |
++name_len; |
new_name[name_len + 1] = 0x00; |
png_text_compress_init(&comp, profile, profile_len); |
png_write_chunk_data(png_ptr, (png_bytep)new_name, |
(png_size_t)(name_len + 2)); |
/* Allow for keyword terminator and compression byte */ |
if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg); |
if (profile_len) |
png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len); |
png_write_chunk_data(png_ptr, new_name, name_len); |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
928,11 → 1246,10 |
#ifdef PNG_WRITE_sPLT_SUPPORTED |
/* Write a sPLT chunk */ |
void /* PRIVATE */ |
png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette) |
png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette) |
{ |
PNG_sPLT; |
png_size_t name_len; |
png_charp new_name; |
png_uint_32 name_len; |
png_byte new_name[80]; |
png_byte entrybuf[10]; |
png_size_t entry_size = (spalette->depth == 8 ? 6 : 10); |
png_size_t palette_size = entry_size * spalette->nentries; |
943,11 → 1260,13 |
png_debug(1, "in png_write_sPLT"); |
if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0) |
return; |
name_len = png_check_keyword(png_ptr, spalette->name, new_name); |
if (name_len == 0) |
png_error(png_ptr, "sPLT: invalid keyword"); |
/* Make sure we include the NULL after the name */ |
png_write_chunk_start(png_ptr, png_sPLT, |
png_write_chunk_header(png_ptr, png_sPLT, |
(png_uint_32)(name_len + 2 + palette_size)); |
png_write_chunk_data(png_ptr, (png_bytep)new_name, |
977,7 → 1296,7 |
png_save_uint_16(entrybuf + 8, ep->frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); |
png_write_chunk_data(png_ptr, entrybuf, entry_size); |
} |
#else |
ep=spalette->entries; |
1001,12 → 1320,11 |
png_save_uint_16(entrybuf + 8, ep[i].frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); |
png_write_chunk_data(png_ptr, entrybuf, entry_size); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
1013,9 → 1331,8 |
#ifdef PNG_WRITE_sBIT_SUPPORTED |
/* Write the sBIT chunk */ |
void /* PRIVATE */ |
png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type) |
png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type) |
{ |
PNG_sBIT; |
png_byte buf[4]; |
png_size_t size; |
1066,7 → 1383,7 |
buf[size++] = sbit->alpha; |
} |
png_write_chunk(png_ptr, png_sBIT, buf, size); |
png_write_complete_chunk(png_ptr, png_sBIT, buf, size); |
} |
#endif |
1073,46 → 1390,35 |
#ifdef PNG_WRITE_cHRM_SUPPORTED |
/* Write the cHRM chunk */ |
void /* PRIVATE */ |
png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, |
png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, |
png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, |
png_fixed_point blue_y) |
png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy) |
{ |
PNG_cHRM; |
png_byte buf[32]; |
png_debug(1, "in png_write_cHRM"); |
/* Each value is saved in 1/100,000ths */ |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y, |
green_x, green_y, blue_x, blue_y)) |
#endif |
{ |
png_save_uint_32(buf, (png_uint_32)white_x); |
png_save_uint_32(buf + 4, (png_uint_32)white_y); |
png_save_int_32(buf, xy->whitex); |
png_save_int_32(buf + 4, xy->whitey); |
png_save_uint_32(buf + 8, (png_uint_32)red_x); |
png_save_uint_32(buf + 12, (png_uint_32)red_y); |
png_save_int_32(buf + 8, xy->redx); |
png_save_int_32(buf + 12, xy->redy); |
png_save_uint_32(buf + 16, (png_uint_32)green_x); |
png_save_uint_32(buf + 20, (png_uint_32)green_y); |
png_save_int_32(buf + 16, xy->greenx); |
png_save_int_32(buf + 20, xy->greeny); |
png_save_uint_32(buf + 24, (png_uint_32)blue_x); |
png_save_uint_32(buf + 28, (png_uint_32)blue_y); |
png_save_int_32(buf + 24, xy->bluex); |
png_save_int_32(buf + 28, xy->bluey); |
png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32); |
png_write_complete_chunk(png_ptr, png_cHRM, buf, 32); |
} |
} |
#endif |
#ifdef PNG_WRITE_tRNS_SUPPORTED |
/* Write the tRNS chunk */ |
void /* PRIVATE */ |
png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha, |
png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha, |
png_const_color_16p tran, int num_trans, int color_type) |
{ |
PNG_tRNS; |
png_byte buf[6]; |
png_debug(1, "in png_write_tRNS"); |
1121,12 → 1427,14 |
{ |
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Invalid number of transparent colors specified"); |
png_app_warning(png_ptr, |
"Invalid number of transparent colors specified"); |
return; |
} |
/* Write the chunk out as it is */ |
png_write_chunk(png_ptr, png_tRNS, trans_alpha, (png_size_t)num_trans); |
png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha, |
(png_size_t)num_trans); |
} |
else if (color_type == PNG_COLOR_TYPE_GRAY) |
1134,7 → 1442,7 |
/* One 16 bit value */ |
if (tran->gray >= (1 << png_ptr->bit_depth)) |
{ |
png_warning(png_ptr, |
png_app_warning(png_ptr, |
"Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); |
return; |
1141,7 → 1449,7 |
} |
png_save_uint_16(buf, tran->gray); |
png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)2); |
png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2); |
} |
else if (color_type == PNG_COLOR_TYPE_RGB) |
1156,17 → 1464,17 |
if (buf[0] | buf[2] | buf[4]) |
#endif |
{ |
png_warning(png_ptr, |
png_app_warning(png_ptr, |
"Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); |
png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); |
} |
else |
{ |
png_warning(png_ptr, "Can't write tRNS with an alpha channel"); |
png_app_warning(png_ptr, "Can't write tRNS with an alpha channel"); |
} |
} |
#endif |
1174,9 → 1482,8 |
#ifdef PNG_WRITE_bKGD_SUPPORTED |
/* Write the background chunk */ |
void /* PRIVATE */ |
png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type) |
png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type) |
{ |
PNG_bKGD; |
png_byte buf[6]; |
png_debug(1, "in png_write_bKGD"); |
1195,7 → 1502,7 |
} |
buf[0] = back->index; |
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)1); |
png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1); |
} |
else if (color_type & PNG_COLOR_MASK_COLOR) |
1215,7 → 1522,7 |
return; |
} |
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)6); |
png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6); |
} |
else |
1229,7 → 1536,7 |
} |
png_save_uint_16(buf, back->gray); |
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)2); |
png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2); |
} |
} |
#endif |
1237,9 → 1544,8 |
#ifdef PNG_WRITE_hIST_SUPPORTED |
/* Write the histogram */ |
void /* PRIVATE */ |
png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist) |
png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist) |
{ |
PNG_hIST; |
int i; |
png_byte buf[3]; |
1254,7 → 1560,7 |
return; |
} |
png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); |
png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); |
for (i = 0; i < num_hist; i++) |
{ |
1266,166 → 1572,34 |
} |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, |
* and if invalid, correct the keyword rather than discarding the entire |
* chunk. The PNG 1.0 specification requires keywords 1-79 characters in |
* length, forbids leading or trailing whitespace, multiple internal spaces, |
* and the non-break space (0x80) from ISO 8859-1. Returns keyword length. |
* |
* The new_key is allocated to hold the corrected keyword and must be freed |
* by the calling routine. This avoids problems with trying to write to |
* static keywords without having to have duplicate copies of the strings. |
*/ |
png_size_t /* PRIVATE */ |
png_check_keyword(png_structp png_ptr, png_const_charp key, png_charpp new_key) |
{ |
png_size_t key_len; |
png_const_charp ikp; |
png_charp kp, dp; |
int kflag; |
int kwarn=0; |
png_debug(1, "in png_check_keyword"); |
*new_key = NULL; |
if (key == NULL || (key_len = png_strlen(key)) == 0) |
{ |
png_warning(png_ptr, "zero length keyword"); |
return ((png_size_t)0); |
} |
png_debug1(2, "Keyword to be checked is '%s'", key); |
*new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); |
if (*new_key == NULL) |
{ |
png_warning(png_ptr, "Out of memory while procesing keyword"); |
return ((png_size_t)0); |
} |
/* Replace non-printing characters with a blank and print a warning */ |
for (ikp = key, dp = *new_key; *ikp != '\0'; ikp++, dp++) |
{ |
if ((png_byte)*ikp < 0x20 || |
((png_byte)*ikp > 0x7E && (png_byte)*ikp < 0xA1)) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[40]; |
png_snprintf(msg, 40, |
"invalid keyword character 0x%02X", (png_byte)*ikp); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "invalid character in keyword"); |
#endif |
*dp = ' '; |
} |
else |
{ |
*dp = *ikp; |
} |
} |
*dp = '\0'; |
/* Remove any trailing white space. */ |
kp = *new_key + key_len - 1; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "trailing spaces removed from keyword"); |
while (*kp == ' ') |
{ |
*(kp--) = '\0'; |
key_len--; |
} |
} |
/* Remove any leading white space. */ |
kp = *new_key; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "leading spaces removed from keyword"); |
while (*kp == ' ') |
{ |
kp++; |
key_len--; |
} |
} |
png_debug1(2, "Checking for multiple internal spaces in '%s'", kp); |
/* Remove multiple internal spaces. */ |
for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) |
{ |
if (*kp == ' ' && kflag == 0) |
{ |
*(dp++) = *kp; |
kflag = 1; |
} |
else if (*kp == ' ') |
{ |
key_len--; |
kwarn = 1; |
} |
else |
{ |
*(dp++) = *kp; |
kflag = 0; |
} |
} |
*dp = '\0'; |
if (kwarn) |
png_warning(png_ptr, "extra interior spaces removed from keyword"); |
if (key_len == 0) |
{ |
png_free(png_ptr, *new_key); |
png_warning(png_ptr, "Zero length keyword"); |
} |
if (key_len > 79) |
{ |
png_warning(png_ptr, "keyword length must be 1 - 79 characters"); |
(*new_key)[79] = '\0'; |
key_len = 79; |
} |
return (key_len); |
} |
#endif |
#ifdef PNG_WRITE_tEXt_SUPPORTED |
/* Write a tEXt chunk */ |
void /* PRIVATE */ |
png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text, |
png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, |
png_size_t text_len) |
{ |
PNG_tEXt; |
png_size_t key_len; |
png_charp new_key; |
png_uint_32 key_len; |
png_byte new_key[80]; |
png_debug(1, "in png_write_tEXt"); |
if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
return; |
key_len = png_check_keyword(png_ptr, key, new_key); |
if (key_len == 0) |
png_error(png_ptr, "tEXt: invalid keyword"); |
if (text == NULL || *text == '\0') |
text_len = 0; |
else |
text_len = png_strlen(text); |
text_len = strlen(text); |
if (text_len > PNG_UINT_31_MAX - (key_len+1)) |
png_error(png_ptr, "tEXt: text too long"); |
/* Make sure we include the 0 after the key */ |
png_write_chunk_start(png_ptr, png_tEXt, |
(png_uint_32)(key_len + text_len + 1)); |
png_write_chunk_header(png_ptr, png_tEXt, |
(png_uint_32)/*checked above*/(key_len + text_len + 1)); |
/* |
* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
1432,15 → 1606,12 |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, |
(png_size_t)(key_len + 1)); |
png_write_chunk_data(png_ptr, new_key, key_len + 1); |
if (text_len) |
png_write_chunk_data(png_ptr, (png_const_bytep)text, |
(png_size_t)text_len); |
png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
} |
#endif |
1447,57 → 1618,47 |
#ifdef PNG_WRITE_zTXt_SUPPORTED |
/* Write a compressed text chunk */ |
void /* PRIVATE */ |
png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text, |
png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, |
png_size_t text_len, int compression) |
{ |
PNG_zTXt; |
png_size_t key_len; |
png_byte buf; |
png_charp new_key; |
png_uint_32 key_len; |
png_byte new_key[81]; |
compression_state comp; |
png_debug(1, "in png_write_zTXt"); |
PNG_UNUSED(text_len) /* Always use strlen */ |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
comp.input_len = 0; |
if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) |
if (compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
png_free(png_ptr, new_key); |
png_write_tEXt(png_ptr, key, text, 0); |
return; |
} |
if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) |
{ |
png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); |
png_free(png_ptr, new_key); |
return; |
} |
if (compression != PNG_TEXT_COMPRESSION_zTXt) |
png_error(png_ptr, "zTXt: invalid compression type"); |
text_len = png_strlen(text); |
key_len = png_check_keyword(png_ptr, key, new_key); |
if (key_len == 0) |
png_error(png_ptr, "zTXt: invalid keyword"); |
/* Add the compression method and 1 for the keyword separator. */ |
new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE; |
++key_len; |
/* Compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression, |
&comp); |
png_text_compress_init(&comp, (png_const_bytep)text, |
text == NULL ? 0 : strlen(text)); |
if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg); |
/* Write start of chunk */ |
png_write_chunk_start(png_ptr, png_zTXt, |
(png_uint_32)(key_len+text_len + 2)); |
png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len); |
/* Write key */ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, |
(png_size_t)(key_len + 1)); |
png_write_chunk_data(png_ptr, new_key, key_len); |
png_free(png_ptr, new_key); |
buf = (png_byte)compression; |
/* Write compression */ |
png_write_chunk_data(png_ptr, &buf, (png_size_t)1); |
/* Write the compressed data */ |
png_write_compressed_data_out(png_ptr, &comp); |
1509,94 → 1670,100 |
#ifdef PNG_WRITE_iTXt_SUPPORTED |
/* Write an iTXt chunk */ |
void /* PRIVATE */ |
png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key, |
png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key, |
png_const_charp lang, png_const_charp lang_key, png_const_charp text) |
{ |
PNG_iTXt; |
png_size_t lang_len, key_len, lang_key_len, text_len; |
png_charp new_lang; |
png_charp new_key = NULL; |
png_byte cbuf[2]; |
png_uint_32 key_len, prefix_len; |
png_size_t lang_len, lang_key_len; |
png_byte new_key[82]; |
compression_state comp; |
png_debug(1, "in png_write_iTXt"); |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
key_len = png_check_keyword(png_ptr, key, new_key); |
if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) |
return; |
if (key_len == 0) |
png_error(png_ptr, "iTXt: invalid keyword"); |
if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang)) == 0) |
/* Set the compression flag */ |
switch (compression) |
{ |
png_warning(png_ptr, "Empty language field in iTXt chunk"); |
new_lang = NULL; |
lang_len = 0; |
case PNG_ITXT_COMPRESSION_NONE: |
case PNG_TEXT_COMPRESSION_NONE: |
compression = new_key[++key_len] = 0; /* no compression */ |
break; |
case PNG_TEXT_COMPRESSION_zTXt: |
case PNG_ITXT_COMPRESSION_zTXt: |
compression = new_key[++key_len] = 1; /* compressed */ |
break; |
default: |
png_error(png_ptr, "iTXt: invalid compression"); |
} |
if (lang_key == NULL) |
lang_key_len = 0; |
new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE; |
++key_len; /* for the keywod separator */ |
/* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG, however, |
* specifies that the text is UTF-8 and this really doesn't require any |
* checking. |
* |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
* |
* TODO: validate the language tag correctly (see the spec.) |
*/ |
if (lang == NULL) lang = ""; /* empty language is valid */ |
lang_len = strlen(lang)+1; |
if (lang_key == NULL) lang_key = ""; /* may be empty */ |
lang_key_len = strlen(lang_key)+1; |
if (text == NULL) text = ""; /* may be empty */ |
prefix_len = key_len; |
if (lang_len > PNG_UINT_31_MAX-prefix_len) |
prefix_len = PNG_UINT_31_MAX; |
else |
lang_key_len = png_strlen(lang_key); |
prefix_len = (png_uint_32)(prefix_len + lang_len); |
if (text == NULL) |
text_len = 0; |
if (lang_key_len > PNG_UINT_31_MAX-prefix_len) |
prefix_len = PNG_UINT_31_MAX; |
else |
text_len = png_strlen(text); |
prefix_len = (png_uint_32)(prefix_len + lang_key_len); |
/* Compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression - 2, |
&comp); |
png_text_compress_init(&comp, (png_const_bytep)text, strlen(text)); |
if (compression) |
{ |
if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg); |
} |
/* Make sure we include the compression flag, the compression byte, |
* and the NULs after the key, lang, and lang_key parts |
*/ |
else |
{ |
if (comp.input_len > PNG_UINT_31_MAX-prefix_len) |
png_error(png_ptr, "iTXt: uncompressed text too long"); |
png_write_chunk_start(png_ptr, png_iTXt, (png_uint_32)( |
5 /* comp byte, comp flag, terminators for key, lang and lang_key */ |
+ key_len |
+ lang_len |
+ lang_key_len |
+ text_len)); |
/* So the string will fit in a chunk: */ |
comp.output_len = (png_uint_32)/*SAFE*/comp.input_len; |
} |
/* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, (png_size_t)(key_len + 1)); |
png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len); |
/* Set the compression flag */ |
if (compression == PNG_ITXT_COMPRESSION_NONE || |
compression == PNG_TEXT_COMPRESSION_NONE) |
cbuf[0] = 0; |
png_write_chunk_data(png_ptr, new_key, key_len); |
else /* compression == PNG_ITXT_COMPRESSION_zTXt */ |
cbuf[0] = 1; |
png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len); |
/* Set the compression method */ |
cbuf[1] = 0; |
png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len); |
png_write_chunk_data(png_ptr, cbuf, (png_size_t)2); |
if (compression) |
png_write_compressed_data_out(png_ptr, &comp); |
cbuf[0] = 0; |
png_write_chunk_data(png_ptr, (new_lang ? (png_const_bytep)new_lang : cbuf), |
(png_size_t)(lang_len + 1)); |
else |
png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len); |
png_write_chunk_data(png_ptr, (lang_key ? (png_const_bytep)lang_key : cbuf), |
(png_size_t)(lang_key_len + 1)); |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
png_free(png_ptr, new_lang); |
} |
#endif |
1603,10 → 1770,9 |
#ifdef PNG_WRITE_oFFs_SUPPORTED |
/* Write the oFFs chunk */ |
void /* PRIVATE */ |
png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, |
png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset, |
int unit_type) |
{ |
PNG_oFFs; |
png_byte buf[9]; |
png_debug(1, "in png_write_oFFs"); |
1618,36 → 1784,42 |
png_save_int_32(buf + 4, y_offset); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); |
png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); |
} |
#endif |
#ifdef PNG_WRITE_pCAL_SUPPORTED |
/* Write the pCAL chunk (described in the PNG extensions document) */ |
void /* PRIVATE */ |
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, |
png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0, |
png_int_32 X1, int type, int nparams, png_const_charp units, |
png_charpp params) |
{ |
PNG_pCAL; |
png_size_t purpose_len, units_len, total_len; |
png_uint_32p params_len; |
png_uint_32 purpose_len; |
png_size_t units_len, total_len; |
png_size_tp params_len; |
png_byte buf[10]; |
png_charp new_purpose; |
png_byte new_purpose[80]; |
int i; |
png_debug1(1, "in png_write_pCAL (%d parameters)", nparams); |
if (type >= PNG_EQUATION_LAST) |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
png_error(png_ptr, "Unrecognized equation type for pCAL chunk"); |
purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; |
purpose_len = png_check_keyword(png_ptr, purpose, new_purpose); |
if (purpose_len == 0) |
png_error(png_ptr, "pCAL: invalid keyword"); |
++purpose_len; /* terminator */ |
png_debug1(3, "pCAL purpose length = %d", (int)purpose_len); |
units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); |
units_len = strlen(units) + (nparams == 0 ? 0 : 1); |
png_debug1(3, "pCAL units length = %d", (int)units_len); |
total_len = purpose_len + units_len + 10; |
params_len = (png_uint_32p)png_malloc(png_ptr, |
(png_alloc_size_t)(nparams * png_sizeof(png_uint_32))); |
params_len = (png_size_tp)png_malloc(png_ptr, |
(png_alloc_size_t)(nparams * (sizeof (png_size_t)))); |
/* Find the length of each parameter, making sure we don't count the |
* null terminator for the last parameter. |
1654,16 → 1826,15 |
*/ |
for (i = 0; i < nparams; i++) |
{ |
params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); |
params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1); |
png_debug2(3, "pCAL parameter %d length = %lu", i, |
(unsigned long)params_len[i]); |
total_len += (png_size_t)params_len[i]; |
total_len += params_len[i]; |
} |
png_debug1(3, "pCAL total length = %d", (int)total_len); |
png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_const_bytep)new_purpose, |
(png_size_t)purpose_len); |
png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, new_purpose, purpose_len); |
png_save_int_32(buf, X0); |
png_save_int_32(buf + 4, X1); |
buf[8] = (png_byte)type; |
1671,12 → 1842,9 |
png_write_chunk_data(png_ptr, buf, (png_size_t)10); |
png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len); |
png_free(png_ptr, new_purpose); |
for (i = 0; i < nparams; i++) |
{ |
png_write_chunk_data(png_ptr, (png_const_bytep)params[i], |
(png_size_t)params_len[i]); |
png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]); |
} |
png_free(png_ptr, params_len); |
1687,17 → 1855,16 |
#ifdef PNG_WRITE_sCAL_SUPPORTED |
/* Write the sCAL chunk */ |
void /* PRIVATE */ |
png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width, |
png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width, |
png_const_charp height) |
{ |
PNG_sCAL; |
png_byte buf[64]; |
png_size_t wlen, hlen, total_len; |
png_debug(1, "in png_write_sCAL_s"); |
wlen = png_strlen(width); |
hlen = png_strlen(height); |
wlen = strlen(width); |
hlen = strlen(height); |
total_len = wlen + hlen + 2; |
if (total_len > 64) |
1707,11 → 1874,11 |
} |
buf[0] = (png_byte)unit; |
png_memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ |
png_memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ |
memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ |
memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ |
png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); |
png_write_chunk(png_ptr, png_sCAL, buf, total_len); |
png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len); |
} |
#endif |
1718,11 → 1885,10 |
#ifdef PNG_WRITE_pHYs_SUPPORTED |
/* Write the pHYs chunk */ |
void /* PRIVATE */ |
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, |
png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit, |
png_uint_32 y_pixels_per_unit, |
int unit_type) |
{ |
PNG_pHYs; |
png_byte buf[9]; |
png_debug(1, "in png_write_pHYs"); |
1734,7 → 1900,7 |
png_save_uint_32(buf + 4, y_pixels_per_unit); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); |
png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); |
} |
#endif |
1743,9 → 1909,8 |
* or png_convert_from_time_t(), or fill in the structure yourself. |
*/ |
void /* PRIVATE */ |
png_write_tIME(png_structp png_ptr, png_const_timep mod_time) |
png_write_tIME(png_structrp png_ptr, png_const_timep mod_time) |
{ |
PNG_tIME; |
png_byte buf[7]; |
png_debug(1, "in png_write_tIME"); |
1765,40 → 1930,44 |
buf[5] = mod_time->minute; |
buf[6] = mod_time->second; |
png_write_chunk(png_ptr, png_tIME, buf, (png_size_t)7); |
png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7); |
} |
#endif |
/* Initializes the row writing capability of libpng */ |
void /* PRIVATE */ |
png_write_start_row(png_structp png_ptr) |
png_write_start_row(png_structrp png_ptr) |
{ |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
png_size_t buf_size; |
png_alloc_size_t buf_size; |
int usr_pixel_depth; |
png_debug(1, "in png_write_start_row"); |
buf_size = (png_size_t)(PNG_ROWBYTES( |
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1); |
usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth; |
buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1; |
/* 1.5.6: added to allow checking in the row write code. */ |
png_ptr->transformed_pixel_depth = png_ptr->pixel_depth; |
png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth; |
/* Set up row buffer */ |
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)buf_size); |
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size); |
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
1815,8 → 1984,7 |
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) |
{ |
/* Set up previous row buffer */ |
png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, |
(png_alloc_size_t)buf_size); |
png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size); |
if (png_ptr->do_filter & PNG_FILTER_UP) |
{ |
1870,33 → 2038,28 |
png_ptr->num_rows = png_ptr->height; |
png_ptr->usr_width = png_ptr->width; |
} |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
/* Internal use only. Called when finished processing a row of data. */ |
void /* PRIVATE */ |
png_write_finish_row(png_structp png_ptr) |
png_write_finish_row(png_structrp png_ptr) |
{ |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int ret; |
png_debug(1, "in png_write_finish_row"); |
/* Next row */ |
1947,7 → 2110,7 |
if (png_ptr->pass < 7) |
{ |
if (png_ptr->prev_row != NULL) |
png_memset(png_ptr->prev_row, 0, |
memset(png_ptr->prev_row, 0, |
(png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* |
png_ptr->usr_bit_depth, png_ptr->width)) + 1); |
1958,44 → 2121,9 |
/* If we get here, we've just written the last row, so we need |
to flush the compressor */ |
do |
{ |
/* Tell the compressor we are done */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
/* Check for an error */ |
if (ret == Z_OK) |
{ |
/* Check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH); |
} |
} |
else if (ret != Z_STREAM_END) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
/* Write any extra space */ |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - |
png_ptr->zstream.avail_out); |
} |
deflateReset(&png_ptr->zstream); |
png_ptr->zstream.data_type = Z_BINARY; |
} |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Pick out the correct pixels for the interlace pass. |
* The basic idea here is to go through the row with a source |
2010,10 → 2138,10 |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
png_debug(1, "in png_do_write_interlace"); |
2157,7 → 2285,7 |
/* Move the pixel */ |
if (dp != sp) |
png_memcpy(dp, sp, pixel_bytes); |
memcpy(dp, sp, pixel_bytes); |
/* Next pixel */ |
dp += pixel_bytes; |
2181,12 → 2309,15 |
* been specified by the application, and then writes the row out with the |
* chosen filter. |
*/ |
static void png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, |
png_size_t row_bytes); |
#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1) |
#define PNG_HISHIFT 10 |
#define PNG_LOMASK ((png_uint_32)0xffffL) |
#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) |
void /* PRIVATE */ |
png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
png_write_find_filter(png_structrp png_ptr, png_row_infop row_info) |
{ |
png_bytep best_row; |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
2195,7 → 2326,7 |
png_byte filter_to_do = png_ptr->do_filter; |
png_size_t row_bytes = row_info->rowbytes; |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
int num_p_filters = (int)png_ptr->num_prev_filters; |
int num_p_filters = png_ptr->num_prev_filters; |
#endif |
png_debug(1, "in png_write_find_filter"); |
2832,10 → 2963,10 |
} |
} |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
/* Do the actual writing of the filtered row data from the chosen filter. */ |
png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1); |
png_write_filtered_row(png_ptr, best_row); |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
/* Save the type of filter we picked this time for future calculations */ |
2856,72 → 2987,16 |
/* Do the actual writing of a previously filtered row. */ |
void /* PRIVATE */ |
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) |
static void |
png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, |
png_size_t full_row_length/*includes filter byte*/) |
{ |
png_size_t avail; |
png_debug(1, "in png_write_filtered_row"); |
png_debug1(2, "filter = %d", filtered_row[0]); |
/* Set up the zlib input buffer */ |
png_ptr->zstream.next_in = filtered_row; |
png_ptr->zstream.avail_in = 0; |
avail = png_ptr->row_info.rowbytes + 1; |
/* Repeat until we have compressed all the data */ |
do |
{ |
int ret; /* Return of zlib */ |
png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH); |
/* Record the number of bytes available - zlib supports at least 65535 |
* bytes at one step, depending on the size of the zlib type 'uInt', the |
* maximum size zlib can write at once is ZLIB_IO_MAX (from pngpriv.h). |
* Use this because on 16 bit systems 'rowbytes' can be up to 65536 (i.e. |
* one more than 16 bits) and, in this case 'rowbytes+1' can overflow a |
* uInt. ZLIB_IO_MAX can be safely reduced to cause zlib to be called |
* with smaller chunks of data. |
*/ |
if (png_ptr->zstream.avail_in == 0) |
{ |
if (avail > ZLIB_IO_MAX) |
{ |
png_ptr->zstream.avail_in = ZLIB_IO_MAX; |
avail -= ZLIB_IO_MAX; |
} |
else |
{ |
/* So this will fit in the available uInt space: */ |
png_ptr->zstream.avail_in = (uInt)avail; |
avail = 0; |
} |
} |
/* Compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
/* Check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
/* See if it is time to write another IDAT */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* Write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
/* Repeat until all data has been compressed */ |
} while (avail > 0 || png_ptr->zstream.avail_in > 0); |
/* Swap the current and previous rows */ |
if (png_ptr->prev_row != NULL) |
{ |
/programs/develop/libraries/newlib/cmd1.sed |
---|
1,0 → 0,0 |
s|[^ ][A-Za-z0-9_]*|_&,'&',\\| |
s|[^ ][A-Za-z0-9_]*|&,'&',\\| |
/programs/develop/libraries/newlib/crt/crt1.c |
---|
98,7 → 98,7 |
__do_global_ctors(); |
__appcwdlen = strrchr(&__pgmname, '/') - &__pgmname + 1; |
__appcwdlen = strrchr(&__pgmname[0], '/') - &__pgmname[0] + 1; |
__appcwdlen = __appcwdlen > 1023 ? 1023 : __appcwdlen; |
memcpy(__appcwd, &__pgmname, __appcwdlen); |
__appcwd[__appcwdlen] = 0; |
105,12 → 105,12 |
set_cwd(__appcwd); |
arg[0] = &__pgmname; |
arg[0] = &__pgmname[0]; |
if( __cmdline[0] != 0) |
{ |
_argc = 2; |
arg[1] = &__cmdline; |
arg[1] = &__cmdline[0]; |
} else _argc = 1; |
_argv = arg; |
/programs/develop/libraries/newlib/newlib.sed |
---|
0,0 → 1,0 |
s|[^ ][A-Za-z0-9_]*|_&,'&',\\| |
/programs/develop/libraries/newlib/sdk/fasm/include/libpng.inc |
---|
0,0 → 1,243 |
EXPORTS,'EXPORTS',\ |
import libpng16,\ |
png_access_version_number,'png_access_version_number',\ |
png_set_sig_bytes,'png_set_sig_bytes',\ |
png_sig_cmp,'png_sig_cmp',\ |
png_create_read_struct,'png_create_read_struct',\ |
png_create_write_struct,'png_create_write_struct',\ |
png_get_compression_buffer_size,'png_get_compression_buffer_size',\ |
png_set_compression_buffer_size,'png_set_compression_buffer_size',\ |
png_set_longjmp_fn,'png_set_longjmp_fn',\ |
png_longjmp,'png_longjmp',\ |
png_reset_zstream,'png_reset_zstream',\ |
png_create_read_struct_2,'png_create_read_struct_2',\ |
png_create_write_struct_2,'png_create_write_struct_2',\ |
png_write_sig,'png_write_sig',\ |
png_write_chunk,'png_write_chunk',\ |
png_write_chunk_start,'png_write_chunk_start',\ |
png_write_chunk_data,'png_write_chunk_data',\ |
png_write_chunk_end,'png_write_chunk_end',\ |
png_create_info_struct,'png_create_info_struct',\ |
png_info_init_3,'png_info_init_3',\ |
png_write_info_before_PLTE,'png_write_info_before_PLTE',\ |
png_write_info,'png_write_info',\ |
png_read_info,'png_read_info',\ |
png_convert_to_rfc1123,'png_convert_to_rfc1123',\ |
png_convert_to_rfc1123_buffer,'png_convert_to_rfc1123_buffer',\ |
png_convert_from_struct_tm,'png_convert_from_struct_tm',\ |
png_convert_from_time_t,'png_convert_from_time_t',\ |
png_set_expand,'png_set_expand',\ |
png_set_expand_gray_1_2_4_to_8,'png_set_expand_gray_1_2_4_to_8',\ |
png_set_palette_to_rgb,'png_set_palette_to_rgb',\ |
png_set_tRNS_to_alpha,'png_set_tRNS_to_alpha',\ |
png_set_expand_16,'png_set_expand_16',\ |
png_set_bgr,'png_set_bgr',\ |
png_set_gray_to_rgb,'png_set_gray_to_rgb',\ |
png_set_rgb_to_gray,'png_set_rgb_to_gray',\ |
png_set_rgb_to_gray_fixed,'png_set_rgb_to_gray_fixed',\ |
png_get_rgb_to_gray_status,'png_get_rgb_to_gray_status',\ |
png_build_grayscale_palette,'png_build_grayscale_palette',\ |
png_set_alpha_mode,'png_set_alpha_mode',\ |
png_set_alpha_mode_fixed,'png_set_alpha_mode_fixed',\ |
png_set_strip_alpha,'png_set_strip_alpha',\ |
png_set_swap_alpha,'png_set_swap_alpha',\ |
png_set_invert_alpha,'png_set_invert_alpha',\ |
png_set_filler,'png_set_filler',\ |
png_set_add_alpha,'png_set_add_alpha',\ |
png_set_swap,'png_set_swap',\ |
png_set_packing,'png_set_packing',\ |
png_set_packswap,'png_set_packswap',\ |
png_set_shift,'png_set_shift',\ |
png_set_interlace_handling,'png_set_interlace_handling',\ |
png_set_invert_mono,'png_set_invert_mono',\ |
png_set_background,'png_set_background',\ |
png_set_background_fixed,'png_set_background_fixed',\ |
png_set_scale_16,'png_set_scale_16',\ |
png_set_strip_16,'png_set_strip_16',\ |
png_set_quantize,'png_set_quantize',\ |
png_set_gamma,'png_set_gamma',\ |
png_set_gamma_fixed,'png_set_gamma_fixed',\ |
png_set_flush,'png_set_flush',\ |
png_write_flush,'png_write_flush',\ |
png_start_read_image,'png_start_read_image',\ |
png_read_update_info,'png_read_update_info',\ |
png_read_rows,'png_read_rows',\ |
png_read_row,'png_read_row',\ |
png_read_image,'png_read_image',\ |
png_write_row,'png_write_row',\ |
png_write_rows,'png_write_rows',\ |
png_write_image,'png_write_image',\ |
png_write_end,'png_write_end',\ |
png_read_end,'png_read_end',\ |
png_destroy_info_struct,'png_destroy_info_struct',\ |
png_destroy_read_struct,'png_destroy_read_struct',\ |
png_destroy_write_struct,'png_destroy_write_struct',\ |
png_set_crc_action,'png_set_crc_action',\ |
png_set_filter,'png_set_filter',\ |
png_set_filter_heuristics,'png_set_filter_heuristics',\ |
png_set_filter_heuristics_fixed,'png_set_filter_heuristics_fixed',\ |
png_set_compression_level,'png_set_compression_level',\ |
png_set_compression_mem_level,'png_set_compression_mem_level',\ |
png_set_compression_strategy,'png_set_compression_strategy',\ |
png_set_compression_window_bits,'png_set_compression_window_bits',\ |
png_set_compression_method,'png_set_compression_method',\ |
png_set_text_compression_level,'png_set_text_compression_level',\ |
png_set_text_compression_mem_level,'png_set_text_compression_mem_level',\ |
png_set_text_compression_strategy,'png_set_text_compression_strategy',\ |
png_set_text_compression_window_bits,'png_set_text_compression_window_bits',\ |
png_set_text_compression_method,'png_set_text_compression_method',\ |
png_init_io,'png_init_io',\ |
png_set_error_fn,'png_set_error_fn',\ |
png_get_error_ptr,'png_get_error_ptr',\ |
png_set_write_fn,'png_set_write_fn',\ |
png_set_read_fn,'png_set_read_fn',\ |
png_get_io_ptr,'png_get_io_ptr',\ |
png_set_read_status_fn,'png_set_read_status_fn',\ |
png_set_write_status_fn,'png_set_write_status_fn',\ |
png_set_mem_fn,'png_set_mem_fn',\ |
png_get_mem_ptr,'png_get_mem_ptr',\ |
png_set_read_user_transform_fn,'png_set_read_user_transform_fn',\ |
png_set_write_user_transform_fn,'png_set_write_user_transform_fn',\ |
png_set_user_transform_info,'png_set_user_transform_info',\ |
png_get_user_transform_ptr,'png_get_user_transform_ptr',\ |
png_get_current_row_number,'png_get_current_row_number',\ |
png_get_current_pass_number,'png_get_current_pass_number',\ |
png_set_read_user_chunk_fn,'png_set_read_user_chunk_fn',\ |
png_get_user_chunk_ptr,'png_get_user_chunk_ptr',\ |
png_set_progressive_read_fn,'png_set_progressive_read_fn',\ |
png_get_progressive_ptr,'png_get_progressive_ptr',\ |
png_process_data,'png_process_data',\ |
png_process_data_pause,'png_process_data_pause',\ |
png_process_data_skip,'png_process_data_skip',\ |
png_progressive_combine_row,'png_progressive_combine_row',\ |
png_malloc,'png_malloc',\ |
png_calloc,'png_calloc',\ |
png_malloc_warn,'png_malloc_warn',\ |
png_free,'png_free',\ |
png_free_data,'png_free_data',\ |
png_data_freer,'png_data_freer',\ |
png_malloc_default,'png_malloc_default',\ |
png_free_default,'png_free_default',\ |
png_error,'png_error',\ |
png_chunk_error,'png_chunk_error',\ |
png_warning,'png_warning',\ |
png_chunk_warning,'png_chunk_warning',\ |
png_benign_error,'png_benign_error',\ |
png_chunk_benign_error,'png_chunk_benign_error',\ |
png_set_benign_errors,'png_set_benign_errors',\ |
png_get_valid,'png_get_valid',\ |
png_get_rowbytes,'png_get_rowbytes',\ |
png_get_rows,'png_get_rows',\ |
png_set_rows,'png_set_rows',\ |
png_get_channels,'png_get_channels',\ |
png_get_image_width,'png_get_image_width',\ |
png_get_image_height,'png_get_image_height',\ |
png_get_bit_depth,'png_get_bit_depth',\ |
png_get_color_type,'png_get_color_type',\ |
png_get_filter_type,'png_get_filter_type',\ |
png_get_interlace_type,'png_get_interlace_type',\ |
png_get_compression_type,'png_get_compression_type',\ |
png_get_pixels_per_meter,'png_get_pixels_per_meter',\ |
png_get_x_pixels_per_meter,'png_get_x_pixels_per_meter',\ |
png_get_y_pixels_per_meter,'png_get_y_pixels_per_meter',\ |
png_get_pixel_aspect_ratio,'png_get_pixel_aspect_ratio',\ |
png_get_pixel_aspect_ratio_fixed,'png_get_pixel_aspect_ratio_fixed',\ |
png_get_x_offset_pixels,'png_get_x_offset_pixels',\ |
png_get_y_offset_pixels,'png_get_y_offset_pixels',\ |
png_get_x_offset_microns,'png_get_x_offset_microns',\ |
png_get_y_offset_microns,'png_get_y_offset_microns',\ |
png_get_signature,'png_get_signature',\ |
png_get_bKGD,'png_get_bKGD',\ |
png_set_bKGD,'png_set_bKGD',\ |
png_get_cHRM,'png_get_cHRM',\ |
png_get_cHRM_XYZ,'png_get_cHRM_XYZ',\ |
png_get_cHRM_fixed,'png_get_cHRM_fixed',\ |
png_get_cHRM_XYZ_fixed,'png_get_cHRM_XYZ_fixed',\ |
png_set_cHRM,'png_set_cHRM',\ |
png_set_cHRM_XYZ,'png_set_cHRM_XYZ',\ |
png_set_cHRM_fixed,'png_set_cHRM_fixed',\ |
png_set_cHRM_XYZ_fixed,'png_set_cHRM_XYZ_fixed',\ |
png_get_gAMA,'png_get_gAMA',\ |
png_get_gAMA_fixed,'png_get_gAMA_fixed',\ |
png_set_gAMA,'png_set_gAMA',\ |
png_set_gAMA_fixed,'png_set_gAMA_fixed',\ |
png_get_hIST,'png_get_hIST',\ |
png_set_hIST,'png_set_hIST',\ |
png_get_IHDR,'png_get_IHDR',\ |
png_set_IHDR,'png_set_IHDR',\ |
png_get_oFFs,'png_get_oFFs',\ |
png_set_oFFs,'png_set_oFFs',\ |
png_get_pCAL,'png_get_pCAL',\ |
png_set_pCAL,'png_set_pCAL',\ |
png_get_pHYs,'png_get_pHYs',\ |
png_set_pHYs,'png_set_pHYs',\ |
png_get_PLTE,'png_get_PLTE',\ |
png_set_PLTE,'png_set_PLTE',\ |
png_get_sBIT,'png_get_sBIT',\ |
png_set_sBIT,'png_set_sBIT',\ |
png_get_sRGB,'png_get_sRGB',\ |
png_set_sRGB,'png_set_sRGB',\ |
png_set_sRGB_gAMA_and_cHRM,'png_set_sRGB_gAMA_and_cHRM',\ |
png_get_iCCP,'png_get_iCCP',\ |
png_set_iCCP,'png_set_iCCP',\ |
png_get_sPLT,'png_get_sPLT',\ |
png_set_sPLT,'png_set_sPLT',\ |
png_get_text,'png_get_text',\ |
png_set_text,'png_set_text',\ |
png_get_tIME,'png_get_tIME',\ |
png_set_tIME,'png_set_tIME',\ |
png_get_tRNS,'png_get_tRNS',\ |
png_set_tRNS,'png_set_tRNS',\ |
png_get_sCAL,'png_get_sCAL',\ |
png_get_sCAL_fixed,'png_get_sCAL_fixed',\ |
png_get_sCAL_s,'png_get_sCAL_s',\ |
png_set_sCAL,'png_set_sCAL',\ |
png_set_sCAL_fixed,'png_set_sCAL_fixed',\ |
png_set_sCAL_s,'png_set_sCAL_s',\ |
png_set_keep_unknown_chunks,'png_set_keep_unknown_chunks',\ |
png_handle_as_unknown,'png_handle_as_unknown',\ |
png_set_unknown_chunks,'png_set_unknown_chunks',\ |
png_set_unknown_chunk_location,'png_set_unknown_chunk_location',\ |
png_get_unknown_chunks,'png_get_unknown_chunks',\ |
png_set_invalid,'png_set_invalid',\ |
png_read_png,'png_read_png',\ |
png_write_png,'png_write_png',\ |
png_get_copyright,'png_get_copyright',\ |
png_get_header_ver,'png_get_header_ver',\ |
png_get_header_version,'png_get_header_version',\ |
png_get_libpng_ver,'png_get_libpng_ver',\ |
png_permit_mng_features,'png_permit_mng_features',\ |
png_set_user_limits,'png_set_user_limits',\ |
png_get_user_width_max,'png_get_user_width_max',\ |
png_get_user_height_max,'png_get_user_height_max',\ |
png_set_chunk_cache_max,'png_set_chunk_cache_max',\ |
png_get_chunk_cache_max,'png_get_chunk_cache_max',\ |
png_set_chunk_malloc_max,'png_set_chunk_malloc_max',\ |
png_get_chunk_malloc_max,'png_get_chunk_malloc_max',\ |
png_get_pixels_per_inch,'png_get_pixels_per_inch',\ |
png_get_x_pixels_per_inch,'png_get_x_pixels_per_inch',\ |
png_get_y_pixels_per_inch,'png_get_y_pixels_per_inch',\ |
png_get_x_offset_inches,'png_get_x_offset_inches',\ |
png_get_x_offset_inches_fixed,'png_get_x_offset_inches_fixed',\ |
png_get_y_offset_inches,'png_get_y_offset_inches',\ |
png_get_y_offset_inches_fixed,'png_get_y_offset_inches_fixed',\ |
png_get_pHYs_dpi,'png_get_pHYs_dpi',\ |
png_get_io_state,'png_get_io_state',\ |
png_get_io_chunk_type,'png_get_io_chunk_type',\ |
png_get_uint_32,'png_get_uint_32',\ |
png_get_uint_16,'png_get_uint_16',\ |
png_get_int_32,'png_get_int_32',\ |
png_get_uint_31,'png_get_uint_31',\ |
png_save_uint_32,'png_save_uint_32',\ |
png_save_int_32,'png_save_int_32',\ |
png_save_uint_16,'png_save_uint_16',\ |
png_image_begin_read_from_file,'png_image_begin_read_from_file',\ |
png_image_begin_read_from_stdio,'png_image_begin_read_from_stdio',\ |
png_image_begin_read_from_memory,'png_image_begin_read_from_memory',\ |
png_image_finish_read,'png_image_finish_read',\ |
png_image_free,'png_image_free',\ |
png_image_write_to_file,'png_image_write_to_file',\ |
png_image_write_to_stdio,'png_image_write_to_stdio',\ |
png_set_check_for_invalid_index,'png_set_check_for_invalid_index',\ |
png_get_palette_max,'png_get_palette_max',\ |
png_set_option,'png_set_option' |
/programs/develop/libraries/newlib/sdk/fasm/include/zlib.inc |
---|
0,0 → 1,66 |
import zlib,\ |
zlibVersion,'zlibVersion',\ |
deflate,'deflate',\ |
deflateEnd,'deflateEnd',\ |
inflate,'inflate',\ |
inflateEnd,'inflateEnd',\ |
deflateSetDictionary,'deflateSetDictionary',\ |
deflateCopy,'deflateCopy',\ |
deflateReset,'deflateReset',\ |
deflateParams,'deflateParams',\ |
deflateTune,'deflateTune',\ |
deflateBound,'deflateBound',\ |
deflatePrime,'deflatePrime',\ |
deflateSetHeader,'deflateSetHeader',\ |
inflateSetDictionary,'inflateSetDictionary',\ |
inflateSync,'inflateSync',\ |
inflateCopy,'inflateCopy',\ |
inflateReset,'inflateReset',\ |
inflateReset2,'inflateReset2',\ |
inflatePrime,'inflatePrime',\ |
inflateMark,'inflateMark',\ |
inflateGetHeader,'inflateGetHeader',\ |
inflateBack,'inflateBack',\ |
inflateBackEnd,'inflateBackEnd',\ |
zlibCompileFlags,'zlibCompileFlags',\ |
compress,'compress',\ |
compress2,'compress2',\ |
compressBound,'compressBound',\ |
uncompress,'uncompress',\ |
gzopen,'gzopen',\ |
gzdopen,'gzdopen',\ |
gzbuffer,'gzbuffer',\ |
gzsetparams,'gzsetparams',\ |
gzread,'gzread',\ |
gzwrite,'gzwrite',\ |
gzprintf,'gzprintf',\ |
gzputs,'gzputs',\ |
gzgets,'gzgets',\ |
gzputc,'gzputc',\ |
gzgetc,'gzgetc',\ |
gzungetc,'gzungetc',\ |
gzflush,'gzflush',\ |
gzseek,'gzseek',\ |
gzrewind,'gzrewind',\ |
gztell,'gztell',\ |
gzoffset,'gzoffset',\ |
gzeof,'gzeof',\ |
gzdirect,'gzdirect',\ |
gzclose,'gzclose',\ |
gzclose_r,'gzclose_r',\ |
gzclose_w,'gzclose_w',\ |
gzerror,'gzerror',\ |
gzclearerr,'gzclearerr',\ |
adler32,'adler32',\ |
crc32,'crc32',\ |
adler32_combine,'adler32_combine',\ |
crc32_combine,'crc32_combine',\ |
deflateInit_,'deflateInit_',\ |
deflateInit2_,'deflateInit2_',\ |
inflateInit_,'inflateInit_',\ |
inflateInit2_,'inflateInit2_',\ |
inflateBackInit_,'inflateBackInit_',\ |
zError,'zError',\ |
inflateSyncPoint,'inflateSyncPoint',\ |
get_crc_table,'get_crc_table',\ |
inflateUndermine,'inflateUndermine' |