ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updated included PNG library to latest release. 

git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@3123 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba
This commit is contained in:
stephena 2014-12-29 17:44:01 +00:00
parent 1460947005
commit 1a62c3a424
20 changed files with 1185 additions and 1028 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

480
src/libpng/png.c
View File

File diff suppressed because it is too large Load Diff

57
src/libpng/png.h
View File

@ -1,7 +1,7 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.6.14 - October 23, 2014 * libpng version 1.6.15, November 20, 2014
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -11,7 +11,7 @@
* Authors and maintainers: * Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat * 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.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.6.14 - October 23, 2014: Glenn * libpng versions 0.97, January 1998, through 1.6.15, November 20, 2014: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@ -206,6 +206,9 @@
* 1.6.14beta01-07 16 10614 16.so.16.14[.0] * 1.6.14beta01-07 16 10614 16.so.16.14[.0]
* 1.6.14rc01-02 16 10614 16.so.16.14[.0] * 1.6.14rc01-02 16 10614 16.so.16.14[.0]
* 1.6.14 16 10614 16.so.16.14[.0] * 1.6.14 16 10614 16.so.16.14[.0]
* 1.6.15beta01-08 16 10615 16.so.16.15[.0]
* 1.6.15rc01-03 16 10615 16.so.16.15[.0]
* 1.6.15 16 10615 16.so.16.15[.0]
* *
* Henceforth the source version will match the shared-library major * Henceforth the source version will match the shared-library major
* and minor numbers; the shared-library major version number will be * and minor numbers; the shared-library major version number will be
@ -237,7 +240,7 @@
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* *
* libpng versions 1.2.6, August 15, 2004, through 1.6.14, October 23, 2014, are * libpng versions 1.2.6, August 15, 2004, through 1.6.15, November 20, 2014, are
* Copyright (c) 2004, 2006-2014 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2014 Glenn Randers-Pehrson, and are
* distributed according to the same disclaimer and license as libpng-1.2.5 * distributed according to the same disclaimer and license as libpng-1.2.5
* with the following individual added to the list of Contributing Authors: * with the following individual added to the list of Contributing Authors:
@ -349,13 +352,13 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* October 23, 2014 * November 20, 2014
* *
* Since the PNG Development group is an ad-hoc body, we can't make * Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration. * an official declaration.
* *
* This is your unofficial assurance that libpng from version 0.71 and * This is your unofficial assurance that libpng from version 0.71 and
* upward through 1.6.14 are Y2K compliant. It is my belief that * upward through 1.6.15 are Y2K compliant. It is my belief that
* earlier versions were also Y2K compliant. * earlier versions were also Y2K compliant.
* *
* Libpng only has two year fields. One is a 2-byte unsigned integer * Libpng only has two year fields. One is a 2-byte unsigned integer
@ -417,9 +420,9 @@
*/ */
/* Version information for png.h - this should match the version in png.c */ /* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.6.14" #define PNG_LIBPNG_VER_STRING "1.6.15"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.6.14 - October 23, 2014\n" " libpng version 1.6.15 - November 20, 2014\n"
#define PNG_LIBPNG_VER_SONUM 16 #define PNG_LIBPNG_VER_SONUM 16
#define PNG_LIBPNG_VER_DLLNUM 16 #define PNG_LIBPNG_VER_DLLNUM 16
@ -427,7 +430,7 @@
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
#define PNG_LIBPNG_VER_MAJOR 1 #define PNG_LIBPNG_VER_MAJOR 1
#define PNG_LIBPNG_VER_MINOR 6 #define PNG_LIBPNG_VER_MINOR 6
#define PNG_LIBPNG_VER_RELEASE 14 #define PNG_LIBPNG_VER_RELEASE 15
/* This should match the numeric part of the final component of /* This should match the numeric part of the final component of
* PNG_LIBPNG_VER_STRING, omitting any leading zero: * PNG_LIBPNG_VER_STRING, omitting any leading zero:
@ -458,7 +461,7 @@
* version 1.0.0 was mis-numbered 100 instead of 10000). From * 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 * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release
*/ */
#define PNG_LIBPNG_VER 10614 /* 1.6.14 */ #define PNG_LIBPNG_VER 10615 /* 1.6.15 */
/* Library configuration: these options cannot be changed after /* Library configuration: these options cannot be changed after
* the library has been built. * the library has been built.
@ -563,7 +566,7 @@ extern "C" {
/* This triggers a compiler error in png.c, if png.c and png.h /* This triggers a compiler error in png.c, if png.c and png.h
* do not agree upon the version number. * do not agree upon the version number.
*/ */
typedef char* png_libpng_version_1_6_14; typedef char* png_libpng_version_1_6_15;
/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info. /* Basic control structions. Read libpng-manual.txt or libpng.3 for more info.
* *
@ -1176,7 +1179,7 @@ PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
/* Convert from time_t to png_time. Uses gmtime() */ /* 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 */ #endif /* CONVERT_tIME */
#ifdef PNG_READ_EXPAND_SUPPORTED #ifdef PNG_READ_EXPAND_SUPPORTED
/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
@ -1382,7 +1385,7 @@ PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */
PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr, PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
png_uint_32 filler, int flags)); png_uint_32 filler, int flags));
#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ #endif /* READ_FILLER || WRITE_FILLER */
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* Swap bytes in 16-bit depth files. */ /* Swap bytes in 16-bit depth files. */
@ -1646,7 +1649,7 @@ PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
(png_structrp png_ptr, int heuristic_method, int num_weights, (png_structrp png_ptr, int heuristic_method, int num_weights,
png_const_fixed_point_p filter_weights, png_const_fixed_point_p filter_weights,
png_const_fixed_point_p filter_costs)) png_const_fixed_point_p filter_costs))
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ #endif /* WRITE_WEIGHTED_FILTER */
/* Heuristic used for row filter selection. These defines should NOT be /* Heuristic used for row filter selection. These defines should NOT be
* changed. * changed.
@ -1702,7 +1705,7 @@ PNG_EXPORT(225, void, png_set_text_compression_window_bits,
PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
int method)); int method));
#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
/* These next functions are called for input/output, memory, and error /* These next functions are called for input/output, memory, and error
* handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,
@ -1869,7 +1872,7 @@ PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
*/ */
PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr, PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
png_bytep old_row, png_const_bytep new_row)); png_bytep old_row, png_const_bytep new_row));
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PROGRESSIVE_READ */
PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr, PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
png_alloc_size_t size), PNG_ALLOCATED); png_alloc_size_t size), PNG_ALLOCATED);
@ -2070,7 +2073,7 @@ PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
(png_const_structrp png_ptr, png_const_inforp info_ptr)); (png_const_structrp png_ptr, png_const_inforp info_ptr));
#endif /* PNG_EASY_ACCESS_SUPPORTED */ #endif /* EASY_ACCESS */
#ifdef PNG_READ_SUPPORTED #ifdef PNG_READ_SUPPORTED
/* Returns pointer to signature string read from PNG header */ /* Returns pointer to signature string read from PNG header */
@ -2322,7 +2325,7 @@ PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr, PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
png_inforp info_ptr, int unit, png_inforp info_ptr, int unit,
png_const_charp swidth, png_const_charp sheight)); png_const_charp swidth, png_const_charp sheight));
#endif /* PNG_sCAL_SUPPORTED */ #endif /* sCAL */
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
/* Provide the default handling for all unknown chunks or, optionally, for /* Provide the default handling for all unknown chunks or, optionally, for
@ -2550,8 +2553,8 @@ PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr, 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, png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
int *unit_type)); int *unit_type));
# endif /* PNG_pHYs_SUPPORTED */ # endif /* pHYs */
#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ #endif /* INCH_CONVERSIONS */
/* Added in libpng-1.4.0 */ /* Added in libpng-1.4.0 */
#ifdef PNG_IO_STATE_SUPPORTED #ifdef PNG_IO_STATE_SUPPORTED
@ -2574,7 +2577,7 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ # define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */
# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ # define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */
# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ # define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */
#endif /* ?PNG_IO_STATE_SUPPORTED */ #endif /* IO_STATE */
/* Interlace support. The following macros are always defined so that if /* Interlace support. The following macros are always defined so that if
* libpng interlace handling is turned off the macros may be used to handle * libpng interlace handling is turned off the macros may be used to handle
@ -2678,7 +2681,7 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
32767) / 65535) 32767) / 65535)
#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ #endif /* READ_COMPOSITE_NODIV */
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
@ -3106,7 +3109,7 @@ PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image, PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
FILE* file)); FILE* file));
/* The PNG header is read from the stdio FILE object. */ /* The PNG header is read from the stdio FILE object. */
#endif /* PNG_STDIO_SUPPORTED */ #endif /* STDIO */
PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image, PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
png_const_voidp memory, png_size_t size)); png_const_voidp memory, png_size_t size));
@ -3151,7 +3154,7 @@ PNG_EXPORT(238, void, png_image_free, (png_imagep image));
/* Free any data allocated by libpng in image->opaque, setting the pointer to /* 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. * NULL. May be called at any time after the structure is initialized.
*/ */
#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ #endif /* SIMPLIFIED_READ */
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
#ifdef PNG_STDIO_SUPPORTED #ifdef PNG_STDIO_SUPPORTED
@ -3197,12 +3200,12 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
* *
* Note that the write API does not support interlacing or sub-8-bit pixels. * Note that the write API does not support interlacing or sub-8-bit pixels.
*/ */
#endif /* PNG_STDIO_SUPPORTED */ #endif /* STDIO */
#endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */ #endif /* SIMPLIFIED_WRITE */
/******************************************************************************* /*******************************************************************************
* END OF SIMPLIFIED API * END OF SIMPLIFIED API
******************************************************************************/ ******************************************************************************/
#endif /* PNG_SIMPLIFIED_{READ|WRITE}_SUPPORTED */ #endif /* SIMPLIFIED_{READ|WRITE} */
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
PNG_EXPORT(242, void, png_set_check_for_invalid_index, PNG_EXPORT(242, void, png_set_check_for_invalid_index,
@ -3250,7 +3253,7 @@ PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
int onoff)); int onoff));
#endif /* PNG_SET_OPTION_SUPPORTED */ #endif /* SET_OPTION */
/******************************************************************************* /*******************************************************************************
* END OF HARDWARE AND SOFTWARE OPTIONS * END OF HARDWARE AND SOFTWARE OPTIONS

2
src/libpng/pngconf.h
View File

@ -1,7 +1,7 @@
/* pngconf.h - machine configurable file for libpng /* pngconf.h - machine configurable file for libpng
* *
* libpng version 1.6.14 - October 23, 2014 * libpng version 1.6.15,November 20, 2014
* *
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

66
src/libpng/pngerror.c
View File

@ -1,7 +1,7 @@
/* pngerror.c - stub functions for i/o and memory allocation /* pngerror.c - stub functions for i/o and memory allocation
* *
* Last changed in libpng 1.6.13 [August 21, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -27,7 +27,7 @@ static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
static void /* PRIVATE */ static void /* PRIVATE */
png_default_warning PNGARG((png_const_structrp png_ptr, png_default_warning PNGARG((png_const_structrp png_ptr,
png_const_charp warning_message)); png_const_charp warning_message));
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
/* This function is called whenever there is a fatal error. This function /* This function is called whenever there is a fatal error. This function
* should not be changed. If there is a need to handle errors differently, * should not be changed. If there is a need to handle errors differently,
@ -43,8 +43,8 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
char msg[16]; char msg[16];
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
if (png_ptr->flags& if ((png_ptr->flags &
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
{ {
if (*error_message == PNG_LITERAL_SHARP) if (*error_message == PNG_LITERAL_SHARP)
{ {
@ -54,7 +54,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
if (error_message[offset] == ' ') if (error_message[offset] == ' ')
break; break;
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
{ {
int i; int i;
for (i = 0; i < offset - 1; i++) for (i = 0; i < offset - 1; i++)
@ -69,7 +69,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
else else
{ {
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
{ {
msg[0] = '0'; msg[0] = '0';
msg[1] = '\0'; msg[1] = '\0';
@ -103,7 +103,7 @@ png_err,(png_const_structrp png_ptr),PNG_NORETURN)
use the default handler, which will not return. */ use the default handler, which will not return. */
png_default_error(png_ptr, ""); png_default_error(png_ptr, "");
} }
#endif /* PNG_ERROR_TEXT_SUPPORTED */ #endif /* ERROR_TEXT */
/* Utility to safely appends strings to a buffer. This never errors out so /* Utility to safely appends strings to a buffer. This never errors out so
* error checking is not required in the caller. * error checking is not required in the caller.
@ -152,7 +152,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
case PNG_NUMBER_FORMAT_fixed: case PNG_NUMBER_FORMAT_fixed:
/* Needs five digits (the fraction) */ /* Needs five digits (the fraction) */
mincount = 5; mincount = 5;
if (output || number % 10 != 0) if (output != 0 || number % 10 != 0)
{ {
*--end = digits[number % 10]; *--end = digits[number % 10];
output = 1; output = 1;
@ -189,7 +189,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
++count; ++count;
/* Float a fixed number here: */ /* Float a fixed number here: */
if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start) if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
{ {
/* End of the fraction, but maybe nothing was output? In that case /* 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 * drop the decimal point. If the number is a true zero handle that
@ -219,8 +219,8 @@ png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
#ifdef PNG_ERROR_NUMBERS_SUPPORTED #ifdef PNG_ERROR_NUMBERS_SUPPORTED
if (png_ptr->flags& if ((png_ptr->flags &
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
#endif #endif
{ {
if (*warning_message == PNG_LITERAL_SHARP) if (*warning_message == PNG_LITERAL_SHARP)
@ -355,13 +355,13 @@ png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
*/ */
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
} }
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
#ifdef PNG_BENIGN_ERRORS_SUPPORTED #ifdef PNG_BENIGN_ERRORS_SUPPORTED
void PNGAPI void PNGAPI
png_benign_error(png_const_structrp 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) if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
{ {
# ifdef PNG_READ_SUPPORTED # ifdef PNG_READ_SUPPORTED
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
@ -391,7 +391,7 @@ png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
void /* PRIVATE */ void /* PRIVATE */
png_app_warning(png_const_structrp png_ptr, png_const_charp error_message) png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
{ {
if (png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
png_warning(png_ptr, error_message); png_warning(png_ptr, error_message);
else else
png_error(png_ptr, error_message); png_error(png_ptr, error_message);
@ -404,7 +404,7 @@ png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
void /* PRIVATE */ void /* PRIVATE */
png_app_error(png_const_structrp png_ptr, png_const_charp error_message) png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
{ {
if (png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
png_warning(png_ptr, error_message); png_warning(png_ptr, error_message);
else else
png_error(png_ptr, error_message); png_error(png_ptr, error_message);
@ -442,7 +442,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
int c = (int)(chunk_name >> ishift) & 0xff; int c = (int)(chunk_name >> ishift) & 0xff;
ishift -= 8; ishift -= 8;
if (isnonalpha(c)) if (isnonalpha(c) != 0)
{ {
buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET; buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
buffer[iout++] = png_digit[(c & 0xf0) >> 4]; buffer[iout++] = png_digit[(c & 0xf0) >> 4];
@ -473,7 +473,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
buffer[iout] = '\0'; buffer[iout] = '\0';
} }
} }
#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ #endif /* WARNINGS || ERROR_TEXT */
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
PNG_FUNCTION(void,PNGAPI PNG_FUNCTION(void,PNGAPI
@ -490,7 +490,7 @@ png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
png_error(png_ptr, msg); png_error(png_ptr, msg);
} }
} }
#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */ #endif /* READ && ERROR_TEXT */
#ifdef PNG_WARNINGS_SUPPORTED #ifdef PNG_WARNINGS_SUPPORTED
void PNGAPI void PNGAPI
@ -506,7 +506,7 @@ png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
} }
} }
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
#ifdef PNG_READ_SUPPORTED #ifdef PNG_READ_SUPPORTED
#ifdef PNG_BENIGN_ERRORS_SUPPORTED #ifdef PNG_BENIGN_ERRORS_SUPPORTED
@ -514,7 +514,7 @@ void PNGAPI
png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
error_message) error_message)
{ {
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
png_chunk_warning(png_ptr, error_message); png_chunk_warning(png_ptr, error_message);
else else
@ -525,7 +525,7 @@ png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
# endif # endif
} }
#endif #endif
#endif /* PNG_READ_SUPPORTED */ #endif /* READ */
void /* PRIVATE */ void /* PRIVATE */
png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error) png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
@ -538,7 +538,7 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
* unconditionally does the right thing. * unconditionally does the right thing.
*/ */
# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED) # if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
if (png_ptr->mode & PNG_IS_READ_STRUCT) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
# endif # endif
# ifdef PNG_READ_SUPPORTED # ifdef PNG_READ_SUPPORTED
@ -552,7 +552,7 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
# endif # endif
# if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED) # if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
else if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) else if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
# endif # endif
# ifdef PNG_WRITE_SUPPORTED # ifdef PNG_WRITE_SUPPORTED
@ -577,11 +577,12 @@ png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
memcpy(msg, fixed_message, fixed_message_ln); memcpy(msg, fixed_message, fixed_message_ln);
iin = 0; iin = 0;
if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0) if (name != NULL)
{ while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
msg[fixed_message_ln + iin] = name[iin]; {
++iin; msg[fixed_message_ln + iin] = name[iin];
} ++iin;
}
msg[fixed_message_ln + iin] = 0; msg[fixed_message_ln + iin] = 0;
png_error(png_ptr, msg); png_error(png_ptr, msg);
} }
@ -757,7 +758,8 @@ PNG_FUNCTION(void,PNGAPI
png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN) png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
{ {
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
if (png_ptr && png_ptr->longjmp_fn && png_ptr->jmp_buf_ptr) if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
png_ptr->jmp_buf_ptr != NULL)
png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val); png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
#else #else
PNG_UNUSED(png_ptr) PNG_UNUSED(png_ptr)
@ -822,7 +824,7 @@ png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
#endif #endif
PNG_UNUSED(png_ptr) /* Make compiler happy */ PNG_UNUSED(png_ptr) /* Make compiler happy */
} }
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
/* This function is called when the application wants to use another method /* This function is called when the application wants to use another method
* of handling errors and warnings. Note that the error function MUST NOT * of handling errors and warnings. Note that the error function MUST NOT
@ -957,5 +959,5 @@ png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
return result; return result;
} }
#endif /* SIMPLIFIED READ/WRITE */ #endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ #endif /* READ || WRITE */

121
src/libpng/pngget.c
View File

@ -1,7 +1,7 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
* *
* Last changed in libpng 1.6.11 [June 5, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -116,7 +116,8 @@ png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
info_ptr) info_ptr)
{ {
#ifdef PNG_pHYs_SUPPORTED #ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
png_debug1(1, "in %s retrieval function", png_debug1(1, "in %s retrieval function",
"png_get_x_pixels_per_meter"); "png_get_x_pixels_per_meter");
@ -137,7 +138,8 @@ png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
info_ptr) info_ptr)
{ {
#ifdef PNG_pHYs_SUPPORTED #ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
png_debug1(1, "in %s retrieval function", png_debug1(1, "in %s retrieval function",
"png_get_y_pixels_per_meter"); "png_get_y_pixels_per_meter");
@ -157,7 +159,8 @@ png_uint_32 PNGAPI
png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
{ {
#ifdef PNG_pHYs_SUPPORTED #ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
@ -179,7 +182,8 @@ png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
info_ptr) info_ptr)
{ {
#ifdef PNG_READ_pHYs_SUPPORTED #ifdef PNG_READ_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
@ -202,10 +206,11 @@ png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
png_const_inforp info_ptr) png_const_inforp info_ptr)
{ {
#ifdef PNG_READ_pHYs_SUPPORTED #ifdef PNG_READ_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) if (png_ptr != NULL && info_ptr != NULL &&
&& info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 (info_ptr->valid & PNG_INFO_pHYs) != 0 &&
&& info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&
&& info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX) info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&
info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
{ {
png_fixed_point res; png_fixed_point res;
@ -215,7 +220,7 @@ png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,
* range of 0..2^31-1; otherwise the cast might overflow. * range of 0..2^31-1; otherwise the cast might overflow.
*/ */
if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1, if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
(png_int_32)info_ptr->x_pixels_per_unit)) (png_int_32)info_ptr->x_pixels_per_unit) != 0)
return res; return res;
} }
#else #else
@ -231,7 +236,8 @@ png_int_32 PNGAPI
png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
{ {
#ifdef PNG_oFFs_SUPPORTED #ifdef PNG_oFFs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_oFFs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
@ -250,7 +256,8 @@ png_int_32 PNGAPI
png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)
{ {
#ifdef PNG_oFFs_SUPPORTED #ifdef PNG_oFFs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_oFFs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
@ -269,7 +276,8 @@ png_int_32 PNGAPI
png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
{ {
#ifdef PNG_oFFs_SUPPORTED #ifdef PNG_oFFs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_oFFs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels"); png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
@ -288,7 +296,8 @@ png_int_32 PNGAPI
png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)
{ {
#ifdef PNG_oFFs_SUPPORTED #ifdef PNG_oFFs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_oFFs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels"); png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
@ -328,7 +337,7 @@ ppi_from_ppm(png_uint_32 ppm)
*/ */
png_fixed_point result; png_fixed_point result;
if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
5000)) 5000) != 0)
return result; return result;
/* Overflow. */ /* Overflow. */
@ -414,7 +423,8 @@ png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
{ {
png_uint_32 retval = 0; png_uint_32 retval = 0;
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
png_debug1(1, "in %s retrieval function", "pHYs"); png_debug1(1, "in %s retrieval function", "pHYs");
@ -445,12 +455,12 @@ png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
return (retval); return (retval);
} }
#endif /* PNG_pHYs_SUPPORTED */ #endif /* pHYs */
#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ #endif /* INCH_CONVERSIONS */
/* png_get_channels really belongs in here, too, but it's been around longer */ /* png_get_channels really belongs in here, too, but it's been around longer */
#endif /* PNG_EASY_ACCESS_SUPPORTED */ #endif /* EASY_ACCESS */
png_byte PNGAPI png_byte PNGAPI
@ -478,8 +488,9 @@ png_uint_32 PNGAPI
png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
png_color_16p *background) png_color_16p *background)
{ {
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) if (png_ptr != NULL && info_ptr != NULL &&
&& background != NULL) (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
background != NULL)
{ {
png_debug1(1, "in %s retrieval function", "bKGD"); png_debug1(1, "in %s retrieval function", "bKGD");
@ -509,7 +520,7 @@ png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
* consistent. * consistent.
*/ */
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
png_debug1(1, "in %s retrieval function", "cHRM"); png_debug1(1, "in %s retrieval function", "cHRM");
@ -550,7 +561,7 @@ png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
double *blue_Z) double *blue_Z)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)"); png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
@ -598,7 +609,7 @@ png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_fixed_point *int_blue_Z) png_fixed_point *int_blue_Z)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
png_debug1(1, "in %s retrieval function", "cHRM_XYZ"); png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
@ -635,7 +646,7 @@ png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_debug1(1, "in %s retrieval function", "cHRM"); png_debug1(1, "in %s retrieval function", "cHRM");
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
if (white_x != NULL) if (white_x != NULL)
*white_x = info_ptr->colorspace.end_points_xy.whitex; *white_x = info_ptr->colorspace.end_points_xy.whitex;
@ -670,7 +681,7 @@ png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_debug1(1, "in %s retrieval function", "gAMA"); png_debug1(1, "in %s retrieval function", "gAMA");
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) && (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
file_gamma != NULL) file_gamma != NULL)
{ {
*file_gamma = info_ptr->colorspace.gamma; *file_gamma = info_ptr->colorspace.gamma;
@ -689,7 +700,7 @@ png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_debug1(1, "in %s retrieval function", "gAMA(float)"); png_debug1(1, "in %s retrieval function", "gAMA(float)");
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) && (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
file_gamma != NULL) file_gamma != NULL)
{ {
*file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma, *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
@ -709,8 +720,8 @@ png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "sRGB"); png_debug1(1, "in %s retrieval function", "sRGB");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) if (png_ptr != NULL && info_ptr != NULL &&
&& file_srgb_intent != NULL) (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL)
{ {
*file_srgb_intent = info_ptr->colorspace.rendering_intent; *file_srgb_intent = info_ptr->colorspace.rendering_intent;
return (PNG_INFO_sRGB); return (PNG_INFO_sRGB);
@ -728,9 +739,10 @@ png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "iCCP"); png_debug1(1, "in %s retrieval function", "iCCP");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) if (png_ptr != NULL && info_ptr != NULL &&
&& name != NULL && compression_type != NULL && profile != NULL && (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
proflen != NULL) name != NULL && compression_type != NULL && profile != NULL &&
proflen != NULL)
{ {
*name = info_ptr->iccp_name; *name = info_ptr->iccp_name;
*profile = info_ptr->iccp_profile; *profile = info_ptr->iccp_profile;
@ -768,8 +780,8 @@ png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "hIST"); png_debug1(1, "in %s retrieval function", "hIST");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) if (png_ptr != NULL && info_ptr != NULL &&
&& hist != NULL) (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
{ {
*hist = info_ptr->hist; *hist = info_ptr->hist;
return (PNG_INFO_hIST); return (PNG_INFO_hIST);
@ -824,8 +836,9 @@ png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "oFFs"); png_debug1(1, "in %s retrieval function", "oFFs");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) if (png_ptr != NULL && info_ptr != NULL &&
&& offset_x != NULL && offset_y != NULL && unit_type != NULL) (info_ptr->valid & PNG_INFO_oFFs) != 0 &&
offset_x != NULL && offset_y != NULL && unit_type != NULL)
{ {
*offset_x = info_ptr->x_offset; *offset_x = info_ptr->x_offset;
*offset_y = info_ptr->y_offset; *offset_y = info_ptr->y_offset;
@ -845,8 +858,9 @@ png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "pCAL"); png_debug1(1, "in %s retrieval function", "pCAL");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) if (png_ptr != NULL && info_ptr != NULL &&
&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && (info_ptr->valid & PNG_INFO_pCAL) != 0 &&
purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
nparams != NULL && units != NULL && params != NULL) nparams != NULL && units != NULL && params != NULL)
{ {
*purpose = info_ptr->pcal_purpose; *purpose = info_ptr->pcal_purpose;
@ -872,7 +886,7 @@ png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
int *unit, png_fixed_point *width, png_fixed_point *height) int *unit, png_fixed_point *width, png_fixed_point *height)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL)) (info_ptr->valid & PNG_INFO_sCAL) != 0)
{ {
*unit = info_ptr->scal_unit; *unit = info_ptr->scal_unit;
/*TODO: make this work without FP support; the API is currently eliminated /*TODO: make this work without FP support; the API is currently eliminated
@ -895,7 +909,7 @@ png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
int *unit, double *width, double *height) int *unit, double *width, double *height)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL)) (info_ptr->valid & PNG_INFO_sCAL) != 0)
{ {
*unit = info_ptr->scal_unit; *unit = info_ptr->scal_unit;
*width = atof(info_ptr->scal_s_width); *width = atof(info_ptr->scal_s_width);
@ -911,7 +925,7 @@ png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
int *unit, png_charpp width, png_charpp height) int *unit, png_charpp width, png_charpp height)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL)) (info_ptr->valid & PNG_INFO_sCAL) != 0)
{ {
*unit = info_ptr->scal_unit; *unit = info_ptr->scal_unit;
*width = info_ptr->scal_s_width; *width = info_ptr->scal_s_width;
@ -933,7 +947,7 @@ png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_debug1(1, "in %s retrieval function", "pHYs"); png_debug1(1, "in %s retrieval function", "pHYs");
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs)) (info_ptr->valid & PNG_INFO_pHYs) != 0)
{ {
if (res_x != NULL) if (res_x != NULL)
{ {
@ -964,8 +978,8 @@ png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "PLTE"); png_debug1(1, "in %s retrieval function", "PLTE");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) if (png_ptr != NULL && info_ptr != NULL &&
&& palette != NULL) (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
{ {
*palette = info_ptr->palette; *palette = info_ptr->palette;
*num_palette = info_ptr->num_palette; *num_palette = info_ptr->num_palette;
@ -983,8 +997,8 @@ png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "sBIT"); png_debug1(1, "in %s retrieval function", "sBIT");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) if (png_ptr != NULL && info_ptr != NULL &&
&& sig_bit != NULL) (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
{ {
*sig_bit = &(info_ptr->sig_bit); *sig_bit = &(info_ptr->sig_bit);
return (PNG_INFO_sBIT); return (PNG_INFO_sBIT);
@ -1027,8 +1041,8 @@ png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_debug1(1, "in %s retrieval function", "tIME"); png_debug1(1, "in %s retrieval function", "tIME");
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) if (png_ptr != NULL && info_ptr != NULL &&
&& mod_time != NULL) (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
{ {
*mod_time = &(info_ptr->mod_time); *mod_time = &(info_ptr->mod_time);
return (PNG_INFO_tIME); return (PNG_INFO_tIME);
@ -1044,7 +1058,8 @@ 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_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
{ {
png_uint_32 retval = 0; png_uint_32 retval = 0;
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_tRNS) != 0)
{ {
png_debug1(1, "in %s retrieval function", "tRNS"); png_debug1(1, "in %s retrieval function", "tRNS");
@ -1121,7 +1136,7 @@ png_get_compression_buffer_size(png_const_structrp png_ptr)
return 0; return 0;
# ifdef PNG_WRITE_SUPPORTED # ifdef PNG_WRITE_SUPPORTED
if (png_ptr->mode & PNG_IS_READ_STRUCT) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
# endif # endif
{ {
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
@ -1165,7 +1180,7 @@ png_get_chunk_malloc_max (png_const_structrp png_ptr)
{ {
return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
} }
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ #endif /* SET_USER_LIMITS */
/* These functions were added to libpng 1.4.0 */ /* These functions were added to libpng 1.4.0 */
#ifdef PNG_IO_STATE_SUPPORTED #ifdef PNG_IO_STATE_SUPPORTED
@ -1180,7 +1195,7 @@ png_get_io_chunk_type (png_const_structrp png_ptr)
{ {
return png_ptr->chunk_name; return png_ptr->chunk_name;
} }
#endif /* ?PNG_IO_STATE_SUPPORTED */ #endif /* IO_STATE */
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
# ifdef PNG_GET_PALETTE_MAX_SUPPORTED # ifdef PNG_GET_PALETTE_MAX_SUPPORTED
@ -1195,4 +1210,4 @@ png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
# endif # endif
#endif #endif
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ #endif /* READ || WRITE */

2
src/libpng/pnginfo.h
View File

@ -121,7 +121,7 @@ struct png_info_def
int num_text; /* number of comments read or comments to write */ int num_text; /* number of comments read or comments to write */
int max_text; /* current size of text array */ int max_text; /* current size of text array */
png_textp text; /* array of comments read or comments to write */ png_textp text; /* array of comments read or comments to write */
#endif /* PNG_TEXT_SUPPORTED */ #endif /* TEXT */
#ifdef PNG_tIME_SUPPORTED #ifdef PNG_tIME_SUPPORTED
/* The tIME chunk holds the last time the displayed image data was /* The tIME chunk holds the last time the displayed image data was

12
src/libpng/pngmem.c
View File

@ -1,8 +1,8 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
* *
* Last changed in libpng 1.6.8 [December 19, 2013] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2013 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@ -199,7 +199,7 @@ png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
return ret; return ret;
} }
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* USER_MEM */
/* This function was added at libpng version 1.2.3. The png_malloc_warn() /* 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 * function will issue a png_warning and return NULL instead of issuing a
@ -244,7 +244,7 @@ png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
{ {
if (png_ptr == NULL || ptr == NULL) if (png_ptr == NULL || ptr == NULL)
return; return;
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* USER_MEM */
free(ptr); free(ptr);
} }
@ -277,5 +277,5 @@ png_get_mem_ptr(png_const_structrp png_ptr)
return png_ptr->mem_ptr; return png_ptr->mem_ptr;
} }
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* USER_MEM */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ #endif /* READ || WRITE */

49
src/libpng/pngpread.c
View File

@ -1,7 +1,7 @@
/* pngpread.c - read a png file in push mode /* pngpread.c - read a png file in push mode
* *
* Last changed in libpng 1.6.14 [October 23, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -202,7 +202,7 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
* sure we have enough data in the buffer for the 4-byte CRC at the * sure we have enough data in the buffer for the 4-byte CRC at the
* end of every chunk (except IDAT, which is handled separately). * end of every chunk (except IDAT, which is handled separately).
*/ */
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
{ {
png_byte chunk_length[4]; png_byte chunk_length[4];
png_byte chunk_tag[4]; png_byte chunk_tag[4];
@ -221,28 +221,28 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
if (chunk_name == png_IDAT) if (chunk_name == png_IDAT)
{ {
if (png_ptr->mode & PNG_AFTER_IDAT) if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
/* If we reach an IDAT chunk, this means we have read all of the /* 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 * header chunks, and we can start reading the image (or if this
* is called after the image has been read - we have an error). * is called after the image has been read - we have an error).
*/ */
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) (png_ptr->mode & PNG_HAVE_PLTE) == 0)
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
png_ptr->process_mode = PNG_READ_IDAT_MODE; png_ptr->process_mode = PNG_READ_IDAT_MODE;
if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
if (png_ptr->push_length == 0) if (png_ptr->push_length == 0)
return; return;
if (png_ptr->mode & PNG_AFTER_IDAT) if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "Too many IDATs found"); png_benign_error(png_ptr, "Too many IDATs found");
} }
@ -449,7 +449,7 @@ png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
void /* PRIVATE */ void /* PRIVATE */
png_push_crc_finish(png_structrp png_ptr) png_push_crc_finish(png_structrp png_ptr)
{ {
if (png_ptr->skip_length && png_ptr->save_buffer_size) if (png_ptr->skip_length != 0 && png_ptr->save_buffer_size != 0)
{ {
png_size_t save_size = png_ptr->save_buffer_size; png_size_t save_size = png_ptr->save_buffer_size;
png_uint_32 skip_length = png_ptr->skip_length; png_uint_32 skip_length = png_ptr->skip_length;
@ -473,7 +473,7 @@ png_push_crc_finish(png_structrp png_ptr)
png_ptr->save_buffer_size -= save_size; png_ptr->save_buffer_size -= save_size;
png_ptr->save_buffer_ptr += save_size; png_ptr->save_buffer_ptr += save_size;
} }
if (png_ptr->skip_length && png_ptr->current_buffer_size) if (png_ptr->skip_length != 0 && png_ptr->current_buffer_size != 0)
{ {
png_size_t save_size = png_ptr->current_buffer_size; png_size_t save_size = png_ptr->current_buffer_size;
png_uint_32 skip_length = png_ptr->skip_length; png_uint_32 skip_length = png_ptr->skip_length;
@ -494,7 +494,7 @@ png_push_crc_finish(png_structrp png_ptr)
png_ptr->current_buffer_size -= save_size; png_ptr->current_buffer_size -= save_size;
png_ptr->current_buffer_ptr += save_size; png_ptr->current_buffer_ptr += save_size;
} }
if (!png_ptr->skip_length) if (png_ptr->skip_length == 0)
{ {
PNG_PUSH_SAVE_BUFFER_IF_LT(4) PNG_PUSH_SAVE_BUFFER_IF_LT(4)
png_crc_finish(png_ptr, 0); png_crc_finish(png_ptr, 0);
@ -511,7 +511,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
return; return;
ptr = buffer; ptr = buffer;
if (png_ptr->save_buffer_size) if (png_ptr->save_buffer_size != 0)
{ {
png_size_t save_size; png_size_t save_size;
@ -528,7 +528,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
png_ptr->save_buffer_size -= save_size; png_ptr->save_buffer_size -= save_size;
png_ptr->save_buffer_ptr += save_size; png_ptr->save_buffer_ptr += save_size;
} }
if (length && png_ptr->current_buffer_size) if (length != 0 && png_ptr->current_buffer_size != 0)
{ {
png_size_t save_size; png_size_t save_size;
@ -548,7 +548,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
void /* PRIVATE */ void /* PRIVATE */
png_push_save_buffer(png_structrp png_ptr) png_push_save_buffer(png_structrp png_ptr)
{ {
if (png_ptr->save_buffer_size) if (png_ptr->save_buffer_size != 0)
{ {
if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
{ {
@ -584,11 +584,13 @@ png_push_save_buffer(png_structrp png_ptr)
if (png_ptr->save_buffer == NULL) if (png_ptr->save_buffer == NULL)
{ {
png_free(png_ptr, old_buffer); png_free(png_ptr, old_buffer);
old_buffer = NULL;
png_error(png_ptr, "Insufficient memory for save_buffer"); png_error(png_ptr, "Insufficient memory for save_buffer");
} }
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_free(png_ptr, old_buffer);
old_buffer = NULL;
png_ptr->save_buffer_max = new_max; png_ptr->save_buffer_max = new_max;
} }
if (png_ptr->current_buffer_size) if (png_ptr->current_buffer_size)
@ -615,7 +617,7 @@ png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
void /* PRIVATE */ void /* PRIVATE */
png_push_read_IDAT(png_structrp png_ptr) png_push_read_IDAT(png_structrp png_ptr)
{ {
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
{ {
png_byte chunk_length[4]; png_byte chunk_length[4];
png_byte chunk_tag[4]; png_byte chunk_tag[4];
@ -633,7 +635,7 @@ png_push_read_IDAT(png_structrp png_ptr)
{ {
png_ptr->process_mode = PNG_READ_CHUNK_MODE; png_ptr->process_mode = PNG_READ_CHUNK_MODE;
if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
png_error(png_ptr, "Not enough compressed data"); png_error(png_ptr, "Not enough compressed data");
return; return;
@ -642,7 +644,7 @@ png_push_read_IDAT(png_structrp png_ptr)
png_ptr->idat_size = png_ptr->push_length; png_ptr->idat_size = png_ptr->push_length;
} }
if (png_ptr->idat_size && png_ptr->save_buffer_size) if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
{ {
png_size_t save_size = png_ptr->save_buffer_size; png_size_t save_size = png_ptr->save_buffer_size;
png_uint_32 idat_size = png_ptr->idat_size; png_uint_32 idat_size = png_ptr->idat_size;
@ -669,7 +671,7 @@ png_push_read_IDAT(png_structrp png_ptr)
png_ptr->save_buffer_ptr += save_size; png_ptr->save_buffer_ptr += save_size;
} }
if (png_ptr->idat_size && png_ptr->current_buffer_size) if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
{ {
png_size_t save_size = png_ptr->current_buffer_size; png_size_t save_size = png_ptr->current_buffer_size;
png_uint_32 idat_size = png_ptr->idat_size; png_uint_32 idat_size = png_ptr->idat_size;
@ -694,7 +696,7 @@ png_push_read_IDAT(png_structrp png_ptr)
png_ptr->current_buffer_size -= save_size; png_ptr->current_buffer_size -= save_size;
png_ptr->current_buffer_ptr += save_size; png_ptr->current_buffer_ptr += save_size;
} }
if (!png_ptr->idat_size) if (png_ptr->idat_size == 0)
{ {
PNG_PUSH_SAVE_BUFFER_IF_LT(4) PNG_PUSH_SAVE_BUFFER_IF_LT(4)
png_crc_finish(png_ptr, 0); png_crc_finish(png_ptr, 0);
@ -841,7 +843,7 @@ png_push_process_row(png_structrp png_ptr)
memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
#ifdef PNG_READ_TRANSFORMS_SUPPORTED #ifdef PNG_READ_TRANSFORMS_SUPPORTED
if (png_ptr->transformations) if (png_ptr->transformations != 0)
png_do_read_transformations(png_ptr, &row_info); png_do_read_transformations(png_ptr, &row_info);
#endif #endif
@ -859,7 +861,8 @@ png_push_process_row(png_structrp png_ptr)
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* Expand interlaced rows to full size */ /* Expand interlaced rows to full size */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced != 0 &&
(png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
@ -1066,7 +1069,7 @@ png_read_push_finish_row(png_structrp png_ptr)
if (png_ptr->row_number < png_ptr->num_rows) if (png_ptr->row_number < png_ptr->num_rows)
return; return;
if (png_ptr->interlaced) if (png_ptr->interlaced != 0)
{ {
png_ptr->row_number = 0; png_ptr->row_number = 0;
memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
@ -1090,7 +1093,7 @@ png_read_push_finish_row(png_structrp png_ptr)
png_pass_start[png_ptr->pass]) / png_pass_start[png_ptr->pass]) /
png_pass_inc[png_ptr->pass]; png_pass_inc[png_ptr->pass];
if (png_ptr->transformations & PNG_INTERLACE) if ((png_ptr->transformations & PNG_INTERLACE) != 0)
break; break;
png_ptr->num_rows = (png_ptr->height + png_ptr->num_rows = (png_ptr->height +
@ -1162,4 +1165,4 @@ png_get_progressive_ptr(png_const_structrp png_ptr)
return png_ptr->io_ptr; return png_ptr->io_ptr;
} }
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PROGRESSIVE_READ */

12
src/libpng/pngpriv.h
View File

@ -172,7 +172,7 @@
*/ */
# define PNG_ARM_NEON_IMPLEMENTATION 2 # define PNG_ARM_NEON_IMPLEMENTATION 2
# endif /* __ARM_NEON__ */ # endif /* __ARM_NEON__ */
# endif /* !defined PNG_ARM_NEON_IMPLEMENTATION */ # endif /* !PNG_ARM_NEON_IMPLEMENTATION */
# ifndef PNG_ARM_NEON_IMPLEMENTATION # ifndef PNG_ARM_NEON_IMPLEMENTATION
/* Use the intrinsics code by default. */ /* Use the intrinsics code by default. */
@ -855,7 +855,7 @@ PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
/* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB /* 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 * encoded value with maximum error 0.646365. Note that the input is not a
* 16-bit value; it has been multiplied by 255! */ * 16-bit value; it has been multiplied by 255! */
#endif /* PNG_SIMPLIFIED_READ/WRITE */ #endif /* SIMPLIFIED_READ/WRITE */
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
@ -1229,7 +1229,7 @@ PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr), PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
PNG_EMPTY); PNG_EMPTY);
/* Finish a row while reading, dealing with interlacing passes, etc. */ /* Finish a row while reading, dealing with interlacing passes, etc. */
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
/* Initialize the row buffers, etc. */ /* Initialize the row buffers, etc. */
PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY); PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
@ -1305,7 +1305,7 @@ PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
#ifdef PNG_READ_iCCP_SUPPORTED #ifdef PNG_READ_iCCP_SUPPORTED
PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
#endif /* PNG_READ_iCCP_SUPPORTED */ #endif /* READ_iCCP */
#ifdef PNG_READ_iTXt_SUPPORTED #ifdef PNG_READ_iTXt_SUPPORTED
PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
@ -1340,7 +1340,7 @@ PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
#ifdef PNG_READ_sPLT_SUPPORTED #ifdef PNG_READ_sPLT_SUPPORTED
PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
#endif /* PNG_READ_sPLT_SUPPORTED */ #endif /* READ_sPLT */
#ifdef PNG_READ_sRGB_SUPPORTED #ifdef PNG_READ_sRGB_SUPPORTED
PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
@ -1454,7 +1454,7 @@ PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
png_inforp info_ptr),PNG_EMPTY); png_inforp info_ptr),PNG_EMPTY);
# endif # endif
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PROGRESSIVE_READ */
/* Added at libpng version 1.6.0 */ /* Added at libpng version 1.6.0 */
#ifdef PNG_GAMMA_SUPPORTED #ifdef PNG_GAMMA_SUPPORTED

229
src/libpng/pngread.c
View File

@ -1,7 +1,7 @@
/* pngread.c - read a PNG file /* pngread.c - read a PNG file
* *
* Last changed in libpng 1.6.11 [June 5, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -44,7 +44,7 @@ png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
{ {
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* USER_MEM */
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
@ -113,20 +113,20 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
*/ */
if (chunk_name == png_IDAT) if (chunk_name == png_IDAT)
{ {
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_chunk_error(png_ptr, "Missing IHDR before IDAT"); png_chunk_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) (png_ptr->mode & PNG_HAVE_PLTE) == 0)
png_chunk_error(png_ptr, "Missing PLTE before IDAT"); png_chunk_error(png_ptr, "Missing PLTE before IDAT");
else if (png_ptr->mode & PNG_AFTER_IDAT) else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
png_chunk_benign_error(png_ptr, "Too many IDATs found"); png_chunk_benign_error(png_ptr, "Too many IDATs found");
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
} }
else if (png_ptr->mode & PNG_HAVE_IDAT) else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
/* This should be a binary subdivision search or a hash for /* This should be a binary subdivision search or a hash for
@ -252,7 +252,7 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
PNG_HANDLE_CHUNK_AS_DEFAULT); PNG_HANDLE_CHUNK_AS_DEFAULT);
} }
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
/* Optional call to update the users info_ptr structure */ /* Optional call to update the users info_ptr structure */
void PNGAPI void PNGAPI
@ -302,7 +302,7 @@ png_start_read_image(png_structrp png_ptr)
"png_start_read_image/png_read_update_info: duplicate call"); "png_start_read_image/png_read_update_info: duplicate call");
} }
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
@ -315,7 +315,7 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
png_debug(1, "in png_do_read_intrapixel"); png_debug(1, "in png_do_read_intrapixel");
if ( if (
(row_info->color_type & PNG_COLOR_MASK_COLOR)) (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
int bytes_per_pixel; int bytes_per_pixel;
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
@ -369,7 +369,7 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
} }
} }
} }
#endif /* PNG_MNG_FEATURES_SUPPORTED */ #endif /* MNG_FEATURES */
void PNGAPI void PNGAPI
png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row) png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
@ -385,7 +385,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
/* png_read_start_row sets the information (in particular iwidth) for this /* png_read_start_row sets the information (in particular iwidth) for this
* interlace pass. * interlace pass.
*/ */
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
/* 1.5.6: row_info moved out of png_struct to a local here. */ /* 1.5.6: row_info moved out of png_struct to a local here. */
@ -401,42 +401,42 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
{ {
/* Check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
if (png_ptr->transformations & PNG_FILLER) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
!defined(PNG_READ_PACKSWAP_SUPPORTED) !defined(PNG_READ_PACKSWAP_SUPPORTED)
if (png_ptr->transformations & PNG_PACKSWAP) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
if (png_ptr->transformations & PNG_PACK) if ((png_ptr->transformations & PNG_PACK) != 0)
png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
if (png_ptr->transformations & PNG_SHIFT) if ((png_ptr->transformations & PNG_SHIFT) != 0)
png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
if (png_ptr->transformations & PNG_BGR) if ((png_ptr->transformations & PNG_BGR) != 0)
png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
#endif #endif
#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
if (png_ptr->transformations & PNG_SWAP_BYTES) if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
#endif #endif
} }
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
#ifdef PNG_READ_INTERLACING_SUPPORTED #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.
@ -445,7 +445,8 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
* untransformed) and, because of the libpng API for interlaced images, this * untransformed) and, because of the libpng API for interlaced images, this
* means we must transform before de-interlacing. * means we must transform before de-interlacing.
*/ */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced != 0 &&
(png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
{ {
@ -516,7 +517,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
default: default:
case 6: case 6:
if (!(png_ptr->row_number & 1)) if ((png_ptr->row_number & 1) == 0)
{ {
png_read_finish_row(png_ptr); png_read_finish_row(png_ptr);
return; return;
@ -526,7 +527,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
} }
#endif #endif
if (!(png_ptr->mode & PNG_HAVE_IDAT)) if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
png_error(png_ptr, "Invalid attempt to read row data"); png_error(png_ptr, "Invalid attempt to read row data");
/* Fill the row with IDAT data: */ /* Fill the row with IDAT data: */
@ -549,7 +550,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
{ {
/* Intrapixel differencing */ /* Intrapixel differencing */
@ -575,8 +576,8 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* Expand interlaced rows to full size */ /* Expand interlaced rows to full size */
if (png_ptr->interlaced && if (png_ptr->interlaced != 0 &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
@ -604,7 +605,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
(*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
/* Read one or more rows of image data. If the image is interlaced, /* Read one or more rows of image data. If the image is interlaced,
@ -671,7 +672,7 @@ png_read_rows(png_structrp png_ptr, png_bytepp row,
dp++; dp++;
} }
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
/* Read the entire image. If the image has an alpha channel or a tRNS /* Read the entire image. If the image has an alpha channel or a tRNS
@ -699,7 +700,7 @@ png_read_image(png_structrp png_ptr, png_bytepp image)
return; return;
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
{ {
pass = png_set_interlace_handling(png_ptr); pass = png_set_interlace_handling(png_ptr);
/* And make sure transforms are initialized. */ /* And make sure transforms are initialized. */
@ -707,7 +708,8 @@ png_read_image(png_structrp png_ptr, png_bytepp image)
} }
else else
{ {
if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced != 0 &&
(png_ptr->transformations & PNG_INTERLACE) == 0)
{ {
/* Caller called png_start_read_image or png_read_update_info without /* Caller called png_start_read_image or png_read_update_info without
* first turning on the PNG_INTERLACE transform. We can fix this here, * first turning on the PNG_INTERLACE transform. We can fix this here,
@ -744,7 +746,7 @@ png_read_image(png_structrp png_ptr, png_bytepp image)
} }
} }
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
/* Read the end of the PNG file. Will not read past the end of the /* Read the end of the PNG file. Will not read past the end of the
@ -767,7 +769,7 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
* still be pending IDAT data and an owned zstream. Deal with this here. * still be pending IDAT data and an owned zstream. Deal with this here.
*/ */
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
if (!png_chunk_unknown_handling(png_ptr, png_IDAT)) if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
#endif #endif
png_read_finish_IDAT(png_ptr); png_read_finish_IDAT(png_ptr);
@ -797,7 +799,8 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
{ {
if (chunk_name == png_IDAT) if (chunk_name == png_IDAT)
{ {
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) if ((length > 0) ||
(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "Too many IDATs found"); png_benign_error(png_ptr, "Too many IDATs found");
} }
png_handle_unknown(png_ptr, info_ptr, length, keep); png_handle_unknown(png_ptr, info_ptr, length, keep);
@ -811,7 +814,8 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
/* Zero length IDATs are legal after the last IDAT has been /* Zero length IDATs are legal after the last IDAT has been
* read, but not after other chunks have been read. * read, but not after other chunks have been read.
*/ */
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) if ((length > 0) ||
(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "Too many IDATs found"); png_benign_error(png_ptr, "Too many IDATs found");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
@ -907,9 +911,9 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
else else
png_handle_unknown(png_ptr, info_ptr, length, png_handle_unknown(png_ptr, info_ptr, length,
PNG_HANDLE_CHUNK_AS_DEFAULT); PNG_HANDLE_CHUNK_AS_DEFAULT);
} while (!(png_ptr->mode & PNG_HAVE_IEND)); } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
} }
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
/* Free all memory used in the read struct */ /* Free all memory used in the read struct */
static void static void
@ -922,22 +926,33 @@ png_read_destroy(png_structrp png_ptr)
#endif #endif
png_free(png_ptr, png_ptr->big_row_buf); png_free(png_ptr, png_ptr->big_row_buf);
png_ptr->big_row_buf = NULL;
png_free(png_ptr, png_ptr->big_prev_row); png_free(png_ptr, png_ptr->big_prev_row);
png_ptr->big_prev_row = NULL;
png_free(png_ptr, png_ptr->read_buffer); png_free(png_ptr, png_ptr->read_buffer);
png_ptr->read_buffer = NULL;
#ifdef PNG_READ_QUANTIZE_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
png_free(png_ptr, png_ptr->palette_lookup); png_free(png_ptr, png_ptr->palette_lookup);
png_ptr->palette_lookup = NULL;
png_free(png_ptr, png_ptr->quantize_index); png_free(png_ptr, png_ptr->quantize_index);
png_ptr->quantize_index = NULL;
#endif #endif
if (png_ptr->free_me & PNG_FREE_PLTE) if ((png_ptr->free_me & PNG_FREE_PLTE) != 0)
{
png_zfree(png_ptr, png_ptr->palette); png_zfree(png_ptr, png_ptr->palette);
png_ptr->palette = NULL;
}
png_ptr->free_me &= ~PNG_FREE_PLTE; png_ptr->free_me &= ~PNG_FREE_PLTE;
#if defined(PNG_tRNS_SUPPORTED) || \ #if defined(PNG_tRNS_SUPPORTED) || \
defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
if (png_ptr->free_me & PNG_FREE_TRNS) if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
{
png_free(png_ptr, png_ptr->trans_alpha); png_free(png_ptr, png_ptr->trans_alpha);
png_ptr->trans_alpha = NULL;
}
png_ptr->free_me &= ~PNG_FREE_TRNS; png_ptr->free_me &= ~PNG_FREE_TRNS;
#endif #endif
@ -945,15 +960,18 @@ png_read_destroy(png_structrp png_ptr)
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
png_free(png_ptr, png_ptr->save_buffer); png_free(png_ptr, png_ptr->save_buffer);
png_ptr->save_buffer = NULL;
#endif #endif
#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) && \ #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) && \
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
png_free(png_ptr, png_ptr->unknown_chunk.data); png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL;
#endif #endif
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
png_free(png_ptr, png_ptr->chunk_list); png_free(png_ptr, png_ptr->chunk_list);
png_ptr->chunk_list = NULL;
#endif #endif
/* NOTE: the 'setjmp' buffer may still be allocated and the memory and error /* NOTE: the 'setjmp' buffer may still be allocated and the memory and error
@ -1025,7 +1043,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Tell libpng to strip 16-bit/color files down to 8 bits per color. /* Tell libpng to strip 16-bit/color files down to 8 bits per color.
*/ */
if (transforms & PNG_TRANSFORM_SCALE_16) if ((transforms & PNG_TRANSFORM_SCALE_16) != 0)
/* Added at libpng-1.5.4. "strip_16" produces the same result that it /* 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. * did in earlier versions, while "scale_16" is now more accurate.
*/ */
@ -1039,7 +1057,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
* latter by doing SCALE first. This is ok and allows apps not to check for * latter by doing SCALE first. This is ok and allows apps not to check for
* which is supported to get the right answer. * which is supported to get the right answer.
*/ */
if (transforms & PNG_TRANSFORM_STRIP_16) if ((transforms & PNG_TRANSFORM_STRIP_16) != 0)
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
png_set_strip_16(png_ptr); png_set_strip_16(png_ptr);
#else #else
@ -1049,7 +1067,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Strip alpha bytes from the input data without combining with /* Strip alpha bytes from the input data without combining with
* the background (not recommended). * the background (not recommended).
*/ */
if (transforms & PNG_TRANSFORM_STRIP_ALPHA) if ((transforms & PNG_TRANSFORM_STRIP_ALPHA) != 0)
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
png_set_strip_alpha(png_ptr); png_set_strip_alpha(png_ptr);
#else #else
@ -1059,7 +1077,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Extract multiple pixels with bit depths of 1, 2, or 4 from a single /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single
* byte into separate bytes (useful for paletted and grayscale images). * byte into separate bytes (useful for paletted and grayscale images).
*/ */
if (transforms & PNG_TRANSFORM_PACKING) if ((transforms & PNG_TRANSFORM_PACKING) != 0)
#ifdef PNG_READ_PACK_SUPPORTED #ifdef PNG_READ_PACK_SUPPORTED
png_set_packing(png_ptr); png_set_packing(png_ptr);
#else #else
@ -1069,7 +1087,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Change the order of packed pixels to least significant bit first /* Change the order of packed pixels to least significant bit first
* (not useful if you are using png_set_packing). * (not useful if you are using png_set_packing).
*/ */
if (transforms & PNG_TRANSFORM_PACKSWAP) if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
#ifdef PNG_READ_PACKSWAP_SUPPORTED #ifdef PNG_READ_PACKSWAP_SUPPORTED
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
#else #else
@ -1081,7 +1099,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
* Expand paletted or RGB images with transparency to full alpha * Expand paletted or RGB images with transparency to full alpha
* channels so the data will be available as RGBA quartets. * channels so the data will be available as RGBA quartets.
*/ */
if (transforms & PNG_TRANSFORM_EXPAND) if ((transforms & PNG_TRANSFORM_EXPAND) != 0)
#ifdef PNG_READ_EXPAND_SUPPORTED #ifdef PNG_READ_EXPAND_SUPPORTED
png_set_expand(png_ptr); png_set_expand(png_ptr);
#else #else
@ -1093,7 +1111,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Invert monochrome files to have 0 as white and 1 as black /* Invert monochrome files to have 0 as white and 1 as black
*/ */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
#ifdef PNG_READ_INVERT_SUPPORTED #ifdef PNG_READ_INVERT_SUPPORTED
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
#else #else
@ -1104,16 +1122,16 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
* [0,65535] to the original [0,7] or [0,31], or whatever range the * [0,65535] to the original [0,7] or [0,31], or whatever range the
* colors were originally in: * colors were originally in:
*/ */
if (transforms & PNG_TRANSFORM_SHIFT) if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
#ifdef PNG_READ_SHIFT_SUPPORTED #ifdef PNG_READ_SHIFT_SUPPORTED
if (info_ptr->valid & PNG_INFO_sBIT) if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
png_set_shift(png_ptr, &info_ptr->sig_bit); png_set_shift(png_ptr, &info_ptr->sig_bit);
#else #else
png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported"); png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
#endif #endif
/* Flip the RGB pixels to BGR (or RGBA to BGRA) */ /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
if (transforms & PNG_TRANSFORM_BGR) if ((transforms & PNG_TRANSFORM_BGR) != 0)
#ifdef PNG_READ_BGR_SUPPORTED #ifdef PNG_READ_BGR_SUPPORTED
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#else #else
@ -1121,7 +1139,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#else #else
@ -1129,7 +1147,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* 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) if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
#ifdef PNG_READ_SWAP_SUPPORTED #ifdef PNG_READ_SWAP_SUPPORTED
png_set_swap(png_ptr); png_set_swap(png_ptr);
#else #else
@ -1138,7 +1156,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Added at libpng-1.2.41 */ /* Added at libpng-1.2.41 */
/* Invert the alpha channel from opacity to transparency */ /* Invert the alpha channel from opacity to transparency */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
#else #else
@ -1147,7 +1165,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
/* Added at libpng-1.2.41 */ /* Added at libpng-1.2.41 */
/* Expand grayscale image to RGB */ /* Expand grayscale image to RGB */
if (transforms & PNG_TRANSFORM_GRAY_TO_RGB) if ((transforms & PNG_TRANSFORM_GRAY_TO_RGB) != 0)
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
png_set_gray_to_rgb(png_ptr); png_set_gray_to_rgb(png_ptr);
#else #else
@ -1155,7 +1173,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Added at libpng-1.5.4 */ /* Added at libpng-1.5.4 */
if (transforms & PNG_TRANSFORM_EXPAND_16) if ((transforms & PNG_TRANSFORM_EXPAND_16) != 0)
#ifdef PNG_READ_EXPAND_16_SUPPORTED #ifdef PNG_READ_EXPAND_16_SUPPORTED
png_set_expand_16(png_ptr); png_set_expand_16(png_ptr);
#else #else
@ -1203,8 +1221,8 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
PNG_UNUSED(params) PNG_UNUSED(params)
} }
#endif /* PNG_INFO_IMAGE_SUPPORTED */ #endif /* INFO_IMAGE */
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ #endif /* SEQUENTIAL_READ */
#ifdef PNG_SIMPLIFIED_READ_SUPPORTED #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
/* SIMPLIFIED READ /* SIMPLIFIED READ
@ -1313,10 +1331,10 @@ png_image_format(png_structrp png_ptr)
{ {
png_uint_32 format = 0; png_uint_32 format = 0;
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
format |= PNG_FORMAT_FLAG_COLOR; format |= PNG_FORMAT_FLAG_COLOR;
if (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
format |= PNG_FORMAT_FLAG_ALPHA; format |= PNG_FORMAT_FLAG_ALPHA;
/* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS /* Use png_ptr here, not info_ptr, because by examination png_handle_tRNS
@ -1330,7 +1348,7 @@ png_image_format(png_structrp png_ptr)
if (png_ptr->bit_depth == 16) if (png_ptr->bit_depth == 16)
format |= PNG_FORMAT_FLAG_LINEAR; format |= PNG_FORMAT_FLAG_LINEAR;
if (png_ptr->color_type & PNG_COLOR_MASK_PALETTE) if ((png_ptr->color_type & PNG_COLOR_MASK_PALETTE) != 0)
format |= PNG_FORMAT_FLAG_COLORMAP; format |= PNG_FORMAT_FLAG_COLORMAP;
return format; return format;
@ -1430,7 +1448,7 @@ png_image_begin_read_from_stdio(png_imagep image, FILE* file)
{ {
if (file != NULL) if (file != NULL)
{ {
if (png_image_read_init(image)) if (png_image_read_init(image) != 0)
{ {
/* This is slightly evil, but png_init_io doesn't do anything other /* 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 * than this and we haven't changed the standard IO functions so
@ -1464,7 +1482,7 @@ png_image_begin_read_from_file(png_imagep image, const char *file_name)
if (fp != NULL) if (fp != NULL)
{ {
if (png_image_read_init(image)) if (png_image_read_init(image) != 0)
{ {
image->opaque->png_ptr->io_ptr = fp; image->opaque->png_ptr->io_ptr = fp;
image->opaque->owned_file = 1; image->opaque->owned_file = 1;
@ -1490,7 +1508,7 @@ png_image_begin_read_from_file(png_imagep image, const char *file_name)
return 0; return 0;
} }
#endif /* PNG_STDIO_SUPPORTED */ #endif /* STDIO */
static void PNGCBAPI static void PNGCBAPI
png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need) png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
@ -1529,7 +1547,7 @@ int PNGAPI png_image_begin_read_from_memory(png_imagep image,
{ {
if (memory != NULL && size > 0) if (memory != NULL && size > 0)
{ {
if (png_image_read_init(image)) if (png_image_read_init(image) != 0)
{ {
/* Now set the IO functions to read from the memory buffer and /* 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 * store it into io_ptr. Again do this in-place to avoid calling a
@ -1601,14 +1619,14 @@ png_image_skip_unused_chunks(png_structrp png_ptr)
/* But do not ignore image data handling chunks */ /* But do not ignore image data handling chunks */
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT, png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
chunks_to_process, (sizeof chunks_to_process)/5); chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5);
} }
} }
# define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p) # define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p)
#else #else
# define PNG_SKIP_CHUNKS(p) ((void)0) # define PNG_SKIP_CHUNKS(p) ((void)0)
#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */ #endif /* HANDLE_AS_UNKNOWN */
/* The following macro gives the exact rounded answer for all values in the /* 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 * range 0..255 (it actually divides by 51.2, but the rounding still generates
@ -1621,9 +1639,9 @@ static void
set_file_encoding(png_image_read_control *display) set_file_encoding(png_image_read_control *display)
{ {
png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma; png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
if (png_gamma_significant(g)) if (png_gamma_significant(g) != 0)
{ {
if (png_gamma_not_sRGB(g)) if (png_gamma_not_sRGB(g) != 0)
{ {
display->file_encoding = P_FILE; display->file_encoding = P_FILE;
display->gamma_to_linear = png_reciprocal(g); display->gamma_to_linear = png_reciprocal(g);
@ -1718,7 +1736,7 @@ png_create_colormap_entry(png_image_read_control *display,
png_uint_32 alpha, int encoding) png_uint_32 alpha, int encoding)
{ {
png_imagep image = display->image; png_imagep image = display->image;
const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) ? const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
P_LINEAR : P_sRGB; P_LINEAR : P_sRGB;
const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 && const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
(red != green || green != blue); (red != green || green != blue);
@ -1748,7 +1766,7 @@ png_create_colormap_entry(png_image_read_control *display,
green = png_gamma_16bit_correct(green*257, g); green = png_gamma_16bit_correct(green*257, g);
blue = png_gamma_16bit_correct(blue*257, g); blue = png_gamma_16bit_correct(blue*257, g);
if (convert_to_Y || output_encoding == P_LINEAR) if (convert_to_Y != 0 || output_encoding == P_LINEAR)
{ {
alpha *= 257; alpha *= 257;
encoding = P_LINEAR; encoding = P_LINEAR;
@ -1775,7 +1793,8 @@ png_create_colormap_entry(png_image_read_control *display,
encoding = P_LINEAR; encoding = P_LINEAR;
} }
else if (encoding == P_sRGB && (convert_to_Y || output_encoding == P_LINEAR)) else if (encoding == P_sRGB &&
(convert_to_Y != 0 || output_encoding == P_LINEAR))
{ {
/* The values are 8-bit sRGB values, but must be converted to 16-bit /* The values are 8-bit sRGB values, but must be converted to 16-bit
* linear. * linear.
@ -1833,7 +1852,7 @@ png_create_colormap_entry(png_image_read_control *display,
# define afirst 0 # define afirst 0
# endif # endif
# ifdef PNG_FORMAT_BGR_SUPPORTED # ifdef PNG_FORMAT_BGR_SUPPORTED
const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) ? 2 : 0; const int bgr = (image->format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
# else # else
# define bgr 0 # define bgr 0
# endif # endif
@ -2045,7 +2064,7 @@ png_image_read_colormap(png_voidp argument)
const png_structrp png_ptr = image->opaque->png_ptr; const png_structrp png_ptr = image->opaque->png_ptr;
const png_uint_32 output_format = image->format; const png_uint_32 output_format = image->format;
const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) ? const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
P_LINEAR : P_sRGB; P_LINEAR : P_sRGB;
unsigned int cmap_entries; unsigned int cmap_entries;
@ -2084,7 +2103,7 @@ png_image_read_colormap(png_voidp argument)
else else
{ {
back_g = display->background->green; back_g = display->background->green;
if (output_format & PNG_FORMAT_FLAG_COLOR) if ((output_format & PNG_FORMAT_FLAG_COLOR) != 0)
{ {
back_r = display->background->red; back_r = display->background->red;
back_b = display->background->blue; back_b = display->background->blue;
@ -2226,7 +2245,7 @@ png_image_read_colormap(png_voidp argument)
{ {
unsigned int back_alpha; unsigned int back_alpha;
if (output_format & PNG_FORMAT_FLAG_ALPHA) if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
back_alpha = 0; back_alpha = 0;
else else
@ -2307,7 +2326,7 @@ png_image_read_colormap(png_voidp argument)
*/ */
data_encoding = P_sRGB; data_encoding = P_sRGB;
if (output_format & PNG_FORMAT_FLAG_ALPHA) if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries) if (PNG_GA_COLORMAP_ENTRIES > image->colormap_entries)
png_error(png_ptr, "gray+alpha color-map: too few entries"); png_error(png_ptr, "gray+alpha color-map: too few entries");
@ -2502,7 +2521,7 @@ png_image_read_colormap(png_voidp argument)
*/ */
if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || if ((png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
png_ptr->num_trans > 0) && png_ptr->num_trans > 0) &&
png_gamma_not_sRGB(png_ptr->colorspace.gamma)) png_gamma_not_sRGB(png_ptr->colorspace.gamma) != 0)
{ {
cmap_entries = make_gray_file_colormap(display); cmap_entries = make_gray_file_colormap(display);
data_encoding = P_FILE; data_encoding = P_FILE;
@ -2590,7 +2609,7 @@ png_image_read_colormap(png_voidp argument)
/* Is there alpha in the output too? If so all four channels are /* Is there alpha in the output too? If so all four channels are
* processed into a special RGB cube with alpha support. * processed into a special RGB cube with alpha support.
*/ */
if (output_format & PNG_FORMAT_FLAG_ALPHA) if ((output_format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
png_uint_32 r; png_uint_32 r;
@ -2764,7 +2783,7 @@ png_image_read_colormap(png_voidp argument)
for (i=0; i < cmap_entries; ++i) for (i=0; i < cmap_entries; ++i)
{ {
if (do_background && i < num_trans && trans[i] < 255) if (do_background != 0 && i < num_trans && trans[i] < 255)
{ {
if (trans[i] == 0) if (trans[i] == 0)
png_create_colormap_entry(display, i, back_r, back_g, png_create_colormap_entry(display, i, back_r, back_g,
@ -2809,8 +2828,8 @@ png_image_read_colormap(png_voidp argument)
} }
/* Now deal with the output processing */ /* Now deal with the output processing */
if (expand_tRNS && png_ptr->num_trans > 0 && if (expand_tRNS != 0 && png_ptr->num_trans > 0 &&
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0) (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) == 0)
png_set_tRNS_to_alpha(png_ptr); png_set_tRNS_to_alpha(png_ptr);
switch (data_encoding) switch (data_encoding)
@ -3226,7 +3245,8 @@ png_image_read_composite(png_voidp argument)
png_uint_32 height = image->height; png_uint_32 height = image->height;
png_uint_32 width = image->width; png_uint_32 width = image->width;
ptrdiff_t step_row = display->row_bytes; ptrdiff_t step_row = display->row_bytes;
unsigned int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; unsigned int channels =
(image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
int pass; int pass;
for (pass = 0; pass < passes; ++pass) for (pass = 0; pass < passes; ++pass)
@ -3524,7 +3544,8 @@ png_image_read_background(png_voidp argument)
int swap_alpha = 0; int swap_alpha = 0;
# ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
if (preserve_alpha && (image->format & PNG_FORMAT_FLAG_AFIRST)) if (preserve_alpha != 0 &&
(image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
swap_alpha = 1; swap_alpha = 1;
# endif # endif
@ -3633,10 +3654,10 @@ png_image_read_direct(png_voidp argument)
int mode; /* alpha mode */ int mode; /* alpha mode */
/* Do this first so that we have a record if rgb to gray is happening. */ /* Do this first so that we have a record if rgb to gray is happening. */
if (change & PNG_FORMAT_FLAG_COLOR) if ((change & PNG_FORMAT_FLAG_COLOR) != 0)
{ {
/* gray<->color transformation required. */ /* gray<->color transformation required. */
if (format & PNG_FORMAT_FLAG_COLOR) if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
png_set_gray_to_rgb(png_ptr); png_set_gray_to_rgb(png_ptr);
else else
@ -3654,7 +3675,7 @@ png_image_read_direct(png_voidp argument)
* enormous change) 'do_local_background' is used to indicate that * enormous change) 'do_local_background' is used to indicate that
* the problem exists. * the problem exists.
*/ */
if (base_format & PNG_FORMAT_FLAG_ALPHA) if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
do_local_background = 1/*maybe*/; do_local_background = 1/*maybe*/;
png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
@ -3669,8 +3690,8 @@ png_image_read_direct(png_voidp argument)
{ {
png_fixed_point input_gamma_default; png_fixed_point input_gamma_default;
if ((base_format & PNG_FORMAT_FLAG_LINEAR) && if ((base_format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
(image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0) (image->flags & PNG_IMAGE_FLAG_16BIT_sRGB) == 0)
input_gamma_default = PNG_GAMMA_LINEAR; input_gamma_default = PNG_GAMMA_LINEAR;
else else
input_gamma_default = PNG_DEFAULT_sRGB; input_gamma_default = PNG_DEFAULT_sRGB;
@ -3686,7 +3707,7 @@ png_image_read_direct(png_voidp argument)
/* If there *is* an alpha channel in the input it must be multiplied /* If there *is* an alpha channel in the input it must be multiplied
* out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG. * out; use PNG_ALPHA_STANDARD, otherwise just use PNG_ALPHA_PNG.
*/ */
if (base_format & PNG_FORMAT_FLAG_ALPHA) if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
mode = PNG_ALPHA_STANDARD; /* associated alpha */ mode = PNG_ALPHA_STANDARD; /* associated alpha */
else else
@ -3717,7 +3738,7 @@ png_image_read_direct(png_voidp argument)
* final value. * final value.
*/ */
if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma, if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma,
PNG_FP_1) && !png_gamma_significant(gtest)) PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0)
do_local_background = 0; do_local_background = 0;
else if (mode == PNG_ALPHA_STANDARD) else if (mode == PNG_ALPHA_STANDARD)
@ -3730,9 +3751,9 @@ png_image_read_direct(png_voidp argument)
} }
/* If the bit-depth changes then handle that here. */ /* If the bit-depth changes then handle that here. */
if (change & PNG_FORMAT_FLAG_LINEAR) if ((change & PNG_FORMAT_FLAG_LINEAR) != 0)
{ {
if (linear /*16-bit output*/) if (linear != 0 /*16-bit output*/)
png_set_expand_16(png_ptr); png_set_expand_16(png_ptr);
else /* 8-bit output */ else /* 8-bit output */
@ -3742,13 +3763,13 @@ png_image_read_direct(png_voidp argument)
} }
/* Now the background/alpha channel changes. */ /* Now the background/alpha channel changes. */
if (change & PNG_FORMAT_FLAG_ALPHA) if ((change & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
/* Removing an alpha channel requires composition for the 8-bit /* Removing an alpha channel requires composition for the 8-bit
* formats; for the 16-bit it is already done, above, by the * formats; for the 16-bit it is already done, above, by the
* pre-multiplication and the channel just needs to be stripped. * pre-multiplication and the channel just needs to be stripped.
*/ */
if (base_format & PNG_FORMAT_FLAG_ALPHA) if ((base_format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
/* If RGB->gray is happening the alpha channel must be left and the /* If RGB->gray is happening the alpha channel must be left and the
* operation completed locally. * operation completed locally.
@ -3813,7 +3834,7 @@ png_image_read_direct(png_voidp argument)
filler = 255; filler = 255;
# ifdef PNG_FORMAT_AFIRST_SUPPORTED # ifdef PNG_FORMAT_AFIRST_SUPPORTED
if (format & PNG_FORMAT_FLAG_AFIRST) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
where = PNG_FILLER_BEFORE; where = PNG_FILLER_BEFORE;
change &= ~PNG_FORMAT_FLAG_AFIRST; change &= ~PNG_FORMAT_FLAG_AFIRST;
@ -3837,12 +3858,12 @@ png_image_read_direct(png_voidp argument)
png_set_alpha_mode_fixed(png_ptr, mode, output_gamma); png_set_alpha_mode_fixed(png_ptr, mode, output_gamma);
# ifdef PNG_FORMAT_BGR_SUPPORTED # ifdef PNG_FORMAT_BGR_SUPPORTED
if (change & PNG_FORMAT_FLAG_BGR) if ((change & PNG_FORMAT_FLAG_BGR) != 0)
{ {
/* Check only the output format; PNG is never BGR; don't do this if /* 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. * the output is gray, but fix up the 'format' value in that case.
*/ */
if (format & PNG_FORMAT_FLAG_COLOR) if ((format & PNG_FORMAT_FLAG_COLOR) != 0)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
else else
@ -3853,14 +3874,14 @@ png_image_read_direct(png_voidp argument)
# endif # endif
# ifdef PNG_FORMAT_AFIRST_SUPPORTED # ifdef PNG_FORMAT_AFIRST_SUPPORTED
if (change & PNG_FORMAT_FLAG_AFIRST) if ((change & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
/* Only relevant if there is an alpha channel - it's particularly /* Only relevant if there is an alpha channel - it's particularly
* important to handle this correctly because do_local_compose may * important to handle this correctly because do_local_compose may
* be set above and then libpng will keep the alpha channel for this * be set above and then libpng will keep the alpha channel for this
* code to remove. * code to remove.
*/ */
if (format & PNG_FORMAT_FLAG_ALPHA) if ((format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
/* Disable this if doing a local background, /* Disable this if doing a local background,
* TODO: remove this when local background is no longer required. * TODO: remove this when local background is no longer required.
@ -3883,7 +3904,7 @@ png_image_read_direct(png_voidp argument)
{ {
PNG_CONST png_uint_16 le = 0x0001; PNG_CONST png_uint_16 le = 0x0001;
if (*(png_const_bytep)&le) if ((*(png_const_bytep) & le) != 0)
png_set_swap(png_ptr); png_set_swap(png_ptr);
} }
@ -3908,10 +3929,10 @@ png_image_read_direct(png_voidp argument)
{ {
png_uint_32 info_format = 0; png_uint_32 info_format = 0;
if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
info_format |= PNG_FORMAT_FLAG_COLOR; info_format |= PNG_FORMAT_FLAG_COLOR;
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
{ {
/* do_local_compose removes this channel below. */ /* do_local_compose removes this channel below. */
if (do_local_compose == 0) if (do_local_compose == 0)
@ -3930,14 +3951,14 @@ png_image_read_direct(png_voidp argument)
info_format |= PNG_FORMAT_FLAG_LINEAR; info_format |= PNG_FORMAT_FLAG_LINEAR;
# ifdef PNG_FORMAT_BGR_SUPPORTED # ifdef PNG_FORMAT_BGR_SUPPORTED
if (png_ptr->transformations & PNG_BGR) if ((png_ptr->transformations & PNG_BGR) != 0)
info_format |= PNG_FORMAT_FLAG_BGR; info_format |= PNG_FORMAT_FLAG_BGR;
# endif # endif
# ifdef PNG_FORMAT_AFIRST_SUPPORTED # ifdef PNG_FORMAT_AFIRST_SUPPORTED
if (do_local_background == 2) if (do_local_background == 2)
{ {
if (format & PNG_FORMAT_FLAG_AFIRST) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
info_format |= PNG_FORMAT_FLAG_AFIRST; info_format |= PNG_FORMAT_FLAG_AFIRST;
} }
@ -4066,7 +4087,7 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
/* Choose the correct 'end' routine; for the color-map case all the /* Choose the correct 'end' routine; for the color-map case all the
* setup has already been done. * setup has already been done.
*/ */
if (image->format & PNG_FORMAT_FLAG_COLORMAP) if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
result = result =
png_safe_execute(image, png_image_read_colormap, &display) && png_safe_execute(image, png_image_read_colormap, &display) &&
png_safe_execute(image, png_image_read_colormapped, &display); png_safe_execute(image, png_image_read_colormapped, &display);
@ -4096,5 +4117,5 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
return 0; return 0;
} }
#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ #endif /* SIMPLIFIED_READ */
#endif /* PNG_READ_SUPPORTED */ #endif /* READ */

4
src/libpng/pngrio.c
View File

@ -1,7 +1,7 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
* *
* Last changed in libpng 1.6.9 [February 6, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -117,4 +117,4 @@ png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
png_ptr->output_flush_fn = NULL; png_ptr->output_flush_fn = NULL;
#endif #endif
} }
#endif /* PNG_READ_SUPPORTED */ #endif /* READ */

337
src/libpng/pngrtran.c
View File

@ -1,7 +1,7 @@
/* pngrtran.c - transforms the data in a row for PNG readers /* pngrtran.c - transforms the data in a row for PNG readers
* *
* Last changed in libpng 1.6.11 [June 5, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -91,14 +91,15 @@ png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action)
#ifdef PNG_READ_TRANSFORMS_SUPPORTED #ifdef PNG_READ_TRANSFORMS_SUPPORTED
/* Is it OK to set a transformation now? Only if png_start_read_image or /* 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 * 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. * to have been read in all cases; the need_IHDR parameter allows for this
* check too.
*/ */
static int static int
png_rtran_ok(png_structrp png_ptr, int need_IHDR) png_rtran_ok(png_structrp png_ptr, int need_IHDR)
{ {
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
if (png_ptr->flags & PNG_FLAG_ROW_INIT) if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
png_app_error(png_ptr, png_app_error(png_ptr,
"invalid after png_start_read_image or png_read_update_info"); "invalid after png_start_read_image or png_read_update_info");
@ -127,7 +128,7 @@ png_set_background_fixed(png_structrp png_ptr,
{ {
png_debug(1, "in png_set_background_fixed"); png_debug(1, "in png_set_background_fixed");
if (!png_rtran_ok(png_ptr, 0) || background_color == NULL) if (png_rtran_ok(png_ptr, 0) == 0 || background_color == NULL)
return; return;
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
@ -171,7 +172,7 @@ png_set_scale_16(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_scale_16"); png_debug(1, "in png_set_scale_16");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= PNG_SCALE_16_TO_8; png_ptr->transformations |= PNG_SCALE_16_TO_8;
@ -185,7 +186,7 @@ png_set_strip_16(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_strip_16"); png_debug(1, "in png_set_strip_16");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= PNG_16_TO_8; png_ptr->transformations |= PNG_16_TO_8;
@ -198,7 +199,7 @@ png_set_strip_alpha(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_strip_alpha"); png_debug(1, "in png_set_strip_alpha");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= PNG_STRIP_ALPHA; png_ptr->transformations |= PNG_STRIP_ALPHA;
@ -279,7 +280,7 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
png_debug(1, "in png_set_alpha_mode"); png_debug(1, "in png_set_alpha_mode");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/); output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
@ -371,7 +372,7 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE; png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE;
png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
if (png_ptr->transformations & PNG_COMPOSE) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
png_error(png_ptr, png_error(png_ptr,
"conflicting calls to set alpha mode and background"); "conflicting calls to set alpha mode and background");
@ -415,7 +416,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
{ {
png_debug(1, "in png_set_quantize"); png_debug(1, "in png_set_quantize");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= PNG_QUANTIZE; png_ptr->transformations |= PNG_QUANTIZE;
@ -793,7 +794,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
png_free(png_ptr, distance); png_free(png_ptr, distance);
} }
} }
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ #endif /* READ_QUANTIZE */
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
void PNGFAPI void PNGFAPI
@ -802,7 +803,7 @@ png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma,
{ {
png_debug(1, "in png_set_gamma_fixed"); png_debug(1, "in png_set_gamma_fixed");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
/* New in libpng-1.5.4 - reserve particular negative values as flags. */ /* New in libpng-1.5.4 - reserve particular negative values as flags. */
@ -842,7 +843,7 @@ png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma)
png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma), png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
convert_gamma_value(png_ptr, file_gamma)); convert_gamma_value(png_ptr, file_gamma));
} }
# endif /* FLOATING_POINT_SUPPORTED */ # endif /* FLOATING_POINT */
#endif /* READ_GAMMA */ #endif /* READ_GAMMA */
#ifdef PNG_READ_EXPAND_SUPPORTED #ifdef PNG_READ_EXPAND_SUPPORTED
@ -855,7 +856,7 @@ png_set_expand(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_expand"); png_debug(1, "in png_set_expand");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
@ -885,7 +886,7 @@ png_set_palette_to_rgb(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_palette_to_rgb"); png_debug(1, "in png_set_palette_to_rgb");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
@ -897,7 +898,7 @@ 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"); png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= PNG_EXPAND; png_ptr->transformations |= PNG_EXPAND;
@ -909,12 +910,12 @@ png_set_tRNS_to_alpha(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_tRNS_to_alpha"); png_debug(1, "in png_set_tRNS_to_alpha");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
} }
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ #endif /* READ_EXPAND */
#ifdef PNG_READ_EXPAND_16_SUPPORTED #ifdef PNG_READ_EXPAND_16_SUPPORTED
/* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise /* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise
@ -925,7 +926,7 @@ png_set_expand_16(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_expand_16"); png_debug(1, "in png_set_expand_16");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS); png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS);
@ -938,7 +939,7 @@ png_set_gray_to_rgb(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_gray_to_rgb"); png_debug(1, "in png_set_gray_to_rgb");
if (!png_rtran_ok(png_ptr, 0)) if (png_rtran_ok(png_ptr, 0) == 0)
return; return;
/* Because rgb must be 8 bits or more: */ /* Because rgb must be 8 bits or more: */
@ -956,7 +957,7 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
/* Need the IHDR here because of the check on color_type below. */ /* Need the IHDR here because of the check on color_type below. */
/* TODO: fix this */ /* TODO: fix this */
if (!png_rtran_ok(png_ptr, 1)) if (png_rtran_ok(png_ptr, 1) == 0)
return; return;
switch (error_action) switch (error_action)
@ -998,7 +999,7 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
png_uint_16 red_int, green_int; png_uint_16 red_int, green_int;
/* NOTE: this calculation does not round, but this behavior is retained /* NOTE: this calculation does not round, but this behavior is retained
* for consistency, the inaccuracy is very small. The code here always * for consistency; the inaccuracy is very small. The code here always
* overwrites the coefficients, regardless of whether they have been * overwrites the coefficients, regardless of whether they have been
* defaulted or set already. * defaulted or set already.
*/ */
@ -1091,7 +1092,7 @@ png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma)
* the palette. * the palette.
*/ */
/*For the moment 'png_init_palette_transformations' and /* For the moment 'png_init_palette_transformations' and
* 'png_init_rgb_transformations' only do some flag canceling optimizations. * 'png_init_rgb_transformations' only do some flag canceling optimizations.
* The intent is that these two routines should have palette or rgb operations * The intent is that these two routines should have palette or rgb operations
* extracted from 'png_init_read_transformations'. * extracted from 'png_init_read_transformations'.
@ -1153,8 +1154,8 @@ png_init_palette_transformations(png_structrp png_ptr)
/* The following code cannot be entered in the alpha pre-multiplication case /* The following code cannot be entered in the alpha pre-multiplication case
* because PNG_BACKGROUND_EXPAND is cancelled below. * because PNG_BACKGROUND_EXPAND is cancelled below.
*/ */
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
(png_ptr->transformations & PNG_EXPAND)) (png_ptr->transformations & PNG_EXPAND) != 0)
{ {
{ {
png_ptr->background.red = png_ptr->background.red =
@ -1165,9 +1166,9 @@ png_init_palette_transformations(png_structrp png_ptr)
png_ptr->palette[png_ptr->background.index].blue; png_ptr->palette[png_ptr->background.index].blue;
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_INVERT_ALPHA) if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
{ {
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
{ {
/* Invert the alpha channel (in tRNS) unless the pixels are /* Invert the alpha channel (in tRNS) unless the pixels are
* going to be expanded, in which case leave it for later * going to be expanded, in which case leave it for later
@ -1179,10 +1180,10 @@ png_init_palette_transformations(png_structrp png_ptr)
png_ptr->trans_alpha[i]); png_ptr->trans_alpha[i]);
} }
} }
#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */ #endif /* READ_INVERT_ALPHA */
} }
} /* background expand and (therefore) no alpha association. */ } /* background expand and (therefore) no alpha association. */
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ #endif /* READ_EXPAND && READ_BACKGROUND */
} }
static void /* PRIVATE */ static void /* PRIVATE */
@ -1220,9 +1221,9 @@ png_init_rgb_transformations(png_structrp png_ptr)
/* The following code cannot be entered in the alpha pre-multiplication case /* The following code cannot be entered in the alpha pre-multiplication case
* because PNG_BACKGROUND_EXPAND is cancelled below. * because PNG_BACKGROUND_EXPAND is cancelled below.
*/ */
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0 &&
(png_ptr->transformations & PNG_EXPAND) && (png_ptr->transformations & PNG_EXPAND) != 0 &&
!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) (png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
/* i.e., GRAY or GRAY_ALPHA */ /* i.e., GRAY or GRAY_ALPHA */
{ {
{ {
@ -1260,14 +1261,14 @@ png_init_rgb_transformations(png_structrp png_ptr)
png_ptr->background.red = png_ptr->background.green = png_ptr->background.red = png_ptr->background.green =
png_ptr->background.blue = (png_uint_16)gray; png_ptr->background.blue = (png_uint_16)gray;
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) if ((png_ptr->transformations & PNG_EXPAND_tRNS) == 0)
{ {
png_ptr->trans_color.red = png_ptr->trans_color.green = png_ptr->trans_color.red = png_ptr->trans_color.green =
png_ptr->trans_color.blue = (png_uint_16)trans_gray; png_ptr->trans_color.blue = (png_uint_16)trans_gray;
} }
} }
} /* background expand and (therefore) no alpha association. */ } /* background expand and (therefore) no alpha association. */
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ #endif /* READ_EXPAND && READ_BACKGROUND */
} }
void /* PRIVATE */ void /* PRIVATE */
@ -1345,7 +1346,7 @@ png_init_read_transformations(png_structrp png_ptr)
#endif #endif
/* Certain transformations have the effect of preventing other /* Certain transformations have the effect of preventing other
* transformations that happen afterward in png_do_read_transformations, * transformations that happen afterward in png_do_read_transformations;
* resolve the interdependencies here. From the code of * resolve the interdependencies here. From the code of
* png_do_read_transformations the order is: * png_do_read_transformations the order is:
* *
@ -1374,8 +1375,8 @@ png_init_read_transformations(png_structrp png_ptr)
* 23) PNG_USER_TRANSFORM [must be last] * 23) PNG_USER_TRANSFORM [must be last]
*/ */
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
!(png_ptr->transformations & PNG_COMPOSE)) (png_ptr->transformations & PNG_COMPOSE) == 0)
{ {
/* Stripping the alpha channel happens immediately after the 'expand' /* Stripping the alpha channel happens immediately after the 'expand'
* transformations, before all other transformation, so it cancels out * transformations, before all other transformation, so it cancels out
@ -1401,7 +1402,7 @@ png_init_read_transformations(png_structrp png_ptr)
/* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA
* settings will have no effect. * settings will have no effect.
*/ */
if (!png_gamma_significant(png_ptr->screen_gamma)) if (png_gamma_significant(png_ptr->screen_gamma) == 0)
{ {
png_ptr->transformations &= ~PNG_ENCODE_ALPHA; png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
@ -1412,7 +1413,7 @@ png_init_read_transformations(png_structrp png_ptr)
/* Make sure the coefficients for the rgb to gray conversion are set /* Make sure the coefficients for the rgb to gray conversion are set
* appropriately. * appropriately.
*/ */
if (png_ptr->transformations & PNG_RGB_TO_GRAY) if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
png_colorspace_set_rgb_coefficients(png_ptr); png_colorspace_set_rgb_coefficients(png_ptr);
#endif #endif
@ -1433,23 +1434,23 @@ png_init_read_transformations(png_structrp png_ptr)
* png_set_background, along with the bit depth, then the code has a record * png_set_background, along with the bit depth, then the code has a record
* of exactly what color space the background is currently in. * of exactly what color space the background is currently in.
*/ */
if (png_ptr->transformations & PNG_BACKGROUND_EXPAND) if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0)
{ {
/* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if
* the file was grayscale the background value is gray. * the file was grayscale the background value is gray.
*/ */
if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
} }
else if (png_ptr->transformations & PNG_COMPOSE) else if ((png_ptr->transformations & PNG_COMPOSE) != 0)
{ {
/* PNG_COMPOSE: png_set_background was called with need_expand false, /* 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 * 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 * was called and the color is black. Ignore RGB_TO_GRAY because that
* happens before GRAY_TO_RGB. * happens before GRAY_TO_RGB.
*/ */
if (png_ptr->transformations & PNG_GRAY_TO_RGB) if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
{ {
if (png_ptr->background.red == png_ptr->background.green && if (png_ptr->background.red == png_ptr->background.green &&
png_ptr->background.red == png_ptr->background.blue) png_ptr->background.red == png_ptr->background.blue)
@ -1459,8 +1460,8 @@ png_init_read_transformations(png_structrp png_ptr)
} }
} }
} }
#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ #endif /* READ_EXPAND && READ_BACKGROUND */
#endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED */ #endif /* READ_GRAY_TO_RGB */
/* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations /* 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 performed directly on the palette, and some (such as rgb to gray)
@ -1481,10 +1482,10 @@ png_init_read_transformations(png_structrp png_ptr)
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
defined(PNG_READ_EXPAND_16_SUPPORTED) defined(PNG_READ_EXPAND_16_SUPPORTED)
if ((png_ptr->transformations & PNG_EXPAND_16) && if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
(png_ptr->transformations & PNG_COMPOSE) && (png_ptr->transformations & PNG_COMPOSE) != 0 &&
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
png_ptr->bit_depth != 16) png_ptr->bit_depth != 16)
{ {
/* TODO: fix this. Because the expand_16 operation is after the compose /* 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 * handling the background color must be 8, not 16, bits deep, but the
@ -1503,15 +1504,15 @@ png_init_read_transformations(png_structrp png_ptr)
CHOP(png_ptr->background.gray); CHOP(png_ptr->background.gray);
# undef CHOP # undef CHOP
} }
#endif /* PNG_READ_BACKGROUND_SUPPORTED && PNG_READ_EXPAND_16_SUPPORTED */ #endif /* READ_BACKGROUND && READ_EXPAND_16 */
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
(defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \ (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \
defined(PNG_READ_STRIP_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)) && if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) != 0 &&
(png_ptr->transformations & PNG_COMPOSE) && (png_ptr->transformations & PNG_COMPOSE) != 0 &&
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
png_ptr->bit_depth == 16) png_ptr->bit_depth == 16)
{ {
/* On the other hand, if a 16-bit file is to be reduced to 8-bits per /* 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 * component this will also happen after PNG_COMPOSE and so the background
@ -1554,25 +1555,24 @@ png_init_read_transformations(png_structrp png_ptr)
* file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the
* tables. * tables.
*/ */
if ((png_ptr->transformations & PNG_GAMMA) if ((png_ptr->transformations & PNG_GAMMA) != 0 ||
|| ((png_ptr->transformations & PNG_RGB_TO_GRAY) ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0 &&
&& (png_gamma_significant(png_ptr->colorspace.gamma) || (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
png_gamma_significant(png_ptr->screen_gamma))) png_gamma_significant(png_ptr->screen_gamma) != 0)) ||
|| ((png_ptr->transformations & PNG_COMPOSE) ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
&& (png_gamma_significant(png_ptr->colorspace.gamma) (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
|| png_gamma_significant(png_ptr->screen_gamma) png_gamma_significant(png_ptr->screen_gamma) != 0
# ifdef PNG_READ_BACKGROUND_SUPPORTED # ifdef PNG_READ_BACKGROUND_SUPPORTED
|| (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE &&
&& png_gamma_significant(png_ptr->background_gamma)) png_gamma_significant(png_ptr->background_gamma) != 0)
# endif # endif
)) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
&& png_gamma_significant(png_ptr->screen_gamma)) png_gamma_significant(png_ptr->screen_gamma) != 0))
)
{ {
png_build_gamma_table(png_ptr, png_ptr->bit_depth); png_build_gamma_table(png_ptr, png_ptr->bit_depth);
#ifdef PNG_READ_BACKGROUND_SUPPORTED #ifdef PNG_READ_BACKGROUND_SUPPORTED
if (png_ptr->transformations & PNG_COMPOSE) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
{ {
/* Issue a warning about this combination: because RGB_TO_GRAY is /* Issue a warning about this combination: because RGB_TO_GRAY is
* optimized to do the gamma transform if present yet do_background has * optimized to do the gamma transform if present yet do_background has
@ -1580,11 +1580,11 @@ png_init_read_transformations(png_structrp png_ptr)
* double-gamma-correction happens. This is true in all versions of * double-gamma-correction happens. This is true in all versions of
* libpng to date. * libpng to date.
*/ */
if (png_ptr->transformations & PNG_RGB_TO_GRAY) if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
png_warning(png_ptr, png_warning(png_ptr,
"libpng does not support gamma+background+rgb_to_gray"); "libpng does not support gamma+background+rgb_to_gray");
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0)
{ {
/* We don't get to here unless there is a tRNS chunk with non-opaque /* 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. * entries - see the checking code at the start of this function.
@ -1632,7 +1632,7 @@ png_init_read_transformations(png_structrp png_ptr)
break; break;
} }
if (png_gamma_significant(gs)) if (png_gamma_significant(gs) != 0)
{ {
back.red = png_gamma_8bit_correct(png_ptr->background.red, back.red = png_gamma_8bit_correct(png_ptr->background.red,
gs); gs);
@ -1649,7 +1649,7 @@ png_init_read_transformations(png_structrp png_ptr)
back.blue = (png_byte)png_ptr->background.blue; back.blue = (png_byte)png_ptr->background.blue;
} }
if (png_gamma_significant(g)) if (png_gamma_significant(g) != 0)
{ {
back_1.red = png_gamma_8bit_correct(png_ptr->background.red, back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
g); g);
@ -1798,7 +1798,7 @@ png_init_read_transformations(png_structrp png_ptr)
else else
/* Transformation does not include PNG_BACKGROUND */ /* Transformation does not include PNG_BACKGROUND */
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ #endif /* READ_BACKGROUND */
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
/* RGB_TO_GRAY needs to have non-gamma-corrected values! */ /* RGB_TO_GRAY needs to have non-gamma-corrected values! */
@ -1828,11 +1828,11 @@ png_init_read_transformations(png_structrp png_ptr)
#ifdef PNG_READ_BACKGROUND_SUPPORTED #ifdef PNG_READ_BACKGROUND_SUPPORTED
else else
#endif #endif
#endif /* PNG_READ_GAMMA_SUPPORTED */ #endif /* READ_GAMMA */
#ifdef PNG_READ_BACKGROUND_SUPPORTED #ifdef PNG_READ_BACKGROUND_SUPPORTED
/* No GAMMA transformation (see the hanging else 4 lines above) */ /* No GAMMA transformation (see the hanging else 4 lines above) */
if ((png_ptr->transformations & PNG_COMPOSE) && if ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
{ {
int i; int i;
@ -1867,11 +1867,11 @@ png_init_read_transformations(png_structrp png_ptr)
png_ptr->transformations &= ~PNG_COMPOSE; png_ptr->transformations &= ~PNG_COMPOSE;
} }
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ #endif /* READ_BACKGROUND */
#ifdef PNG_READ_SHIFT_SUPPORTED #ifdef PNG_READ_SHIFT_SUPPORTED
if ((png_ptr->transformations & PNG_SHIFT) && if ((png_ptr->transformations & PNG_SHIFT) != 0 &&
!(png_ptr->transformations & PNG_EXPAND) && (png_ptr->transformations & PNG_EXPAND) == 0 &&
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
{ {
int i; int i;
@ -1913,7 +1913,7 @@ png_init_read_transformations(png_structrp png_ptr)
png_ptr->palette[i].blue = (png_byte)component; png_ptr->palette[i].blue = (png_byte)component;
} }
} }
#endif /* PNG_READ_SHIFT_SUPPORTED */ #endif /* READ_SHIFT */
} }
/* Modify the info structure to reflect the transformations. The /* Modify the info structure to reflect the transformations. The
@ -1926,7 +1926,7 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
png_debug(1, "in png_read_transform_info"); png_debug(1, "in png_read_transform_info");
#ifdef PNG_READ_EXPAND_SUPPORTED #ifdef PNG_READ_EXPAND_SUPPORTED
if (png_ptr->transformations & PNG_EXPAND) if ((png_ptr->transformations & PNG_EXPAND) != 0)
{ {
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
{ {
@ -1948,9 +1948,9 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
} }
else else
{ {
if (png_ptr->num_trans) if (png_ptr->num_trans != 0)
{ {
if (png_ptr->transformations & PNG_EXPAND_tRNS) if ((png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
} }
if (info_ptr->bit_depth < 8) if (info_ptr->bit_depth < 8)
@ -1966,7 +1966,7 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
/* The following is almost certainly wrong unless the background value is in /* The following is almost certainly wrong unless the background value is in
* the screen space! * the screen space!
*/ */
if (png_ptr->transformations & PNG_COMPOSE) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
info_ptr->background = png_ptr->background; info_ptr->background = png_ptr->background;
#endif #endif
@ -1987,12 +1987,12 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
{ {
# ifdef PNG_READ_16BIT_SUPPORTED # ifdef PNG_READ_16BIT_SUPPORTED
# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED # ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
if (png_ptr->transformations & PNG_SCALE_16_TO_8) if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
info_ptr->bit_depth = 8; info_ptr->bit_depth = 8;
# endif # endif
# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED # ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
if (png_ptr->transformations & PNG_16_TO_8) if ((png_ptr->transformations & PNG_16_TO_8) != 0)
info_ptr->bit_depth = 8; info_ptr->bit_depth = 8;
# endif # endif
@ -2018,27 +2018,27 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
CONFIGURATION ERROR: you must enable at least one 16 to 8 method CONFIGURATION ERROR: you must enable at least one 16 to 8 method
# endif # endif
# endif # endif
#endif /* !READ_16BIT_SUPPORTED */ #endif /* !READ_16BIT */
} }
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
if (png_ptr->transformations & PNG_GRAY_TO_RGB) if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
info_ptr->color_type = (png_byte)(info_ptr->color_type | info_ptr->color_type = (png_byte)(info_ptr->color_type |
PNG_COLOR_MASK_COLOR); PNG_COLOR_MASK_COLOR);
#endif #endif
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
if (png_ptr->transformations & PNG_RGB_TO_GRAY) if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
info_ptr->color_type = (png_byte)(info_ptr->color_type & info_ptr->color_type = (png_byte)(info_ptr->color_type &
~PNG_COLOR_MASK_COLOR); ~PNG_COLOR_MASK_COLOR);
#endif #endif
#ifdef PNG_READ_QUANTIZE_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
if (png_ptr->transformations & PNG_QUANTIZE) if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
{ {
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
(info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
png_ptr->palette_lookup && info_ptr->bit_depth == 8) png_ptr->palette_lookup != 0 && info_ptr->bit_depth == 8)
{ {
info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
} }
@ -2046,29 +2046,31 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
#endif #endif
#ifdef PNG_READ_EXPAND_16_SUPPORTED #ifdef PNG_READ_EXPAND_16_SUPPORTED
if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 && if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) info_ptr->bit_depth == 8 &&
info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
{ {
info_ptr->bit_depth = 16; info_ptr->bit_depth = 16;
} }
#endif #endif
#ifdef PNG_READ_PACK_SUPPORTED #ifdef PNG_READ_PACK_SUPPORTED
if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) if ((png_ptr->transformations & PNG_PACK) != 0 &&
(info_ptr->bit_depth < 8))
info_ptr->bit_depth = 8; info_ptr->bit_depth = 8;
#endif #endif
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
info_ptr->channels = 1; info_ptr->channels = 1;
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
info_ptr->channels = 3; info_ptr->channels = 3;
else else
info_ptr->channels = 1; info_ptr->channels = 1;
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_STRIP_ALPHA) if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
{ {
info_ptr->color_type = (png_byte)(info_ptr->color_type & info_ptr->color_type = (png_byte)(info_ptr->color_type &
~PNG_COLOR_MASK_ALPHA); ~PNG_COLOR_MASK_ALPHA);
@ -2076,25 +2078,25 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
} }
#endif #endif
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
info_ptr->channels++; info_ptr->channels++;
#ifdef PNG_READ_FILLER_SUPPORTED #ifdef PNG_READ_FILLER_SUPPORTED
/* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */
if ((png_ptr->transformations & PNG_FILLER) && if ((png_ptr->transformations & PNG_FILLER) != 0 &&
((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
(info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) info_ptr->color_type == PNG_COLOR_TYPE_GRAY))
{ {
info_ptr->channels++; info_ptr->channels++;
/* If adding a true alpha channel not just filler */ /* If adding a true alpha channel not just filler */
if (png_ptr->transformations & PNG_ADD_ALPHA) if ((png_ptr->transformations & PNG_ADD_ALPHA) != 0)
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
} }
#endif #endif
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
defined(PNG_READ_USER_TRANSFORM_SUPPORTED) defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
if (png_ptr->transformations & PNG_USER_TRANSFORM) if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
{ {
if (info_ptr->bit_depth < png_ptr->user_transform_depth) if (info_ptr->bit_depth < png_ptr->user_transform_depth)
info_ptr->bit_depth = png_ptr->user_transform_depth; info_ptr->bit_depth = png_ptr->user_transform_depth;
@ -2245,7 +2247,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row,
int channels = 0; int channels = 0;
int bit_depth = row_info->bit_depth; int bit_depth = row_info->bit_depth;
if (color_type & PNG_COLOR_MASK_COLOR) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
shift[channels++] = bit_depth - sig_bits->red; shift[channels++] = bit_depth - sig_bits->red;
shift[channels++] = bit_depth - sig_bits->green; shift[channels++] = bit_depth - sig_bits->green;
@ -2257,7 +2259,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row,
shift[channels++] = bit_depth - sig_bits->gray; shift[channels++] = bit_depth - sig_bits->gray;
} }
if (color_type & PNG_COLOR_MASK_ALPHA) if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
{ {
shift[channels++] = bit_depth - sig_bits->alpha; shift[channels++] = bit_depth - sig_bits->alpha;
} }
@ -2671,7 +2673,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
{ {
if (flags & PNG_FLAG_FILLER_AFTER) if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
{ {
/* This changes the data from G to GX */ /* This changes the data from G to GX */
png_bytep sp = row + (png_size_t)row_width; png_bytep sp = row + (png_size_t)row_width;
@ -2706,7 +2708,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
#ifdef PNG_READ_16BIT_SUPPORTED #ifdef PNG_READ_16BIT_SUPPORTED
else if (row_info->bit_depth == 16) else if (row_info->bit_depth == 16)
{ {
if (flags & PNG_FLAG_FILLER_AFTER) if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
{ {
/* This changes the data from GG to GGXX */ /* This changes the data from GG to GGXX */
png_bytep sp = row + (png_size_t)row_width * 2; png_bytep sp = row + (png_size_t)row_width * 2;
@ -2748,7 +2750,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
{ {
if (flags & PNG_FLAG_FILLER_AFTER) if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
{ {
/* This changes the data from RGB to RGBX */ /* This changes the data from RGB to RGBX */
png_bytep sp = row + (png_size_t)row_width * 3; png_bytep sp = row + (png_size_t)row_width * 3;
@ -2787,7 +2789,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
#ifdef PNG_READ_16BIT_SUPPORTED #ifdef PNG_READ_16BIT_SUPPORTED
else if (row_info->bit_depth == 16) else if (row_info->bit_depth == 16)
{ {
if (flags & PNG_FLAG_FILLER_AFTER) if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
{ {
/* This changes the data from RRGGBB to RRGGBBXX */ /* This changes the data from RRGGBB to RRGGBBXX */
png_bytep sp = row + (png_size_t)row_width * 6; png_bytep sp = row + (png_size_t)row_width * 6;
@ -2848,7 +2850,7 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
png_debug(1, "in png_do_gray_to_rgb"); png_debug(1, "in png_do_gray_to_rgb");
if (row_info->bit_depth >= 8 && if (row_info->bit_depth >= 8 &&
!(row_info->color_type & PNG_COLOR_MASK_COLOR)) (row_info->color_type & PNG_COLOR_MASK_COLOR) == 0)
{ {
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
{ {
@ -2986,8 +2988,8 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
png_debug(1, "in png_do_rgb_to_gray"); png_debug(1, "in png_do_rgb_to_gray");
if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) && if ((row_info->color_type & PNG_COLOR_MASK_PALETTE) == 0 &&
(row_info->color_type & PNG_COLOR_MASK_COLOR)) (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_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 gc = png_ptr->rgb_to_gray_green_coeff;
@ -3086,15 +3088,15 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
{ {
png_uint_16 red, green, blue, w; png_uint_16 red, green, blue, w;
red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; red = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
green = (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; blue = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
if (red == green && red == blue) if (red == green && red == blue)
{ {
if (png_ptr->gamma_16_table != NULL) if (png_ptr->gamma_16_table != NULL)
w = png_ptr->gamma_16_table[(red&0xff) w = png_ptr->gamma_16_table[(red & 0xff)
>> png_ptr->gamma_shift][red>>8]; >> png_ptr->gamma_shift][red >> 8];
else else
w = red; w = red;
@ -3137,9 +3139,9 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
{ {
png_uint_16 red, green, blue, gray16; png_uint_16 red, green, blue, gray16;
red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; red = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
green = (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; blue = (png_uint_16)(((*(sp)) << 8) | *(sp + 1)); sp += 2;
if (red != green || red != blue) if (red != green || red != blue)
rgb_error |= 1; rgb_error |= 1;
@ -3150,7 +3152,7 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
*/ */
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >> gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >>
15); 15);
*(dp++) = (png_byte)((gray16>>8) & 0xff); *(dp++) = (png_byte)((gray16 >> 8) & 0xff);
*(dp++) = (png_byte)(gray16 & 0xff); *(dp++) = (png_byte)(gray16 & 0xff);
if (have_alpha != 0) if (have_alpha != 0)
@ -3910,7 +3912,7 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
} }
} }
} }
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_READ_ALPHA_MODE_SUPPORTED */ #endif /* READ_BACKGROUND || READ_ALPHA_MODE */
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
/* Gamma correct the image, avoiding the alpha channel. Make sure /* Gamma correct the image, avoiding the alpha channel. Make sure
@ -4127,7 +4129,7 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
png_debug(1, "in png_do_encode_alpha"); png_debug(1, "in png_do_encode_alpha");
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
{ {
@ -4353,7 +4355,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
{ {
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
{ {
unsigned int gray = trans_color ? trans_color->gray : 0; unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
if (row_info->bit_depth < 8) if (row_info->bit_depth < 8)
{ {
@ -4497,7 +4499,8 @@ png_do_expand(png_row_infop row_info, png_bytep row,
row_width); row_width);
} }
} }
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_color) else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
trans_color != NULL)
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
{ {
@ -4688,7 +4691,7 @@ png_do_quantize(png_row_infop row_info, png_bytep row,
} }
} }
} }
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ #endif /* READ_QUANTIZE */
/* Transform the row. The order of transformations is significant, /* Transform the row. The order of transformations is significant,
* and is very touchy. If you add a transformation, take care to * and is very touchy. If you add a transformation, take care to
@ -4715,7 +4718,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
* demand, if necessary. * demand, if necessary.
*/ */
if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 && if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
!(png_ptr->flags & PNG_FLAG_ROW_INIT)) (png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
{ {
/* Application has failed to call either png_read_start_image() or /* Application has failed to call either png_read_start_image() or
* png_read_update_info() after setting transforms that expand pixels. * png_read_update_info() after setting transforms that expand pixels.
@ -4725,7 +4728,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
} }
#ifdef PNG_READ_EXPAND_SUPPORTED #ifdef PNG_READ_EXPAND_SUPPORTED
if (png_ptr->transformations & PNG_EXPAND) if ((png_ptr->transformations & PNG_EXPAND) != 0)
{ {
if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
{ {
@ -4735,8 +4738,8 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
else else
{ {
if (png_ptr->num_trans && if (png_ptr->num_trans != 0 &&
(png_ptr->transformations & PNG_EXPAND_tRNS)) (png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
png_do_expand(row_info, png_ptr->row_buf + 1, png_do_expand(row_info, png_ptr->row_buf + 1,
&(png_ptr->trans_color)); &(png_ptr->trans_color));
@ -4748,16 +4751,16 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#endif #endif
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
!(png_ptr->transformations & PNG_COMPOSE) && (png_ptr->transformations & PNG_COMPOSE) == 0 &&
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
png_do_strip_channel(row_info, png_ptr->row_buf + 1, png_do_strip_channel(row_info, png_ptr->row_buf + 1,
0 /* at_start == false, because SWAP_ALPHA happens later */); 0 /* at_start == false, because SWAP_ALPHA happens later */);
#endif #endif
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
if (png_ptr->transformations & PNG_RGB_TO_GRAY) if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
{ {
int rgb_error = int rgb_error =
png_do_rgb_to_gray(png_ptr, row_info, png_do_rgb_to_gray(png_ptr, row_info,
@ -4812,22 +4815,22 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
/* If gray -> RGB, do so now only if background is non-gray; else do later /* If gray -> RGB, do so now only if background is non-gray; else do later
* for performance reasons * for performance reasons
*/ */
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) == 0)
png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
#endif #endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
defined(PNG_READ_ALPHA_MODE_SUPPORTED) defined(PNG_READ_ALPHA_MODE_SUPPORTED)
if (png_ptr->transformations & PNG_COMPOSE) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr); png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr);
#endif #endif
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
if ((png_ptr->transformations & PNG_GAMMA) && if ((png_ptr->transformations & PNG_GAMMA) != 0 &&
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
/* Because RGB_TO_GRAY does the gamma transform. */ /* Because RGB_TO_GRAY does the gamma transform. */
!(png_ptr->transformations & PNG_RGB_TO_GRAY) && (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0 &&
#endif #endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
defined(PNG_READ_ALPHA_MODE_SUPPORTED) defined(PNG_READ_ALPHA_MODE_SUPPORTED)
@ -4836,7 +4839,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
*/ */
!((png_ptr->transformations & PNG_COMPOSE) && !((png_ptr->transformations & PNG_COMPOSE) &&
((png_ptr->num_trans != 0) || ((png_ptr->num_trans != 0) ||
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)) &&
#endif #endif
/* Because png_init_read_transformations transforms the palette, unless /* Because png_init_read_transformations transforms the palette, unless
* RGB_TO_GRAY will do the transform. * RGB_TO_GRAY will do the transform.
@ -4846,22 +4849,22 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#endif #endif
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
if ((png_ptr->transformations & PNG_STRIP_ALPHA) && if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
(png_ptr->transformations & PNG_COMPOSE) && (png_ptr->transformations & PNG_COMPOSE) != 0 &&
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
png_do_strip_channel(row_info, png_ptr->row_buf + 1, png_do_strip_channel(row_info, png_ptr->row_buf + 1,
0 /* at_start == false, because SWAP_ALPHA happens later */); 0 /* at_start == false, because SWAP_ALPHA happens later */);
#endif #endif
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
if ((png_ptr->transformations & PNG_ENCODE_ALPHA) && if ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
(row_info->color_type & PNG_COLOR_MASK_ALPHA)) (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr); png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr);
#endif #endif
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
if (png_ptr->transformations & PNG_SCALE_16_TO_8) if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1); png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1);
#endif #endif
@ -4870,12 +4873,12 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
* by putting the 'scale' option first if the app asks for scale (either by * 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. * calling the API or in a TRANSFORM flag) this is what happens.
*/ */
if (png_ptr->transformations & PNG_16_TO_8) if ((png_ptr->transformations & PNG_16_TO_8) != 0)
png_do_chop(row_info, png_ptr->row_buf + 1); png_do_chop(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_QUANTIZE_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
if (png_ptr->transformations & PNG_QUANTIZE) if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
{ {
png_do_quantize(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); png_ptr->palette_lookup, png_ptr->quantize_index);
@ -4883,7 +4886,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
if (row_info->rowbytes == 0) if (row_info->rowbytes == 0)
png_error(png_ptr, "png_do_quantize returned rowbytes=0"); png_error(png_ptr, "png_do_quantize returned rowbytes=0");
} }
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ #endif /* READ_QUANTIZE */
#ifdef PNG_READ_EXPAND_16_SUPPORTED #ifdef PNG_READ_EXPAND_16_SUPPORTED
/* Do the expansion now, after all the arithmetic has been done. Notice /* Do the expansion now, after all the arithmetic has been done. Notice
@ -4891,35 +4894,35 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
* is efficient (particularly true in the case of gamma correction, where * is efficient (particularly true in the case of gamma correction, where
* better accuracy results faster!) * better accuracy results faster!)
*/ */
if (png_ptr->transformations & PNG_EXPAND_16) if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
png_do_expand_16(row_info, png_ptr->row_buf + 1); png_do_expand_16(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
/* NOTE: moved here in 1.5.4 (from much later in this list.) */ /* NOTE: moved here in 1.5.4 (from much later in this list.) */
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) != 0)
png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_INVERT_SUPPORTED #ifdef PNG_READ_INVERT_SUPPORTED
if (png_ptr->transformations & PNG_INVERT_MONO) if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
png_do_invert(row_info, png_ptr->row_buf + 1); png_do_invert(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_INVERT_ALPHA) if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1); png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_SHIFT_SUPPORTED #ifdef PNG_READ_SHIFT_SUPPORTED
if (png_ptr->transformations & PNG_SHIFT) if ((png_ptr->transformations & PNG_SHIFT) != 0)
png_do_unshift(row_info, png_ptr->row_buf + 1, png_do_unshift(row_info, png_ptr->row_buf + 1,
&(png_ptr->shift)); &(png_ptr->shift));
#endif #endif
#ifdef PNG_READ_PACK_SUPPORTED #ifdef PNG_READ_PACK_SUPPORTED
if (png_ptr->transformations & PNG_PACK) if ((png_ptr->transformations & PNG_PACK) != 0)
png_do_unpack(row_info, png_ptr->row_buf + 1); png_do_unpack(row_info, png_ptr->row_buf + 1);
#endif #endif
@ -4931,36 +4934,36 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#endif #endif
#ifdef PNG_READ_BGR_SUPPORTED #ifdef PNG_READ_BGR_SUPPORTED
if (png_ptr->transformations & PNG_BGR) if ((png_ptr->transformations & PNG_BGR) != 0)
png_do_bgr(row_info, png_ptr->row_buf + 1); png_do_bgr(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_PACKSWAP_SUPPORTED #ifdef PNG_READ_PACKSWAP_SUPPORTED
if (png_ptr->transformations & PNG_PACKSWAP) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
png_do_packswap(row_info, png_ptr->row_buf + 1); png_do_packswap(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_FILLER_SUPPORTED #ifdef PNG_READ_FILLER_SUPPORTED
if (png_ptr->transformations & PNG_FILLER) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_do_read_filler(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); (png_uint_32)png_ptr->filler, png_ptr->flags);
#endif #endif
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_SWAP_ALPHA) if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1); png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_16BIT_SUPPORTED #ifdef PNG_READ_16BIT_SUPPORTED
#ifdef PNG_READ_SWAP_SUPPORTED #ifdef PNG_READ_SWAP_SUPPORTED
if (png_ptr->transformations & PNG_SWAP_BYTES) if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
png_do_swap(row_info, png_ptr->row_buf + 1); png_do_swap(row_info, png_ptr->row_buf + 1);
#endif #endif
#endif #endif
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
if (png_ptr->transformations & PNG_USER_TRANSFORM) if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
{ {
if (png_ptr->read_user_transform_fn != NULL) if (png_ptr->read_user_transform_fn != NULL)
(*(png_ptr->read_user_transform_fn)) /* User read transform function */ (*(png_ptr->read_user_transform_fn)) /* User read transform function */
(png_ptr, /* png_ptr */ (png_ptr, /* png_ptr */
@ -4973,10 +4976,10 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
/* png_byte pixel_depth; bits per pixel (depth*channels) */ /* png_byte pixel_depth; bits per pixel (depth*channels) */
png_ptr->row_buf + 1); /* start of pixel data for row */ png_ptr->row_buf + 1); /* start of pixel data for row */
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
if (png_ptr->user_transform_depth) if (png_ptr->user_transform_depth != 0)
row_info->bit_depth = png_ptr->user_transform_depth; row_info->bit_depth = png_ptr->user_transform_depth;
if (png_ptr->user_transform_channels) if (png_ptr->user_transform_channels != 0)
row_info->channels = png_ptr->user_transform_channels; row_info->channels = png_ptr->user_transform_channels;
#endif #endif
row_info->pixel_depth = (png_byte)(row_info->bit_depth * row_info->pixel_depth = (png_byte)(row_info->bit_depth *
@ -4987,5 +4990,5 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#endif #endif
} }
#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ #endif /* READ_TRANSFORMS */
#endif /* PNG_READ_SUPPORTED */ #endif /* READ */

332
src/libpng/pngrutil.c
View File

File diff suppressed because it is too large Load Diff

68
src/libpng/pngset.c
View File

@ -1,7 +1,7 @@
/* pngset.c - storage of image information into info struct /* pngset.c - storage of image information into info struct
* *
* Last changed in libpng 1.6.11 [June 5, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -59,7 +59,7 @@ png_set_cHRM_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
xy.whitey = white_y; xy.whitey = white_y;
if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy, if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy,
2/* override with app values*/)) 2/* override with app values*/) != 0)
info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
png_colorspace_sync_info(png_ptr, info_ptr); png_colorspace_sync_info(png_ptr, info_ptr);
@ -90,7 +90,8 @@ png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_inforp info_ptr,
XYZ.blue_Y = int_blue_Y; XYZ.blue_Y = int_blue_Y;
XYZ.blue_Z = int_blue_Z; XYZ.blue_Z = int_blue_Z;
if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace, &XYZ, 2)) if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace,
&XYZ, 2) != 0)
info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
png_colorspace_sync_info(png_ptr, info_ptr); png_colorspace_sync_info(png_ptr, info_ptr);
@ -129,9 +130,9 @@ png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,
png_fixed(png_ptr, blue_Y, "cHRM Red Y"), png_fixed(png_ptr, blue_Y, "cHRM Red Y"),
png_fixed(png_ptr, blue_Z, "cHRM Red Z")); png_fixed(png_ptr, blue_Z, "cHRM Red Z"));
} }
# endif /* PNG_FLOATING_POINT_SUPPORTED */ # endif /* FLOATING_POINT */
#endif /* PNG_cHRM_SUPPORTED */ #endif /* cHRM */
#ifdef PNG_gAMA_SUPPORTED #ifdef PNG_gAMA_SUPPORTED
void PNGFAPI void PNGFAPI
@ -227,13 +228,13 @@ png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr,
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
info_ptr->channels = 1; info_ptr->channels = 1;
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
info_ptr->channels = 3; info_ptr->channels = 3;
else else
info_ptr->channels = 1; info_ptr->channels = 1;
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
info_ptr->channels++; info_ptr->channels++;
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
@ -288,12 +289,14 @@ png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
/* Validate params[nparams] */ /* Validate params[nparams] */
for (i=0; i<nparams; ++i) for (i=0; i<nparams; ++i)
{
if (params[i] == NULL || if (params[i] == NULL ||
!png_check_fp_string(params[i], strlen(params[i]))) !png_check_fp_string(params[i], strlen(params[i])))
png_error(png_ptr, "Invalid format for pCAL parameter"); png_error(png_ptr, "Invalid format for pCAL parameter");
}
info_ptr->pcal_purpose = png_voidcast(png_charp, info_ptr->pcal_purpose = png_voidcast(png_charp,
png_malloc_warn(png_ptr, length)); png_malloc_warn(png_ptr, length));
if (info_ptr->pcal_purpose == NULL) if (info_ptr->pcal_purpose == NULL)
{ {
@ -594,7 +597,8 @@ png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent)) if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace,
srgb_intent) != 0)
{ {
/* This causes the gAMA and cHRM to be written too */ /* This causes the gAMA and cHRM to be written too */
info_ptr->colorspace.flags |= info_ptr->colorspace.flags |=
@ -661,6 +665,7 @@ png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
if (new_iccp_profile == NULL) if (new_iccp_profile == NULL)
{ {
png_free(png_ptr, new_iccp_name); png_free(png_ptr, new_iccp_name);
new_iccp_name = NULL;
png_benign_error(png_ptr, png_benign_error(png_ptr,
"Insufficient memory to process iCCP profile"); "Insufficient memory to process iCCP profile");
return; return;
@ -890,7 +895,7 @@ png_set_tIME(png_const_structrp png_ptr, png_inforp info_ptr,
png_debug1(1, "in %s storage function", "tIME"); png_debug1(1, "in %s storage function", "tIME");
if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL || if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL ||
(png_ptr->mode & PNG_WROTE_tIME)) (png_ptr->mode & PNG_WROTE_tIME) != 0)
return; return;
if (mod_time->month == 0 || mod_time->month > 12 || if (mod_time->month == 0 || mod_time->month > 12 ||
@ -1041,6 +1046,7 @@ png_set_sPLT(png_const_structrp png_ptr,
if (np->entries == NULL) if (np->entries == NULL)
{ {
png_free(png_ptr, np->name); png_free(png_ptr, np->name);
np->name = NULL;
break; break;
} }
@ -1063,7 +1069,7 @@ png_set_sPLT(png_const_structrp png_ptr,
if (nentries > 0) if (nentries > 0)
png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR); png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);
} }
#endif /* PNG_sPLT_SUPPORTED */ #endif /* sPLT */
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
static png_byte static png_byte
@ -1075,7 +1081,7 @@ check_location(png_const_structrp png_ptr, int location)
* change; previously the app had to use the * change; previously the app had to use the
* png_set_unknown_chunk_location API below for each chunk. * png_set_unknown_chunk_location API below for each chunk.
*/ */
if (location == 0 && !(png_ptr->mode & PNG_IS_READ_STRUCT)) if (location == 0 && (png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
{ {
/* Write struct, so unknown chunks come from the app */ /* Write struct, so unknown chunks come from the app */
png_app_warning(png_ptr, png_app_warning(png_ptr,
@ -1121,7 +1127,7 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
*/ */
# if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \ # if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
defined(PNG_READ_SUPPORTED) defined(PNG_READ_SUPPORTED)
if (png_ptr->mode & PNG_IS_READ_STRUCT) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
{ {
png_app_error(png_ptr, "no unknown chunk support on read"); png_app_error(png_ptr, "no unknown chunk support on read");
return; return;
@ -1129,7 +1135,7 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
# endif # endif
# if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \ # if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
defined(PNG_WRITE_SUPPORTED) defined(PNG_WRITE_SUPPORTED)
if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
{ {
png_app_error(png_ptr, "no unknown chunk support on write"); png_app_error(png_ptr, "no unknown chunk support on write");
return; return;
@ -1215,7 +1221,7 @@ png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr,
{ {
png_app_error(png_ptr, "invalid unknown chunk location"); png_app_error(png_ptr, "invalid unknown chunk location");
/* Fake out the pre 1.6.0 behavior: */ /* Fake out the pre 1.6.0 behavior: */
if ((location & PNG_HAVE_IDAT)) /* undocumented! */ if ((location & PNG_HAVE_IDAT) != 0) /* undocumented! */
location = PNG_AFTER_IDAT; location = PNG_AFTER_IDAT;
else else
@ -1253,10 +1259,13 @@ add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep)
/* Utility function: update the 'keep' state of a chunk if it is already in /* Utility function: update the 'keep' state of a chunk if it is already in
* the list, otherwise add it to the list. * the list, otherwise add it to the list.
*/ */
for (i=0; i<count; ++i, list += 5) if (memcmp(list, add, 4) == 0) for (i=0; i<count; ++i, list += 5)
{ {
list[4] = (png_byte)keep; if (memcmp(list, add, 4) == 0)
return count; {
list[4] = (png_byte)keep;
return count;
}
} }
if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT) if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
@ -1320,7 +1329,7 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
}; };
chunk_list = chunks_to_ignore; chunk_list = chunks_to_ignore;
num_chunks = (sizeof chunks_to_ignore)/5; num_chunks = (unsigned int)/*SAFE*/(sizeof chunks_to_ignore)/5U;
} }
else /* num_chunks_in > 0 */ else /* num_chunks_in > 0 */
@ -1380,12 +1389,15 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
unsigned int i; unsigned int i;
for (i=0; i<num_chunks; ++i) for (i=0; i<num_chunks; ++i)
{
old_num_chunks = add_one_chunk(new_list, old_num_chunks, old_num_chunks = add_one_chunk(new_list, old_num_chunks,
chunk_list+5*i, keep); chunk_list+5*i, keep);
}
/* Now remove any spurious 'default' entries. */ /* Now remove any spurious 'default' entries. */
num_chunks = 0; num_chunks = 0;
for (i=0, inlist=outlist=new_list; i<old_num_chunks; ++i, inlist += 5) for (i=0, inlist=outlist=new_list; i<old_num_chunks; ++i, inlist += 5)
{
if (inlist[4]) if (inlist[4])
{ {
if (outlist != inlist) if (outlist != inlist)
@ -1393,6 +1405,7 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
outlist += 5; outlist += 5;
++num_chunks; ++num_chunks;
} }
}
/* This means the application has removed all the specialized handling. */ /* This means the application has removed all the specialized handling. */
if (num_chunks == 0) if (num_chunks == 0)
@ -1444,7 +1457,8 @@ png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) if (info_ptr->row_pointers != NULL &&
(info_ptr->row_pointers != row_pointers))
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
info_ptr->row_pointers = row_pointers; info_ptr->row_pointers = row_pointers;
@ -1464,7 +1478,7 @@ png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
png_error(png_ptr, "invalid compression buffer size"); png_error(png_ptr, "invalid compression buffer size");
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
if (png_ptr->mode & PNG_IS_READ_STRUCT) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
{ {
png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */ png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */
return; return;
@ -1472,7 +1486,7 @@ png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
# endif # endif
# ifdef PNG_WRITE_SUPPORTED # ifdef PNG_WRITE_SUPPORTED
if (!(png_ptr->mode & PNG_IS_READ_STRUCT)) if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
{ {
if (png_ptr->zowner != 0) if (png_ptr->zowner != 0)
{ {
@ -1510,7 +1524,7 @@ png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
void PNGAPI void PNGAPI
png_set_invalid(png_const_structrp png_ptr, png_inforp info_ptr, int mask) png_set_invalid(png_const_structrp png_ptr, png_inforp info_ptr, int mask)
{ {
if (png_ptr && info_ptr) if (png_ptr != NULL && info_ptr != NULL)
info_ptr->valid &= ~mask; info_ptr->valid &= ~mask;
} }
@ -1548,7 +1562,7 @@ png_set_chunk_malloc_max (png_structrp png_ptr,
if (png_ptr != NULL) if (png_ptr != NULL)
png_ptr->user_chunk_malloc_max = user_chunk_malloc_max; png_ptr->user_chunk_malloc_max = user_chunk_malloc_max;
} }
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ #endif /* ?SET_USER_LIMITS */
#ifdef PNG_BENIGN_ERRORS_SUPPORTED #ifdef PNG_BENIGN_ERRORS_SUPPORTED
@ -1571,7 +1585,7 @@ png_set_benign_errors(png_structrp png_ptr, int 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); PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN);
} }
#endif /* PNG_BENIGN_ERRORS_SUPPORTED */ #endif /* BENIGN_ERRORS */
#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
/* Whether to report invalid palette index; added at libng-1.5.10. /* Whether to report invalid palette index; added at libng-1.5.10.
@ -1594,4 +1608,4 @@ png_set_check_for_invalid_index(png_structrp png_ptr, int allowed)
png_ptr->num_palette_max = -1; png_ptr->num_palette_max = -1;
} }
#endif #endif
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ #endif /* READ || WRITE */

4
src/libpng/pngstruct.h
View File

@ -274,7 +274,7 @@ struct png_struct_def
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
png_color_16 background_1; /* background normalized to gamma 1.0 */ png_color_16 background_1; /* background normalized to gamma 1.0 */
#endif #endif
#endif /* PNG_bKGD_SUPPORTED */ #endif /* bKGD */
#ifdef PNG_WRITE_FLUSH_SUPPORTED #ifdef PNG_WRITE_FLUSH_SUPPORTED
png_flush_ptr output_flush_fn; /* Function for flushing output */ png_flush_ptr output_flush_fn; /* Function for flushing output */
@ -331,7 +331,7 @@ struct png_struct_def
int process_mode; /* what push library is currently doing */ int process_mode; /* what push library is currently doing */
int cur_palette; /* current push library palette index */ int cur_palette; /* current push library palette index */
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PROGRESSIVE_READ */
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
/* For the Borland special 64K segment handler */ /* For the Borland special 64K segment handler */

23
src/libpng/pngtrans.c
View File

@ -1,7 +1,7 @@
/* pngtrans.c - transforms the data in a row (used by both readers and writers) /* pngtrans.c - transforms the data in a row (used by both readers and writers)
* *
* Last changed in libpng 1.6.11 [June 5, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -100,7 +100,7 @@ png_set_interlace_handling(png_structrp png_ptr)
{ {
png_debug(1, "in png_set_interlace handling"); png_debug(1, "in png_set_interlace handling");
if (png_ptr && png_ptr->interlaced) if (png_ptr != 0 && png_ptr->interlaced != 0)
{ {
png_ptr->transformations |= PNG_INTERLACE; png_ptr->transformations |= PNG_INTERLACE;
return (7); return (7);
@ -127,7 +127,7 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
/* In libpng 1.6 it is possible to determine whether this is a read or write /* 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. * operation and therefore to do more checking here for a valid call.
*/ */
if (png_ptr->mode & PNG_IS_READ_STRUCT) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
{ {
# ifdef PNG_READ_FILLER_SUPPORTED # ifdef PNG_READ_FILLER_SUPPORTED
/* On read png_set_filler is always valid, regardless of the base PNG /* On read png_set_filler is always valid, regardless of the base PNG
@ -210,7 +210,7 @@ png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
png_set_filler(png_ptr, filler, filler_loc); png_set_filler(png_ptr, filler, filler_loc);
/* The above may fail to do anything. */ /* The above may fail to do anything. */
if (png_ptr->transformations & PNG_FILLER) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_ptr->transformations |= PNG_ADD_ALPHA; png_ptr->transformations |= PNG_ADD_ALPHA;
} }
@ -478,7 +478,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
*rp = table[*rp]; *rp = table[*rp];
} }
} }
#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ #endif /* PACKSWAP || WRITE_PACKSWAP */
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
@ -605,7 +605,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
{ {
png_debug(1, "in png_do_bgr"); png_debug(1, "in png_do_bgr");
if ((row_info->color_type & PNG_COLOR_MASK_COLOR)) if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
@ -675,7 +675,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
#endif #endif
} }
} }
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ #endif /* READ_BGR || WRITE_BGR */
#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
@ -778,7 +778,7 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
} }
} }
} }
#endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */ #endif /* CHECK_FOR_INVALID_INDEX */
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
@ -844,7 +844,6 @@ png_get_current_pass_number(png_const_structrp png_ptr)
return png_ptr->pass; return png_ptr->pass;
return 8; /* invalid */ return 8; /* invalid */
} }
#endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */ #endif /* USER_TRANSFORM_INFO */
#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED || #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
PNG_WRITE_USER_TRANSFORM_SUPPORTED */ #endif /* READ || WRITE */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

6
src/libpng/pngwio.c
View File

@ -1,7 +1,7 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
* *
* Last changed in libpng 1.6.9 [February 6, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -151,7 +151,7 @@ png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr,
# endif # endif
#else #else
PNG_UNUSED(output_flush_fn) PNG_UNUSED(output_flush_fn)
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ #endif /* WRITE_FLUSH */
#ifdef PNG_READ_SUPPORTED #ifdef PNG_READ_SUPPORTED
/* It is an error to read while writing a png file */ /* It is an error to read while writing a png file */
@ -165,4 +165,4 @@ png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr,
} }
#endif #endif
} }
#endif /* PNG_WRITE_SUPPORTED */ #endif /* WRITE */

237
src/libpng/pngwrite.c
View File

@ -1,7 +1,7 @@
/* pngwrite.c - general routines to write a PNG file /* pngwrite.c - general routines to write a PNG file
* *
* Last changed in libpng 1.6.14 [October 23, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -24,7 +24,7 @@ static void
write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr, write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
unsigned int where) unsigned int where)
{ {
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num != 0)
{ {
png_const_unknown_chunkp up; png_const_unknown_chunkp up;
@ -33,7 +33,7 @@ write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
for (up = info_ptr->unknown_chunks; for (up = info_ptr->unknown_chunks;
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
++up) ++up)
if (up->location & where) if ((up->location & where) != 0)
{ {
/* If per-chunk unknown chunk handling is enabled use it, otherwise /* If per-chunk unknown chunk handling is enabled use it, otherwise
* just write the chunks the application has set. * just write the chunks the application has set.
@ -69,7 +69,7 @@ write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
} }
} }
} }
#endif /* PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED */ #endif /* WRITE_UNKNOWN_CHUNKS */
/* Writes all the PNG information. This is the suggested way to use the /* 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, * library. If you have a new chunk to add, make a function to write it,
@ -88,14 +88,14 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
{ {
/* Write PNG signature */ /* Write PNG signature */
png_write_sig(png_ptr); png_write_sig(png_ptr);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
(png_ptr->mng_features_permitted)) png_ptr->mng_features_permitted != 0)
{ {
png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
png_ptr->mng_features_permitted = 0; png_ptr->mng_features_permitted = 0;
@ -129,9 +129,9 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
*/ */
#ifdef PNG_GAMMA_SUPPORTED #ifdef PNG_GAMMA_SUPPORTED
# ifdef PNG_WRITE_gAMA_SUPPORTED # ifdef PNG_WRITE_gAMA_SUPPORTED
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) && (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&
(info_ptr->valid & PNG_INFO_gAMA)) (info_ptr->valid & PNG_INFO_gAMA) != 0)
png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma); png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
# endif # endif
#endif #endif
@ -141,11 +141,11 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
* and it matches one of the known sRGB ones issue a warning. * and it matches one of the known sRGB ones issue a warning.
*/ */
# ifdef PNG_WRITE_iCCP_SUPPORTED # ifdef PNG_WRITE_iCCP_SUPPORTED
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->valid & PNG_INFO_iCCP)) (info_ptr->valid & PNG_INFO_iCCP) != 0)
{ {
# ifdef PNG_WRITE_sRGB_SUPPORTED # ifdef PNG_WRITE_sRGB_SUPPORTED
if (info_ptr->valid & PNG_INFO_sRGB) if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
png_app_warning(png_ptr, png_app_warning(png_ptr,
"profile matches sRGB but writing iCCP instead"); "profile matches sRGB but writing iCCP instead");
# endif # endif
@ -159,22 +159,22 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
# endif # endif
# ifdef PNG_WRITE_sRGB_SUPPORTED # ifdef PNG_WRITE_sRGB_SUPPORTED
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->valid & PNG_INFO_sRGB)) (info_ptr->valid & PNG_INFO_sRGB) != 0)
png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent); png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
# endif /* WRITE_sRGB */ # endif /* WRITE_sRGB */
#endif /* COLORSPACE */ #endif /* COLORSPACE */
#ifdef PNG_WRITE_sBIT_SUPPORTED #ifdef PNG_WRITE_sBIT_SUPPORTED
if (info_ptr->valid & PNG_INFO_sBIT) if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
#endif #endif
#ifdef PNG_COLORSPACE_SUPPORTED #ifdef PNG_COLORSPACE_SUPPORTED
# ifdef PNG_WRITE_cHRM_SUPPORTED # ifdef PNG_WRITE_cHRM_SUPPORTED
if (!(info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) && (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
(info_ptr->valid & PNG_INFO_cHRM)) (info_ptr->valid & PNG_INFO_cHRM) != 0)
png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy); png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
# endif # endif
#endif #endif
@ -201,19 +201,19 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
png_write_info_before_PLTE(png_ptr, info_ptr); png_write_info_before_PLTE(png_ptr, info_ptr);
if (info_ptr->valid & PNG_INFO_PLTE) if ((info_ptr->valid & PNG_INFO_PLTE) != 0)
png_write_PLTE(png_ptr, info_ptr->palette, png_write_PLTE(png_ptr, info_ptr->palette,
(png_uint_32)info_ptr->num_palette); (png_uint_32)info_ptr->num_palette);
else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) else if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) !=0)
png_error(png_ptr, "Valid palette required for paletted images"); png_error(png_ptr, "Valid palette required for paletted images");
#ifdef PNG_WRITE_tRNS_SUPPORTED #ifdef PNG_WRITE_tRNS_SUPPORTED
if (info_ptr->valid & PNG_INFO_tRNS) if ((info_ptr->valid & PNG_INFO_tRNS) !=0)
{ {
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
/* Invert the alpha channel (in tRNS) */ /* Invert the alpha channel (in tRNS) */
if ((png_ptr->transformations & PNG_INVERT_ALPHA) && if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
{ {
int j; int j;
@ -227,42 +227,42 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
} }
#endif #endif
#ifdef PNG_WRITE_bKGD_SUPPORTED #ifdef PNG_WRITE_bKGD_SUPPORTED
if (info_ptr->valid & PNG_INFO_bKGD) if ((info_ptr->valid & PNG_INFO_bKGD) != 0)
png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
#endif #endif
#ifdef PNG_WRITE_hIST_SUPPORTED #ifdef PNG_WRITE_hIST_SUPPORTED
if (info_ptr->valid & PNG_INFO_hIST) if ((info_ptr->valid & PNG_INFO_hIST) != 0)
png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
#endif #endif
#ifdef PNG_WRITE_oFFs_SUPPORTED #ifdef PNG_WRITE_oFFs_SUPPORTED
if (info_ptr->valid & PNG_INFO_oFFs) if ((info_ptr->valid & PNG_INFO_oFFs) != 0)
png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
info_ptr->offset_unit_type); info_ptr->offset_unit_type);
#endif #endif
#ifdef PNG_WRITE_pCAL_SUPPORTED #ifdef PNG_WRITE_pCAL_SUPPORTED
if (info_ptr->valid & PNG_INFO_pCAL) if ((info_ptr->valid & PNG_INFO_pCAL) != 0)
png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
info_ptr->pcal_units, info_ptr->pcal_params); info_ptr->pcal_units, info_ptr->pcal_params);
#endif #endif
#ifdef PNG_WRITE_sCAL_SUPPORTED #ifdef PNG_WRITE_sCAL_SUPPORTED
if (info_ptr->valid & PNG_INFO_sCAL) if ((info_ptr->valid & PNG_INFO_sCAL) != 0)
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
info_ptr->scal_s_width, info_ptr->scal_s_height); info_ptr->scal_s_width, info_ptr->scal_s_height);
#endif /* sCAL */ #endif /* sCAL */
#ifdef PNG_WRITE_pHYs_SUPPORTED #ifdef PNG_WRITE_pHYs_SUPPORTED
if (info_ptr->valid & PNG_INFO_pHYs) if ((info_ptr->valid & PNG_INFO_pHYs) != 0)
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
#endif /* pHYs */ #endif /* pHYs */
#ifdef PNG_WRITE_tIME_SUPPORTED #ifdef PNG_WRITE_tIME_SUPPORTED
if (info_ptr->valid & PNG_INFO_tIME) if ((info_ptr->valid & PNG_INFO_tIME) != 0)
{ {
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr->mode |= PNG_WROTE_tIME; png_ptr->mode |= PNG_WROTE_tIME;
@ -270,7 +270,7 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
#endif /* tIME */ #endif /* tIME */
#ifdef PNG_WRITE_sPLT_SUPPORTED #ifdef PNG_WRITE_sPLT_SUPPORTED
if (info_ptr->valid & PNG_INFO_sPLT) if ((info_ptr->valid & PNG_INFO_sPLT) != 0)
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
#endif /* sPLT */ #endif /* sPLT */
@ -351,7 +351,7 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
if (!(png_ptr->mode & PNG_HAVE_IDAT)) if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
png_error(png_ptr, "No IDATs written into file"); png_error(png_ptr, "No IDATs written into file");
#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
@ -367,8 +367,8 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
#endif #endif
#ifdef PNG_WRITE_tIME_SUPPORTED #ifdef PNG_WRITE_tIME_SUPPORTED
/* Check to see if user has supplied a time chunk */ /* Check to see if user has supplied a time chunk */
if ((info_ptr->valid & PNG_INFO_tIME) && if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&
!(png_ptr->mode & PNG_WROTE_tIME)) (png_ptr->mode & PNG_WROTE_tIME) == 0)
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
#endif #endif
@ -497,7 +497,7 @@ png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
{ {
png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr, png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* USER_MEM */
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
/* Set the zlib control values to defaults; they can be overridden by the /* Set the zlib control values to defaults; they can be overridden by the
@ -521,7 +521,7 @@ png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
png_ptr->zlib_text_mem_level = 8; png_ptr->zlib_text_mem_level = 8;
png_ptr->zlib_text_window_bits = 15; png_ptr->zlib_text_window_bits = 15;
png_ptr->zlib_text_method = 8; png_ptr->zlib_text_method = 8;
#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ #endif /* WRITE_COMPRESSED_TEXT */
/* This is a highly dubious configuration option; by default it is off, /* This is a highly dubious configuration option; by default it is off,
* but it may be appropriate for private builds that are testing * but it may be appropriate for private builds that are testing
@ -618,7 +618,7 @@ png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
{ {
png_debug(1, "in png_do_write_intrapixel"); png_debug(1, "in png_do_write_intrapixel");
if ((row_info->color_type & PNG_COLOR_MASK_COLOR)) if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
int bytes_per_pixel; int bytes_per_pixel;
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
@ -671,10 +671,10 @@ png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
*(rp + 5) = (png_byte)(blue & 0xff); *(rp + 5) = (png_byte)(blue & 0xff);
} }
} }
#endif /* PNG_WRITE_16BIT_SUPPORTED */ #endif /* WRITE_16BIT */
} }
} }
#endif /* PNG_MNG_FEATURES_SUPPORTED */ #endif /* MNG_FEATURES */
/* Called by user to write a row of image data */ /* Called by user to write a row of image data */
void PNGAPI void PNGAPI
@ -693,44 +693,44 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
if (png_ptr->row_number == 0 && png_ptr->pass == 0) if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{ {
/* Make sure we wrote the header info */ /* Make sure we wrote the header info */
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
png_error(png_ptr, png_error(png_ptr,
"png_write_info was never called before png_write_row"); "png_write_info was never called before png_write_row");
/* Check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
if (png_ptr->transformations & PNG_FILLER) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
defined(PNG_READ_PACKSWAP_SUPPORTED) defined(PNG_READ_PACKSWAP_SUPPORTED)
if (png_ptr->transformations & PNG_PACKSWAP) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
png_warning(png_ptr, png_warning(png_ptr,
"PNG_WRITE_PACKSWAP_SUPPORTED is not defined"); "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
if (png_ptr->transformations & PNG_PACK) if ((png_ptr->transformations & PNG_PACK) != 0)
png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
if (png_ptr->transformations & PNG_SHIFT) if ((png_ptr->transformations & PNG_SHIFT) != 0)
png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
if (png_ptr->transformations & PNG_BGR) if ((png_ptr->transformations & PNG_BGR) != 0)
png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
#endif #endif
#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
if (png_ptr->transformations & PNG_SWAP_BYTES) if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined"); png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
#endif #endif
@ -739,12 +739,13 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* If interlaced and not interested in row, return */ /* If interlaced and not interested in row, return */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced != 0 &&
(png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
{ {
case 0: case 0:
if (png_ptr->row_number & 0x07) if ((png_ptr->row_number & 0x07) != 0)
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
return; return;
@ -752,7 +753,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
break; break;
case 1: case 1:
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
return; return;
@ -768,7 +769,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
break; break;
case 3: case 3:
if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
return; return;
@ -784,7 +785,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
break; break;
case 5: case 5:
if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
return; return;
@ -792,7 +793,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
break; break;
case 6: case 6:
if (!(png_ptr->row_number & 0x01)) if ((png_ptr->row_number & 0x01) == 0)
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
return; return;
@ -826,7 +827,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* Handle interlacing */ /* Handle interlacing */
if (png_ptr->interlaced && png_ptr->pass < 6 && if (png_ptr->interlaced && png_ptr->pass < 6 &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
png_do_write_interlace(&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 ... */ /* This should always get caught above, but still ... */
@ -840,7 +841,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
/* Handle other transformations */ /* Handle other transformations */
if (png_ptr->transformations) if (png_ptr->transformations != 0)
png_do_write_transformations(png_ptr, &row_info); png_do_write_transformations(png_ptr, &row_info);
#endif #endif
@ -861,7 +862,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
* 4. The filter_method is 64 and * 4. The filter_method is 64 and
* 5. The color_type is RGB or RGBA * 5. The color_type is RGB or RGBA
*/ */
if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
{ {
/* Intrapixel differencing */ /* Intrapixel differencing */
@ -914,7 +915,7 @@ png_write_flush(png_structrp png_ptr)
png_ptr->flush_rows = 0; png_ptr->flush_rows = 0;
png_flush(png_ptr); png_flush(png_ptr);
} }
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ #endif /* WRITE_FLUSH */
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
static void png_reset_filter_heuristics(png_structrp png_ptr);/* forward decl */ static void png_reset_filter_heuristics(png_structrp png_ptr);/* forward decl */
@ -927,18 +928,24 @@ png_write_destroy(png_structrp png_ptr)
png_debug(1, "in png_write_destroy"); png_debug(1, "in png_write_destroy");
/* Free any memory zlib uses */ /* Free any memory zlib uses */
if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
deflateEnd(&png_ptr->zstream); deflateEnd(&png_ptr->zstream);
/* Free our memory. png_free checks NULL for us. */ /* Free our memory. png_free checks NULL for us. */
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list); png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_free(png_ptr, png_ptr->row_buf); png_free(png_ptr, png_ptr->row_buf);
png_ptr->row_buf = NULL;
#ifdef PNG_WRITE_FILTER_SUPPORTED #ifdef PNG_WRITE_FILTER_SUPPORTED
png_free(png_ptr, png_ptr->prev_row); png_free(png_ptr, png_ptr->prev_row);
png_free(png_ptr, png_ptr->sub_row); png_free(png_ptr, png_ptr->sub_row);
png_free(png_ptr, png_ptr->up_row); png_free(png_ptr, png_ptr->up_row);
png_free(png_ptr, png_ptr->avg_row); png_free(png_ptr, png_ptr->avg_row);
png_free(png_ptr, png_ptr->paeth_row); png_free(png_ptr, png_ptr->paeth_row);
png_ptr->prev_row = NULL;
png_ptr->sub_row = NULL;
png_ptr->up_row = NULL;
png_ptr->avg_row = NULL;
png_ptr->paeth_row = NULL;
#endif #endif
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
@ -946,10 +953,13 @@ png_write_destroy(png_structrp png_ptr)
png_reset_filter_heuristics(png_ptr); png_reset_filter_heuristics(png_ptr);
png_free(png_ptr, png_ptr->filter_costs); png_free(png_ptr, png_ptr->filter_costs);
png_free(png_ptr, png_ptr->inv_filter_costs); png_free(png_ptr, png_ptr->inv_filter_costs);
png_ptr->filter_costs = NULL;
png_ptr->inv_filter_costs = NULL;
#endif #endif
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
png_free(png_ptr, png_ptr->chunk_list); png_free(png_ptr, png_ptr->chunk_list);
png_ptr->chunk_list = NULL;
#endif #endif
/* The error handling and memory handling information is left intact at this /* The error handling and memory handling information is left intact at this
@ -995,7 +1005,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
return; return;
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
(method == PNG_INTRAPIXEL_DIFFERENCING)) (method == PNG_INTRAPIXEL_DIFFERENCING))
method = PNG_FILTER_TYPE_BASE; method = PNG_FILTER_TYPE_BASE;
@ -1009,7 +1019,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
case 6: case 6:
case 7: png_app_error(png_ptr, "Unknown row filter for method 0"); case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
/* FALL THROUGH */ /* FALL THROUGH */
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
case PNG_FILTER_VALUE_NONE: case PNG_FILTER_VALUE_NONE:
png_ptr->do_filter = PNG_FILTER_NONE; break; png_ptr->do_filter = PNG_FILTER_NONE; break;
@ -1031,7 +1041,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
#else #else
default: default:
png_app_error(png_ptr, "Unknown row filter for method 0"); png_app_error(png_ptr, "Unknown row filter for method 0");
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
} }
/* If we have allocated the row_buf, this means we have already started /* If we have allocated the row_buf, this means we have already started
@ -1046,14 +1056,16 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->row_buf != NULL) if (png_ptr->row_buf != NULL)
{ {
#ifdef PNG_WRITE_FILTER_SUPPORTED #ifdef PNG_WRITE_FILTER_SUPPORTED
if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) if ((png_ptr->do_filter & PNG_FILTER_SUB) != 0 &&
png_ptr->sub_row == NULL)
{ {
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
(png_ptr->rowbytes + 1)); (png_ptr->rowbytes + 1));
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
} }
if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) if ((png_ptr->do_filter & PNG_FILTER_UP) != 0 &&
png_ptr->up_row == NULL)
{ {
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
{ {
@ -1070,7 +1082,8 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
} }
} }
if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) if ((png_ptr->do_filter & PNG_FILTER_AVG) != 0 &&
png_ptr->avg_row == NULL)
{ {
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
{ {
@ -1087,7 +1100,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
} }
} }
if ((png_ptr->do_filter & PNG_FILTER_PAETH) && if ((png_ptr->do_filter & PNG_FILTER_PAETH) != 0 &&
png_ptr->paeth_row == NULL) png_ptr->paeth_row == NULL)
{ {
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
@ -1105,7 +1118,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
} }
if (png_ptr->do_filter == PNG_NO_FILTERS) if (png_ptr->do_filter == PNG_NO_FILTERS)
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
png_ptr->do_filter = PNG_FILTER_NONE; png_ptr->do_filter = PNG_FILTER_NONE;
} }
} }
@ -1248,7 +1261,7 @@ png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
/* The internal API allocates all the arrays and ensures that the elements of /* The internal API allocates all the arrays and ensures that the elements of
* those arrays are set to the default value. * those arrays are set to the default value.
*/ */
if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
return; return;
/* If using the weighted method copy in the weights. */ /* If using the weighted method copy in the weights. */
@ -1303,7 +1316,7 @@ png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
/* The internal API allocates all the arrays and ensures that the elements of /* The internal API allocates all the arrays and ensures that the elements of
* those arrays are set to the default value. * those arrays are set to the default value.
*/ */
if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
return; return;
/* If using the weighted method copy in the weights. */ /* If using the weighted method copy in the weights. */
@ -1357,7 +1370,7 @@ png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
} }
} }
#endif /* FIXED_POINT */ #endif /* FIXED_POINT */
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ #endif /* WRITE_WEIGHTED_FILTER */
void PNGAPI void PNGAPI
png_set_compression_level(png_structrp png_ptr, int level) png_set_compression_level(png_structrp png_ptr, int level)
@ -1514,7 +1527,7 @@ png_set_text_compression_method(png_structrp png_ptr, int method)
png_ptr->zlib_text_method = method; png_ptr->zlib_text_method = method;
} }
#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
/* end of API added to libpng-1.5.4 */ /* end of API added to libpng-1.5.4 */
void PNGAPI void PNGAPI
@ -1562,7 +1575,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
/* ------ these transformations don't touch the info structure ------- */ /* ------ these transformations don't touch the info structure ------- */
/* Invert monochrome pixels */ /* Invert monochrome pixels */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0)
#ifdef PNG_WRITE_INVERT_SUPPORTED #ifdef PNG_WRITE_INVERT_SUPPORTED
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
#else #else
@ -1572,16 +1585,16 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
/* Shift the pixels up to a legal bit depth and fill in /* Shift the pixels up to a legal bit depth and fill in
* as appropriate to correctly scale the image. * as appropriate to correctly scale the image.
*/ */
if (transforms & PNG_TRANSFORM_SHIFT) if ((transforms & PNG_TRANSFORM_SHIFT) != 0)
#ifdef PNG_WRITE_SHIFT_SUPPORTED #ifdef PNG_WRITE_SHIFT_SUPPORTED
if (info_ptr->valid & PNG_INFO_sBIT) if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
png_set_shift(png_ptr, &info_ptr->sig_bit); png_set_shift(png_ptr, &info_ptr->sig_bit);
#else #else
png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported"); png_app_error(png_ptr, "PNG_TRANSFORM_SHIFT not supported");
#endif #endif
/* Pack pixels into bytes */ /* Pack pixels into bytes */
if (transforms & PNG_TRANSFORM_PACKING) if ((transforms & PNG_TRANSFORM_PACKING) != 0)
#ifdef PNG_WRITE_PACK_SUPPORTED #ifdef PNG_WRITE_PACK_SUPPORTED
png_set_packing(png_ptr); png_set_packing(png_ptr);
#else #else
@ -1589,7 +1602,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Swap location of alpha bytes from ARGB to RGBA */ /* Swap location of alpha bytes from ARGB to RGBA */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0)
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#else #else
@ -1600,13 +1613,13 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
* RGB, note that the code expects the input color type to be G or RGB; no * RGB, note that the code expects the input color type to be G or RGB; no
* alpha channel. * alpha channel.
*/ */
if (transforms & if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
(PNG_TRANSFORM_STRIP_FILLER_AFTER|PNG_TRANSFORM_STRIP_FILLER_BEFORE)) PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
{ {
#ifdef PNG_WRITE_FILLER_SUPPORTED #ifdef PNG_WRITE_FILLER_SUPPORTED
if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
{ {
if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
png_app_error(png_ptr, png_app_error(png_ptr,
"PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported"); "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
@ -1614,7 +1627,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
} }
else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
#else #else
png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported"); png_app_error(png_ptr, "PNG_TRANSFORM_STRIP_FILLER not supported");
@ -1622,7 +1635,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
} }
/* Flip BGR pixels to RGB */ /* Flip BGR pixels to RGB */
if (transforms & PNG_TRANSFORM_BGR) if ((transforms & PNG_TRANSFORM_BGR) != 0)
#ifdef PNG_WRITE_BGR_SUPPORTED #ifdef PNG_WRITE_BGR_SUPPORTED
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#else #else
@ -1630,7 +1643,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Swap bytes of 16-bit files to most significant byte first */ /* Swap bytes of 16-bit files to most significant byte first */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if ((transforms & PNG_TRANSFORM_SWAP_ENDIAN) != 0)
#ifdef PNG_WRITE_SWAP_SUPPORTED #ifdef PNG_WRITE_SWAP_SUPPORTED
png_set_swap(png_ptr); png_set_swap(png_ptr);
#else #else
@ -1638,7 +1651,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Swap bits of 1, 2, 4 bit packed pixel formats */ /* Swap bits of 1, 2, 4 bit packed pixel formats */
if (transforms & PNG_TRANSFORM_PACKSWAP) if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0)
#ifdef PNG_WRITE_PACKSWAP_SUPPORTED #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
#else #else
@ -1646,7 +1659,7 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
#endif #endif
/* Invert the alpha channel from opacity to transparency */ /* Invert the alpha channel from opacity to transparency */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0)
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
#else #else
@ -1737,14 +1750,14 @@ png_write_image_16bit(png_voidp argument)
display->first_row); display->first_row);
png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row); png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
png_uint_16p row_end; png_uint_16p row_end;
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
int aindex = 0; int aindex = 0;
png_uint_32 y = image->height; png_uint_32 y = image->height;
if (image->format & PNG_FORMAT_FLAG_ALPHA) if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if (image->format & PNG_FORMAT_FLAG_AFIRST) if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
aindex = -1; aindex = -1;
++input_row; /* To point to the first component */ ++input_row; /* To point to the first component */
@ -1894,15 +1907,15 @@ png_write_image_8bit(png_voidp argument)
display->first_row); display->first_row);
png_bytep output_row = png_voidcast(png_bytep, display->local_row); png_bytep output_row = png_voidcast(png_bytep, display->local_row);
png_uint_32 y = image->height; png_uint_32 y = image->height;
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
if (image->format & PNG_FORMAT_FLAG_ALPHA) if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
png_bytep row_end; png_bytep row_end;
int aindex; int aindex;
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if (image->format & PNG_FORMAT_FLAG_AFIRST) if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
aindex = -1; aindex = -1;
++input_row; /* To point to the first component */ ++input_row; /* To point to the first component */
@ -1999,7 +2012,7 @@ png_image_set_PLTE(png_image_write_control *display)
# endif # endif
# ifdef PNG_FORMAT_BGR_SUPPORTED # ifdef PNG_FORMAT_BGR_SUPPORTED
const int bgr = (format & PNG_FORMAT_FLAG_BGR) ? 2 : 0; const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
# else # else
# define bgr 0 # define bgr 0
# endif # endif
@ -2016,13 +2029,13 @@ png_image_set_PLTE(png_image_write_control *display)
/* This gets automatically converted to sRGB with reversal of the /* This gets automatically converted to sRGB with reversal of the
* pre-multiplication if the color-map has an alpha channel. * pre-multiplication if the color-map has an alpha channel.
*/ */
if (format & PNG_FORMAT_FLAG_LINEAR) if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
{ {
png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap); png_const_uint_16p entry = png_voidcast(png_const_uint_16p, cmap);
entry += i * channels; entry += i * channels;
if (channels & 1) /* no alpha */ if ((channels & 1) != 0) /* no alpha */
{ {
if (channels >= 3) /* RGB */ if (channels >= 3) /* RGB */
{ {
@ -2134,10 +2147,11 @@ png_image_write_main(png_voidp argument)
png_inforp info_ptr = image->opaque->info_ptr; png_inforp info_ptr = image->opaque->info_ptr;
png_uint_32 format = image->format; png_uint_32 format = image->format;
int colormap = (format & PNG_FORMAT_FLAG_COLORMAP) != 0; /* The following four ints are actually booleans */
int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR) != 0; /* input */ int colormap = (format & PNG_FORMAT_FLAG_COLORMAP);
int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA) != 0; int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR); /* input */
int write_16bit = linear && !colormap && !display->convert_to_8bit; int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
# ifdef PNG_BENIGN_ERRORS_SUPPORTED # ifdef PNG_BENIGN_ERRORS_SUPPORTED
/* Make sure we error out on any bad situation */ /* Make sure we error out on any bad situation */
@ -2149,7 +2163,7 @@ png_image_write_main(png_voidp argument)
display->row_stride = PNG_IMAGE_ROW_STRIDE(*image); display->row_stride = PNG_IMAGE_ROW_STRIDE(*image);
/* Set the required transforms then write the rows in the correct order. */ /* Set the required transforms then write the rows in the correct order. */
if (format & PNG_FORMAT_FLAG_COLORMAP) if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
{ {
if (display->colormap != NULL && image->colormap_entries > 0) if (display->colormap != NULL && image->colormap_entries > 0)
{ {
@ -2186,7 +2200,7 @@ png_image_write_main(png_voidp argument)
/* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */ /* The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB. */
png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR); png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_LINEAR);
if (!(image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB)) if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
png_set_cHRM_fixed(png_ptr, info_ptr, png_set_cHRM_fixed(png_ptr, info_ptr,
/* color x y */ /* color x y */
/* white */ 31270, 32900, /* white */ 31270, 32900,
@ -2196,7 +2210,7 @@ png_image_write_main(png_voidp argument)
); );
} }
else if (!(image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB)) else if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL); 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 /* Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
@ -2217,23 +2231,23 @@ png_image_write_main(png_voidp argument)
{ {
PNG_CONST png_uint_16 le = 0x0001; PNG_CONST png_uint_16 le = 0x0001;
if (*(png_const_bytep)&le) if ((*(png_const_bytep) & le) != 0)
png_set_swap(png_ptr); png_set_swap(png_ptr);
} }
# ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
if (format & PNG_FORMAT_FLAG_BGR) if ((format & PNG_FORMAT_FLAG_BGR) != 0)
{ {
if (!colormap && (format & PNG_FORMAT_FLAG_COLOR) != 0) if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
format &= ~PNG_FORMAT_FLAG_BGR; format &= ~PNG_FORMAT_FLAG_BGR;
} }
# endif # endif
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if (format & PNG_FORMAT_FLAG_AFIRST) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
if (!colormap && (format & PNG_FORMAT_FLAG_ALPHA) != 0) if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
format &= ~PNG_FORMAT_FLAG_AFIRST; format &= ~PNG_FORMAT_FLAG_AFIRST;
} }
@ -2242,7 +2256,7 @@ png_image_write_main(png_voidp argument)
/* If there are 16 or fewer color-map entries we wrote a lower bit depth /* If there are 16 or fewer color-map entries we wrote a lower bit depth
* above, but the application data is still byte packed. * above, but the application data is still byte packed.
*/ */
if (colormap && image->colormap_entries <= 16) if (colormap != 0 && image->colormap_entries <= 16)
png_set_packing(png_ptr); png_set_packing(png_ptr);
/* That should have handled all (both) the transforms. */ /* That should have handled all (both) the transforms. */
@ -2280,7 +2294,8 @@ png_image_write_main(png_voidp argument)
* before it is written. This only applies when the input is 16-bit and * 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. * either there is an alpha channel or it is converted to 8-bit.
*/ */
if ((linear && alpha) || (!colormap && display->convert_to_8bit)) if ((linear != 0 && alpha != 0 ) ||
(colormap == 0 && display->convert_to_8bit != 0))
{ {
png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr, png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
png_get_rowbytes(png_ptr, info_ptr))); png_get_rowbytes(png_ptr, info_ptr)));
@ -2329,7 +2344,7 @@ png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
{ {
if (file != NULL) if (file != NULL)
{ {
if (png_image_write_init(image)) if (png_image_write_init(image) != 0)
{ {
png_image_write_control display; png_image_write_control display;
int result; int result;
@ -2384,7 +2399,7 @@ png_image_write_to_file(png_imagep image, const char *file_name,
if (fp != NULL) if (fp != NULL)
{ {
if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer, if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
row_stride, colormap)) row_stride, colormap) != 0)
{ {
int error; /* from fflush/fclose */ int error; /* from fflush/fclose */
@ -2435,6 +2450,6 @@ png_image_write_to_file(png_imagep image, const char *file_name,
else else
return 0; return 0;
} }
#endif /* PNG_STDIO_SUPPORTED */ #endif /* STDIO */
#endif /* SIMPLIFIED_WRITE */ #endif /* SIMPLIFIED_WRITE */
#endif /* PNG_WRITE_SUPPORTED */ #endif /* WRITE */

40
src/libpng/pngwtran.c
View File

@ -1,7 +1,7 @@
/* pngwtran.c - transforms the data in a row for PNG writers /* pngwtran.c - transforms the data in a row for PNG writers
* *
* Last changed in libpng 1.6.9 [February 6, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -177,7 +177,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
int shift_start[4], shift_dec[4]; int shift_start[4], shift_dec[4];
int channels = 0; int channels = 0;
if (row_info->color_type & PNG_COLOR_MASK_COLOR) if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
shift_start[channels] = row_info->bit_depth - bit_depth->red; shift_start[channels] = row_info->bit_depth - bit_depth->red;
shift_dec[channels] = bit_depth->red; shift_dec[channels] = bit_depth->red;
@ -199,7 +199,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
channels++; channels++;
} }
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
{ {
shift_start[channels] = row_info->bit_depth - bit_depth->alpha; shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
shift_dec[channels] = bit_depth->alpha; shift_dec[channels] = bit_depth->alpha;
@ -353,7 +353,7 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = save[1]; *(dp++) = save[1];
} }
} }
#endif /* PNG_WRITE_16BIT_SUPPORTED */ #endif /* WRITE_16BIT */
} }
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
@ -392,7 +392,7 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = save[1]; *(dp++) = save[1];
} }
} }
#endif /* PNG_WRITE_16BIT_SUPPORTED */ #endif /* WRITE_16BIT */
} }
} }
} }
@ -449,7 +449,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)(255 - *(sp++));
} }
} }
#endif /* PNG_WRITE_16BIT_SUPPORTED */ #endif /* WRITE_16BIT */
} }
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
@ -487,7 +487,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)(255 - *(sp++));
} }
} }
#endif /* PNG_WRITE_16BIT_SUPPORTED */ #endif /* WRITE_16BIT */
} }
} }
} }
@ -505,7 +505,7 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
return; return;
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
if (png_ptr->transformations & PNG_USER_TRANSFORM) if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
if (png_ptr->write_user_transform_fn != NULL) if (png_ptr->write_user_transform_fn != NULL)
(*(png_ptr->write_user_transform_fn)) /* User write transform (*(png_ptr->write_user_transform_fn)) /* User write transform
function */ function */
@ -521,52 +521,54 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
#endif #endif
#ifdef PNG_WRITE_FILLER_SUPPORTED #ifdef PNG_WRITE_FILLER_SUPPORTED
if (png_ptr->transformations & PNG_FILLER) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_do_strip_channel(row_info, png_ptr->row_buf + 1, png_do_strip_channel(row_info, png_ptr->row_buf + 1,
!(png_ptr->flags & PNG_FLAG_FILLER_AFTER)); !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
#endif #endif
#ifdef PNG_WRITE_PACKSWAP_SUPPORTED #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
if (png_ptr->transformations & PNG_PACKSWAP) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
png_do_packswap(row_info, png_ptr->row_buf + 1); png_do_packswap(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_WRITE_PACK_SUPPORTED #ifdef PNG_WRITE_PACK_SUPPORTED
if (png_ptr->transformations & PNG_PACK) if ((png_ptr->transformations & PNG_PACK) != 0)
png_do_pack(row_info, png_ptr->row_buf + 1, png_do_pack(row_info, png_ptr->row_buf + 1,
(png_uint_32)png_ptr->bit_depth); (png_uint_32)png_ptr->bit_depth);
#endif #endif
#ifdef PNG_WRITE_SWAP_SUPPORTED #ifdef PNG_WRITE_SWAP_SUPPORTED
if (png_ptr->transformations & PNG_SWAP_BYTES) # ifdef PNG_16BIT_SUPPORTED
if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
png_do_swap(row_info, png_ptr->row_buf + 1); png_do_swap(row_info, png_ptr->row_buf + 1);
# endif
#endif #endif
#ifdef PNG_WRITE_SHIFT_SUPPORTED #ifdef PNG_WRITE_SHIFT_SUPPORTED
if (png_ptr->transformations & PNG_SHIFT) if ((png_ptr->transformations & PNG_SHIFT) != 0)
png_do_shift(row_info, png_ptr->row_buf + 1, png_do_shift(row_info, png_ptr->row_buf + 1,
&(png_ptr->shift)); &(png_ptr->shift));
#endif #endif
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_SWAP_ALPHA) if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1); png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
if (png_ptr->transformations & PNG_INVERT_ALPHA) if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1); png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_WRITE_BGR_SUPPORTED #ifdef PNG_WRITE_BGR_SUPPORTED
if (png_ptr->transformations & PNG_BGR) if ((png_ptr->transformations & PNG_BGR) != 0)
png_do_bgr(row_info, png_ptr->row_buf + 1); png_do_bgr(row_info, png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_WRITE_INVERT_SUPPORTED #ifdef PNG_WRITE_INVERT_SUPPORTED
if (png_ptr->transformations & PNG_INVERT_MONO) if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
png_do_invert(row_info, png_ptr->row_buf + 1); png_do_invert(row_info, png_ptr->row_buf + 1);
#endif #endif
} }
#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ #endif /* WRITE_TRANSFORMS */
#endif /* PNG_WRITE_SUPPORTED */ #endif /* WRITE */

132
src/libpng/pngwutil.c
View File

@ -1,7 +1,7 @@
/* pngwutil.c - utilities to write a PNG file /* pngwutil.c - utilities to write a PNG file
* *
* Last changed in libpng 1.6.14 [October 23, 2014] * Last changed in libpng 1.6.15 [November 20, 2014]
* Copyright (c) 1998-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2014 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -211,7 +211,7 @@ png_image_size(png_structrp png_ptr)
if (png_ptr->rowbytes < 32768 && h < 32768) if (png_ptr->rowbytes < 32768 && h < 32768)
{ {
if (png_ptr->interlaced) if (png_ptr->interlaced != 0)
{ {
/* Interlacing makes the image larger because of the replication of /* Interlacing makes the image larger because of the replication of
* both the filter byte and the padding to a byte boundary. * both the filter byte and the padding to a byte boundary.
@ -286,9 +286,7 @@ optimize_cmf(png_bytep data, png_alloc_size_t data_size)
} }
} }
} }
#else #endif /* WRITE_OPTIMIZE_CMF */
# define optimize_cmf(dp,dl) ((void)0)
#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
/* Initialize the compressor for the appropriate type of compression. */ /* Initialize the compressor for the appropriate type of compression. */
static int static int
@ -297,7 +295,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
{ {
if (png_ptr->zowner != 0) if (png_ptr->zowner != 0)
{ {
# if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
char msg[64]; char msg[64];
PNG_STRING_FROM_CHUNK(msg, owner); PNG_STRING_FROM_CHUNK(msg, owner);
@ -309,8 +307,8 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
* are minimal. * are minimal.
*/ */
(void)png_safecat(msg, (sizeof msg), 10, " using zstream"); (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
# endif #endif
# if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC #if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
/* Attempt sane error recovery */ /* Attempt sane error recovery */
@ -321,9 +319,9 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
} }
png_ptr->zowner = 0; png_ptr->zowner = 0;
# else #else
png_error(png_ptr, msg); png_error(png_ptr, msg);
# endif #endif
} }
{ {
@ -336,7 +334,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
if (owner == png_IDAT) if (owner == png_IDAT)
{ {
if (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)
strategy = png_ptr->zlib_strategy; strategy = png_ptr->zlib_strategy;
else if (png_ptr->do_filter != PNG_FILTER_NONE) else if (png_ptr->do_filter != PNG_FILTER_NONE)
@ -348,20 +346,20 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
else else
{ {
# ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
level = png_ptr->zlib_text_level; level = png_ptr->zlib_text_level;
method = png_ptr->zlib_text_method; method = png_ptr->zlib_text_method;
windowBits = png_ptr->zlib_text_window_bits; windowBits = png_ptr->zlib_text_window_bits;
memLevel = png_ptr->zlib_text_mem_level; memLevel = png_ptr->zlib_text_mem_level;
strategy = png_ptr->zlib_text_strategy; strategy = png_ptr->zlib_text_strategy;
# else #else
/* If customization is not supported the values all come from the /* If customization is not supported the values all come from the
* IDAT values except for the strategy, which is fixed to 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 * default. (This is the pre-1.6.0 behavior too, although it was
* implemented in a very different way.) * implemented in a very different way.)
*/ */
strategy = Z_DEFAULT_STRATEGY; strategy = Z_DEFAULT_STRATEGY;
# endif #endif
} }
/* Adjust 'windowBits' down if larger than 'data_size'; to stop this /* Adjust 'windowBits' down if larger than 'data_size'; to stop this
@ -388,7 +386,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
} }
/* Check against the previous initialized values, if any. */ /* Check against the previous initialized values, if any. */
if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) && if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 &&
(png_ptr->zlib_set_level != level || (png_ptr->zlib_set_level != level ||
png_ptr->zlib_set_method != method || png_ptr->zlib_set_method != method ||
png_ptr->zlib_set_window_bits != windowBits || png_ptr->zlib_set_window_bits != windowBits ||
@ -412,7 +410,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
/* Now initialize if required, setting the new parameters, otherwise just /* Now initialize if required, setting the new parameters, otherwise just
* to a simple reset to the previous parameters. * to a simple reset to the previous parameters.
*/ */
if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
ret = deflateReset(&png_ptr->zstream); ret = deflateReset(&png_ptr->zstream);
else else
@ -619,9 +617,10 @@ png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
*/ */
if (ret == Z_STREAM_END && input_len == 0) if (ret == Z_STREAM_END && input_len == 0)
{ {
#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
/* Fix up the deflate header, if required */ /* Fix up the deflate header, if required */
optimize_cmf(comp->output, comp->input_len); optimize_cmf(comp->output, comp->input_len);
#endif
/* But Z_OK is returned, not Z_STREAM_END; this allows the claim /* 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 * function above to return Z_STREAM_END on an error (though it never
* does in the current versions of zlib.) * does in the current versions of zlib.)
@ -664,7 +663,7 @@ png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
if (output_len > 0) if (output_len > 0)
png_error(png_ptr, "error writing ancillary chunked compressed data"); png_error(png_ptr, "error writing ancillary chunked compressed data");
} }
#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ #endif /* WRITE_COMPRESSED_TEXT */
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
@ -717,7 +716,7 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
bad_character = ch; /* just skip it, record the first error */ bad_character = ch; /* just skip it, record the first error */
} }
if (key_len > 0 && space) /* trailing space */ if (key_len > 0 && space != 0) /* trailing space */
{ {
--key_len, --new_key; --key_len, --new_key;
if (bad_character == 0) if (bad_character == 0)
@ -732,7 +731,7 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
#ifdef PNG_WARNINGS_SUPPORTED #ifdef PNG_WARNINGS_SUPPORTED
/* Try to only output one warning per keyword: */ /* Try to only output one warning per keyword: */
if (*key) /* keyword too long */ if (*key != 0) /* keyword too long */
png_warning(png_ptr, "keyword truncated"); png_warning(png_ptr, "keyword truncated");
else if (bad_character != 0) else if (bad_character != 0)
@ -744,11 +743,11 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'"); png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
} }
#endif /* PNG_WARNINGS_SUPPORTED */ #endif /* WARNINGS */
return key_len; return key_len;
} }
#endif #endif /* WRITE_TEXT || WRITE_pCAL || WRITE_iCCP || WRITE_sPLT */
/* Write the IHDR chunk, and update the png_struct with the necessary /* Write the IHDR chunk, and update the png_struct with the necessary
* information. Note that the rest of this code depends upon this * information. Note that the rest of this code depends upon this
@ -849,8 +848,8 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
*/ */
if ( if (
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
(color_type == PNG_COLOR_TYPE_RGB || (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
(filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
@ -931,7 +930,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
if (( if ((
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&
#endif #endif
num_pal == 0) || num_pal > 256) num_pal == 0) || num_pal > 256)
{ {
@ -947,7 +946,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
} }
} }
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Ignoring request to write a PLTE chunk in grayscale PNG"); "Ignoring request to write a PLTE chunk in grayscale PNG");
@ -1074,11 +1073,11 @@ png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
/* Write an IDAT containing the data then reset the buffer. The /* Write an IDAT containing the data then reset the buffer. The
* first IDAT may need deflate header optimization. * first IDAT may need deflate header optimization.
*/ */
# ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
if (!(png_ptr->mode & PNG_HAVE_IDAT) && if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
optimize_cmf(data, png_image_size(png_ptr)); optimize_cmf(data, png_image_size(png_ptr));
# endif #endif
png_write_complete_chunk(png_ptr, png_IDAT, data, size); png_write_complete_chunk(png_ptr, png_IDAT, data, size);
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
@ -1120,11 +1119,11 @@ png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
png_bytep data = png_ptr->zbuffer_list->output; png_bytep data = png_ptr->zbuffer_list->output;
uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out; uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
# ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
if (!(png_ptr->mode & PNG_HAVE_IDAT) && if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
optimize_cmf(data, png_image_size(png_ptr)); optimize_cmf(data, png_image_size(png_ptr));
# endif #endif
png_write_complete_chunk(png_ptr, png_IDAT, data, size); png_write_complete_chunk(png_ptr, png_IDAT, data, size);
png_ptr->zstream.avail_out = 0; png_ptr->zstream.avail_out = 0;
@ -1345,7 +1344,7 @@ png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
png_debug(1, "in png_write_sBIT"); png_debug(1, "in png_write_sBIT");
/* Make sure we don't depend upon the order of PNG_COLOR_8 */ /* Make sure we don't depend upon the order of PNG_COLOR_8 */
if (color_type & PNG_COLOR_MASK_COLOR) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
png_byte maxbits; png_byte maxbits;
@ -1378,7 +1377,7 @@ png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
size = 1; size = 1;
} }
if (color_type & PNG_COLOR_MASK_ALPHA) if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
{ {
if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
{ {
@ -1465,9 +1464,9 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
png_save_uint_16(buf + 2, tran->green); png_save_uint_16(buf + 2, tran->green);
png_save_uint_16(buf + 4, tran->blue); png_save_uint_16(buf + 4, tran->blue);
#ifdef PNG_WRITE_16BIT_SUPPORTED #ifdef PNG_WRITE_16BIT_SUPPORTED
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
#else #else
if (buf[0] | buf[2] | buf[4]) if ((buf[0] | buf[2] | buf[4]) != 0)
#endif #endif
{ {
png_app_warning(png_ptr, png_app_warning(png_ptr,
@ -1498,8 +1497,8 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
{ {
if ( if (
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
(png_ptr->num_palette || (png_ptr->num_palette != 0 ||
(!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) &&
#endif #endif
back->index >= png_ptr->num_palette) back->index >= png_ptr->num_palette)
{ {
@ -1511,15 +1510,15 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
png_write_complete_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) else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
png_save_uint_16(buf, back->red); png_save_uint_16(buf, back->red);
png_save_uint_16(buf + 2, back->green); png_save_uint_16(buf + 2, back->green);
png_save_uint_16(buf + 4, back->blue); png_save_uint_16(buf + 4, back->blue);
#ifdef PNG_WRITE_16BIT_SUPPORTED #ifdef PNG_WRITE_16BIT_SUPPORTED
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
#else #else
if (buf[0] | buf[2] | buf[4]) if ((buf[0] | buf[2] | buf[4]) != 0)
#endif #endif
{ {
png_warning(png_ptr, png_warning(png_ptr,
@ -1986,12 +1985,13 @@ png_write_start_row(png_structrp png_ptr)
} }
/* We only need to keep the previous row if we are using one of these. */ /* We only need to keep the previous row if we are using one of these. */
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) if ((png_ptr->do_filter &
(PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
{ {
/* Set up previous row buffer */ /* Set up previous row buffer */
png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size); png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
if (png_ptr->do_filter & PNG_FILTER_UP) if ((png_ptr->do_filter & PNG_FILTER_UP) != 0)
{ {
png_ptr->up_row = (png_bytep)png_malloc(png_ptr, png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
png_ptr->rowbytes + 1); png_ptr->rowbytes + 1);
@ -1999,7 +1999,7 @@ png_write_start_row(png_structrp png_ptr)
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
} }
if (png_ptr->do_filter & PNG_FILTER_AVG) if ((png_ptr->do_filter & PNG_FILTER_AVG) != 0)
{ {
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
png_ptr->rowbytes + 1); png_ptr->rowbytes + 1);
@ -2007,7 +2007,7 @@ png_write_start_row(png_structrp png_ptr)
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
} }
if (png_ptr->do_filter & PNG_FILTER_PAETH) if ((png_ptr->do_filter & PNG_FILTER_PAETH) != 0)
{ {
png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
png_ptr->rowbytes + 1); png_ptr->rowbytes + 1);
@ -2015,13 +2015,13 @@ png_write_start_row(png_structrp png_ptr)
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
} }
} }
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* If interlaced, we need to set up width and height of pass */ /* If interlaced, we need to set up width and height of pass */
if (png_ptr->interlaced) if (png_ptr->interlaced != 0)
{ {
if (!(png_ptr->transformations & PNG_INTERLACE)) if ((png_ptr->transformations & PNG_INTERLACE) == 0)
{ {
png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
png_pass_ystart[0]) / png_pass_yinc[0]; png_pass_ystart[0]) / png_pass_yinc[0];
@ -2076,10 +2076,10 @@ png_write_finish_row(png_structrp png_ptr)
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
/* If interlaced, go to next pass */ /* If interlaced, go to next pass */
if (png_ptr->interlaced) if (png_ptr->interlaced != 0)
{ {
png_ptr->row_number = 0; png_ptr->row_number = 0;
if (png_ptr->transformations & PNG_INTERLACE) if ((png_ptr->transformations & PNG_INTERLACE) != 0)
{ {
png_ptr->pass++; png_ptr->pass++;
} }
@ -2104,7 +2104,7 @@ png_write_finish_row(png_structrp png_ptr)
png_pass_ystart[png_ptr->pass]) / png_pass_ystart[png_ptr->pass]) /
png_pass_yinc[png_ptr->pass]; png_pass_yinc[png_ptr->pass];
if (png_ptr->transformations & PNG_INTERLACE) if ((png_ptr->transformations & PNG_INTERLACE) != 0)
break; break;
} while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
@ -2383,7 +2383,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
/* We don't need to test the 'no filter' case if this is the only filter /* We don't need to test the 'no filter' case if this is the only filter
* that has been chosen, as it doesn't actually do anything to the data. * that has been chosen, as it doesn't actually do anything to the data.
*/ */
if ((filter_to_do & PNG_FILTER_NONE) && filter_to_do != PNG_FILTER_NONE) if ((filter_to_do & PNG_FILTER_NONE) != 0 && filter_to_do != PNG_FILTER_NONE)
{ {
png_bytep rp; png_bytep rp;
png_uint_32 sum = 0; png_uint_32 sum = 0;
@ -2459,7 +2459,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
best_row = png_ptr->sub_row; best_row = png_ptr->sub_row;
} }
else if (filter_to_do & PNG_FILTER_SUB) else if ((filter_to_do & PNG_FILTER_SUB) != 0)
{ {
png_bytep rp, dp, lp; png_bytep rp, dp, lp;
png_uint_32 sum = 0, lmins = mins; png_uint_32 sum = 0, lmins = mins;
@ -2580,7 +2580,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
best_row = png_ptr->up_row; best_row = png_ptr->up_row;
} }
else if (filter_to_do & PNG_FILTER_UP) else if ((filter_to_do & PNG_FILTER_UP) != 0)
{ {
png_bytep rp, dp, pp; png_bytep rp, dp, pp;
png_uint_32 sum = 0, lmins = mins; png_uint_32 sum = 0, lmins = mins;
@ -2694,7 +2694,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
best_row = png_ptr->avg_row; best_row = png_ptr->avg_row;
} }
else if (filter_to_do & PNG_FILTER_AVG) else if ((filter_to_do & PNG_FILTER_AVG) != 0)
{ {
png_bytep rp, dp, pp, lp; png_bytep rp, dp, pp, lp;
png_uint_32 sum = 0, lmins = mins; png_uint_32 sum = 0, lmins = mins;
@ -2796,7 +2796,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
} }
/* Paeth filter */ /* Paeth filter */
if (filter_to_do == PNG_FILTER_PAETH) if ((filter_to_do == PNG_FILTER_PAETH) != 0)
{ {
png_bytep rp, dp, pp, cp, lp; png_bytep rp, dp, pp, cp, lp;
png_size_t i; png_size_t i;
@ -2835,7 +2835,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
best_row = png_ptr->paeth_row; best_row = png_ptr->paeth_row;
} }
else if (filter_to_do & PNG_FILTER_PAETH) else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
{ {
png_bytep rp, dp, pp, cp, lp; png_bytep rp, dp, pp, cp, lp;
png_uint_32 sum = 0, lmins = mins; png_uint_32 sum = 0, lmins = mins;
@ -2905,7 +2905,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
pc = (p + pc) < 0 ? -(p + pc) : p + pc; pc = (p + pc) < 0 ? -(p + pc) : p + pc;
#endif #endif
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
#else /* PNG_SLOW_PAETH */ #else /* SLOW_PAETH */
p = a + b - c; p = a + b - c;
pa = abs(p - a); pa = abs(p - a);
pb = abs(p - b); pb = abs(p - b);
@ -2919,7 +2919,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
else else
p = c; p = c;
#endif /* PNG_SLOW_PAETH */ #endif /* SLOW_PAETH */
v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
@ -2968,7 +2968,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
best_row = png_ptr->paeth_row; best_row = png_ptr->paeth_row;
} }
} }
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
/* Do the actual writing of the filtered row data from the chosen filter. */ /* 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, row_info->rowbytes+1);
@ -2988,7 +2988,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
png_ptr->prev_filters[j] = best_row[0]; png_ptr->prev_filters[j] = best_row[0];
} }
#endif #endif
#endif /* PNG_WRITE_FILTER_SUPPORTED */ #endif /* WRITE_FILTER */
} }
@ -3024,6 +3024,6 @@ png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
{ {
png_write_flush(png_ptr); png_write_flush(png_ptr);
} }
#endif #endif /* WRITE_FLUSH */
} }
#endif /* PNG_WRITE_SUPPORTED */ #endif /* WRITE */