mewin/libpng
1
0
Fork 0
mirror of https://git.code.sf.net/p/libpng/code.git synced 2025-07-10 18:04:09 +02:00
Code Issues Projects Releases Wiki Activity

[libpng17] Ported cosmetic changes from libpng-1.6.15beta02.

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 2014-11-01 13:57:38 -05:00
parent 859254054a
commit 7a4bfbdec1
18 changed files with 778 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ANNOUNCE
View File

@ -1,5 +1,5 @@
Libpng 1.7.0beta39 - October 26, 2014 Libpng 1.7.0beta39 - November 1, 2014
This is not intended to be a public release. It will be replaced This is not intended to be a public release. It will be replaced
within a few weeks by a public version or by another test version. within a few weeks by a public version or by another test version.
@ -617,8 +617,8 @@ Version 1.7.0beta38 [October 17, 2014]
Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa
Only mark text chunks as written after successfully writing them. Only mark text chunks as written after successfully writing them.
Version 1.7.0beta39 [October 26, 2014] Version 1.7.0beta39 [November 1, 2014]
Changed "if (!x)" to "if (x == 0)" and "if (x)" to "if (x !== 0)" Ported cosmetic changes from libpng-1.6.15beta02.
Send comments/corrections/commendations to png-mng-implement at lists.sf.net Send comments/corrections/commendations to png-mng-implement at lists.sf.net
(subscription required; visit (subscription required; visit

4
CHANGES
View File

@ -4906,8 +4906,8 @@ Version 1.7.0beta38 [October 17, 2014]
Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa
Only mark text chunks as written after successfully writing them. Only mark text chunks as written after successfully writing them.
Version 1.7.0beta39 [October 26, 2014] Version 1.7.0beta39 [November 1, 2014]
Changed "if (!x)" to "if (x == 0)" and "if (x)" to "if (x !== 0)" Ported cosmetic changes from libpng-1.6.15beta02.
Send comments/corrections/commendations to png-mng-implement at lists.sf.net Send comments/corrections/commendations to png-mng-implement at lists.sf.net
(subscription required; visit (subscription required; visit

22
example.c
View File

@ -52,7 +52,7 @@ int main(int argc, const char **argv)
image.version = PNG_IMAGE_VERSION; image.version = PNG_IMAGE_VERSION;
/* The first argument is the file to read: */ /* The first argument is the file to read: */
if (png_image_begin_read_from_file(&image, argv[1])) if (png_image_begin_read_from_file(&image, argv[1]) != 0)
{ {
png_bytep buffer; png_bytep buffer;
@ -97,7 +97,7 @@ int main(int argc, const char **argv)
*/ */
if (buffer != NULL && if (buffer != NULL &&
png_image_finish_read(&image, NULL/*background*/, buffer, png_image_finish_read(&image, NULL/*background*/, buffer,
0/*row_stride*/, NULL/*colormap*/)) 0/*row_stride*/, NULL/*colormap*/) != 0)
{ {
/* Now write the image out to the second argument. In the write /* Now write the image out to the second argument. In the write
* call 'convert_to_8bit' allows 16-bit data to be squashed down to * call 'convert_to_8bit' allows 16-bit data to be squashed down to
@ -105,7 +105,7 @@ int main(int argc, const char **argv)
* to the 8-bit format. * to the 8-bit format.
*/ */
if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/, if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/,
buffer, 0/*row_stride*/, NULL/*colormap*/)) buffer, 0/*row_stride*/, NULL/*colormap*/) != 0)
{ {
/* The image has been written successfully. */ /* The image has been written successfully. */
exit(0); exit(0);
@ -405,7 +405,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
/* Expand paletted or RGB images with transparency to full alpha channels /* Expand paletted or RGB images with transparency to full alpha channels
* so the data will be available as RGBA quartets. * so the data will be available as RGBA quartets.
*/ */
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0)
png_set_tRNS_to_alpha(png_ptr); png_set_tRNS_to_alpha(png_ptr);
/* Set the background color to draw transparent and alpha images over. /* Set the background color to draw transparent and alpha images over.
@ -417,7 +417,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
png_color_16 my_background, *image_background; png_color_16 my_background, *image_background;
if (png_get_bKGD(png_ptr, info_ptr, &image_background)) if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0)
png_set_background(png_ptr, image_background, png_set_background(png_ptr, image_background,
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
else else
@ -454,12 +454,12 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
int intent; int intent;
if (png_get_sRGB(png_ptr, info_ptr, &intent)) if (png_get_sRGB(png_ptr, info_ptr, &intent) != 0)
png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB); png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB);
else else
{ {
double image_gamma; double image_gamma;
if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) if (png_get_gAMA(png_ptr, info_ptr, &image_gamma) != 0)
png_set_gamma(png_ptr, screen_gamma, image_gamma); png_set_gamma(png_ptr, screen_gamma, image_gamma);
else else
png_set_gamma(png_ptr, screen_gamma, 0.45455); png_set_gamma(png_ptr, screen_gamma, 0.45455);
@ -469,7 +469,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
/* Quantize RGB files down to 8 bit palette or reduce palettes /* Quantize RGB files down to 8 bit palette or reduce palettes
* to the number of colors available on your screen. * to the number of colors available on your screen.
*/ */
if (color_type & PNG_COLOR_MASK_COLOR) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
int num_palette; int num_palette;
png_colorp palette; png_colorp palette;
@ -484,7 +484,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
MAX_SCREEN_COLORS, NULL, 0); MAX_SCREEN_COLORS, NULL, 0);
} }
/* This reduces the image to the palette supplied in the file */ /* This reduces the image to the palette supplied in the file */
else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)) else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0)
{ {
png_uint_16p histogram = NULL; png_uint_16p histogram = NULL;
@ -503,7 +503,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
* [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 (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0)
{ {
png_color_8p sig_bit_p; png_color_8p sig_bit_p;
@ -512,7 +512,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */
} }
/* Flip the RGB pixels to BGR (or RGBA to BGRA) */ /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
if (color_type & PNG_COLOR_MASK_COLOR) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
/* 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) */

306
png.c
View File

@ -115,7 +115,7 @@ png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
{ {
int need_crc = 1; int need_crc = 1;
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)) if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
{ {
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
@ -124,7 +124,7 @@ png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
else /* critical */ else /* critical */
{ {
if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
need_crc = 0; need_crc = 0;
} }
@ -133,7 +133,7 @@ png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
* following cast is safe. 'uInt' may be no more than 16 bits, so it is * following cast is safe. 'uInt' may be no more than 16 bits, so it is
* necessary to perform a loop here. * necessary to perform a loop here.
*/ */
if (need_crc && length > 0) if (need_crc != 0 && length > 0)
{ {
uLong crc = png_ptr->crc; /* Should never issue a warning */ uLong crc = png_ptr->crc; /* Should never issue a warning */
@ -179,7 +179,7 @@ png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
else else
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
{ {
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
* we must recompile any applications that use any older library version. * we must recompile any applications that use any older library version.
@ -288,7 +288,7 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
# endif # endif
/* Call the general version checker (shared with read and write code): /* Call the general version checker (shared with read and write code):
*/ */
if (png_user_version_check(&create_struct, user_png_ver)) if (png_user_version_check(&create_struct, user_png_ver) != 0)
{ {
png_structrp png_ptr = png_voidcast(png_structrp, png_structrp png_ptr = png_voidcast(png_structrp,
png_malloc_warn(&create_struct, (sizeof *png_ptr))); png_malloc_warn(&create_struct, (sizeof *png_ptr)));
@ -396,32 +396,32 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_TEXT_SUPPORTED #ifdef PNG_TEXT_SUPPORTED
/* Free text item num or (if num == -1) all text items */ /* Free text item num or (if num == -1) all text items */
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) if (info_ptr->text != 0 &&
((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)
{ {
if (num != -1) if (num != -1)
{
if (info_ptr->text && info_ptr->text[num].key)
{ {
png_free(png_ptr, info_ptr->text[num].key); png_free(png_ptr, info_ptr->text[num].key);
info_ptr->text[num].key = NULL; info_ptr->text[num].key = NULL;
} }
}
else else
{ {
int i; int i;
for (i = 0; i < info_ptr->num_text; i++) for (i = 0; i < info_ptr->num_text; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); png_free(png_ptr, info_ptr->text[i].key);
png_free(png_ptr, info_ptr->text); png_free(png_ptr, info_ptr->text);
info_ptr->text = NULL; info_ptr->text = NULL;
info_ptr->num_text=0; info_ptr->num_text = 0;
} }
} }
#endif #endif
#ifdef PNG_tRNS_SUPPORTED #ifdef PNG_tRNS_SUPPORTED
/* Free any tRNS entry */ /* Free any tRNS entry */
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
{ {
info_ptr->valid &= ~PNG_INFO_tRNS; info_ptr->valid &= ~PNG_INFO_tRNS;
png_free(png_ptr, info_ptr->trans_alpha); png_free(png_ptr, info_ptr->trans_alpha);
@ -432,7 +432,7 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_sCAL_SUPPORTED #ifdef PNG_sCAL_SUPPORTED
/* Free any sCAL entry */ /* Free any sCAL entry */
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
{ {
png_free(png_ptr, info_ptr->scal_s_width); png_free(png_ptr, info_ptr->scal_s_width);
png_free(png_ptr, info_ptr->scal_s_height); png_free(png_ptr, info_ptr->scal_s_height);
@ -444,20 +444,20 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_pCAL_SUPPORTED #ifdef PNG_pCAL_SUPPORTED
/* Free any pCAL entry */ /* Free any pCAL entry */
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
{ {
png_free(png_ptr, info_ptr->pcal_purpose); png_free(png_ptr, info_ptr->pcal_purpose);
png_free(png_ptr, info_ptr->pcal_units); png_free(png_ptr, info_ptr->pcal_units);
info_ptr->pcal_purpose = NULL; info_ptr->pcal_purpose = NULL;
info_ptr->pcal_units = NULL; info_ptr->pcal_units = NULL;
if (info_ptr->pcal_params != NULL) if (info_ptr->pcal_params != NULL)
{ {
unsigned int i; int i;
for (i = 0; i < info_ptr->pcal_nparams; i++) for (i = 0; i < info_ptr->pcal_nparams; i++)
{
png_free(png_ptr, info_ptr->pcal_params[i]); png_free(png_ptr, info_ptr->pcal_params[i]);
info_ptr->pcal_params[i] = NULL;
}
png_free(png_ptr, info_ptr->pcal_params); png_free(png_ptr, info_ptr->pcal_params);
info_ptr->pcal_params = NULL; info_ptr->pcal_params = NULL;
} }
@ -467,7 +467,7 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_iCCP_SUPPORTED #ifdef PNG_iCCP_SUPPORTED
/* Free any profile entry */ /* Free any profile entry */
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
{ {
png_free(png_ptr, info_ptr->iccp_name); png_free(png_ptr, info_ptr->iccp_name);
png_free(png_ptr, info_ptr->iccp_profile); png_free(png_ptr, info_ptr->iccp_profile);
@ -479,26 +479,28 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_sPLT_SUPPORTED #ifdef PNG_sPLT_SUPPORTED
/* Free a given sPLT entry, or (if num == -1) all sPLT entries */ /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) if (info_ptr->splt_palettes != 0 &&
((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)
{ {
if (num != -1) if (num != -1)
{
if (info_ptr->splt_palettes)
{ {
png_free(png_ptr, info_ptr->splt_palettes[num].name); png_free(png_ptr, info_ptr->splt_palettes[num].name);
png_free(png_ptr, info_ptr->splt_palettes[num].entries); png_free(png_ptr, info_ptr->splt_palettes[num].entries);
info_ptr->splt_palettes[num].name = NULL; info_ptr->splt_palettes[num].name = NULL;
info_ptr->splt_palettes[num].entries = NULL; info_ptr->splt_palettes[num].entries = NULL;
} }
}
else else
{ {
if (info_ptr->splt_palettes_num) if (info_ptr->splt_palettes_num != 0)
{ {
int i; int i;
for (i = 0; i < info_ptr->splt_palettes_num; i++) for (i = 0; i < info_ptr->splt_palettes_num; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i); {
png_free(png_ptr, info_ptr->splt_palettes[i].name);
png_free(png_ptr, info_ptr->splt_palettes[i].entries);
}
png_free(png_ptr, info_ptr->splt_palettes); png_free(png_ptr, info_ptr->splt_palettes);
info_ptr->splt_palettes = NULL; info_ptr->splt_palettes = NULL;
@ -510,25 +512,23 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#endif #endif
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) if (info_ptr->unknown_chunks != 0 &&
((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
{ {
if (num != -1) if (num != -1)
{
if (info_ptr->unknown_chunks)
{ {
png_free(png_ptr, info_ptr->unknown_chunks[num].data); png_free(png_ptr, info_ptr->unknown_chunks[num].data);
info_ptr->unknown_chunks[num].data = NULL; info_ptr->unknown_chunks[num].data = NULL;
} }
}
else else
{ {
int i; int i;
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num != 0)
{ {
for (i = 0; i < info_ptr->unknown_chunks_num; i++) for (i = 0; i < info_ptr->unknown_chunks_num; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i); png_free(png_ptr, info_ptr->unknown_chunks[i].data);
png_free(png_ptr, info_ptr->unknown_chunks); png_free(png_ptr, info_ptr->unknown_chunks);
info_ptr->unknown_chunks = NULL; info_ptr->unknown_chunks = NULL;
@ -540,7 +540,7 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_hIST_SUPPORTED #ifdef PNG_hIST_SUPPORTED
/* Free any hIST entry */ /* Free any hIST entry */
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
{ {
png_free(png_ptr, info_ptr->hist); png_free(png_ptr, info_ptr->hist);
info_ptr->hist = NULL; info_ptr->hist = NULL;
@ -549,7 +549,7 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#endif #endif
/* Free any PLTE entry that was internally allocated */ /* Free any PLTE entry that was internally allocated */
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
{ {
png_free(png_ptr, info_ptr->palette); png_free(png_ptr, info_ptr->palette);
info_ptr->palette = NULL; info_ptr->palette = NULL;
@ -559,16 +559,14 @@ png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
#ifdef PNG_INFO_IMAGE_SUPPORTED #ifdef PNG_INFO_IMAGE_SUPPORTED
/* Free any image bits attached to the info structure */ /* Free any image bits attached to the info structure */
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)
{ {
if (info_ptr->row_pointers) if (info_ptr->row_pointers != 0)
{ {
png_uint_32 row; png_uint_32 row;
for (row = 0; row < info_ptr->height; row++) for (row = 0; row < info_ptr->height; row++)
{
png_free(png_ptr, info_ptr->row_pointers[row]); png_free(png_ptr, info_ptr->row_pointers[row]);
info_ptr->row_pointers[row] = NULL;
}
png_free(png_ptr, info_ptr->row_pointers); png_free(png_ptr, info_ptr->row_pointers);
info_ptr->row_pointers = NULL; info_ptr->row_pointers = NULL;
} }
@ -696,13 +694,13 @@ png_get_copyright(png_const_structrp png_ptr)
#else #else
# ifdef __STDC__ # ifdef __STDC__
return PNG_STRING_NEWLINE \ return PNG_STRING_NEWLINE \
"libpng version 1.7.0beta39 - October 26, 2014" PNG_STRING_NEWLINE \ "libpng version 1.7.0beta39 - November 1, 2014" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2014 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2014 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE; PNG_STRING_NEWLINE;
# else # else
return "libpng version 1.7.0beta39 - October 26, 2014\ return "libpng version 1.7.0beta39 - November 1, 2014\
Copyright (c) 1998-2014 Glenn Randers-Pehrson\ Copyright (c) 1998-2014 Glenn Randers-Pehrson\
Copyright (c) 1996-1997 Andreas Dilger\ Copyright (c) 1996-1997 Andreas Dilger\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
@ -827,7 +825,7 @@ png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
{ {
p -= 5; p -= 5;
if (!memcmp(chunk_name, p, 4)) if (memcmp(chunk_name, p, 4) == 0)
return p[4]; return p[4];
} }
while (p > p_end); while (p > p_end);
@ -954,8 +952,8 @@ png_colorspace_check_gamma(png_const_structrp png_ptr,
png_fixed_point gtest; png_fixed_point gtest;
if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
(!png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) || (png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) == 0 ||
png_gamma_significant(gtest))) png_gamma_significant(gtest) != 0))
{ {
/* Either this is an sRGB image, in which case the calculated gamma /* Either this is an sRGB image, in which case the calculated gamma
* approximation should match, or this is an image with a profile and the * approximation should match, or this is an image with a profile and the
@ -1010,12 +1008,13 @@ png_colorspace_set_gamma(png_const_structrp png_ptr,
# endif # endif
/* Do nothing if the colorspace is already invalid */ /* Do nothing if the colorspace is already invalid */
else if (colorspace->flags & PNG_COLORSPACE_INVALID) else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return; return;
else else
{ {
if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/)) if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
1/*from gAMA*/) != 0)
{ {
/* Store this gamma value. */ /* Store this gamma value. */
colorspace->gamma = gAMA; colorspace->gamma = gAMA;
@ -1039,7 +1038,7 @@ png_colorspace_set_gamma(png_const_structrp png_ptr,
void /* PRIVATE */ void /* PRIVATE */
png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr) png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
{ {
if (info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
{ {
/* Everything is invalid */ /* Everything is invalid */
info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB| info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
@ -1060,20 +1059,20 @@ png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
* it; this allows a PNG to contain a profile which matches sRGB and * it; this allows a PNG to contain a profile which matches sRGB and
* yet still have that profile retrievable by the application. * yet still have that profile retrievable by the application.
*/ */
if (info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
info_ptr->valid |= PNG_INFO_sRGB; info_ptr->valid |= PNG_INFO_sRGB;
else else
info_ptr->valid &= ~PNG_INFO_sRGB; info_ptr->valid &= ~PNG_INFO_sRGB;
if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
info_ptr->valid |= PNG_INFO_cHRM; info_ptr->valid |= PNG_INFO_cHRM;
else else
info_ptr->valid &= ~PNG_INFO_cHRM; info_ptr->valid &= ~PNG_INFO_cHRM;
# endif # endif
if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
info_ptr->valid |= PNG_INFO_gAMA; info_ptr->valid |= PNG_INFO_gAMA;
else else
@ -1106,22 +1105,28 @@ png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
png_int_32 d, dwhite, whiteX, whiteY; png_int_32 d, dwhite, whiteX, whiteY;
d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z; d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;
if (!png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d)) return 1; if (png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d) == 0)
if (!png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d)) return 1; return 1;
if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0)
return 1;
dwhite = d; dwhite = d;
whiteX = XYZ->red_X; whiteX = XYZ->red_X;
whiteY = XYZ->red_Y; whiteY = XYZ->red_Y;
d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z; d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;
if (!png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d)) return 1; if (png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d) == 0)
if (!png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d)) return 1; return 1;
if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0)
return 1;
dwhite += d; dwhite += d;
whiteX += XYZ->green_X; whiteX += XYZ->green_X;
whiteY += XYZ->green_Y; whiteY += XYZ->green_Y;
d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z; d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;
if (!png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d)) return 1; if (png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d) == 0)
if (!png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d)) return 1; return 1;
if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0)
return 1;
dwhite += d; dwhite += d;
whiteX += XYZ->blue_X; whiteX += XYZ->blue_X;
whiteY += XYZ->blue_Y; whiteY += XYZ->blue_Y;
@ -1129,8 +1134,10 @@ png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
/* The reference white is simply the sum of the end-point (X,Y,Z) vectors, /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
* thus: * thus:
*/ */
if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1; if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0)
if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1; return 1;
if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0)
return 1;
return 0; return 0;
} }
@ -1333,16 +1340,16 @@ png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
/* By the argument, above overflow should be impossible here. The return /* By the argument, above overflow should be impossible here. The return
* value of 2 indicates an internal error to the caller. * value of 2 indicates an internal error to the caller.
*/ */
if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7)) if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0)
return 2; return 2;
if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7)) if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0)
return 2; return 2;
denominator = left - right; denominator = left - right;
/* Now find the red numerator. */ /* Now find the red numerator. */
if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7)) if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
return 2; return 2;
if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7)) if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
return 2; return 2;
/* Overflow is possible here and it indicates an extreme set of PNG cHRM /* Overflow is possible here and it indicates an extreme set of PNG cHRM
@ -1350,16 +1357,16 @@ png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
* scale value because this allows us to delay the multiplication of white-y * scale value because this allows us to delay the multiplication of white-y
* into the denominator, which tends to produce a small number. * into the denominator, which tends to produce a small number.
*/ */
if (!png_muldiv(&red_inverse, xy->whitey, denominator, left-right) || if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 ||
red_inverse <= xy->whitey /* r+g+b scales = white scale */) red_inverse <= xy->whitey /* r+g+b scales = white scale */)
return 1; return 1;
/* Similarly for green_inverse: */ /* Similarly for green_inverse: */
if (!png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7)) if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
return 2; return 2;
if (!png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7)) if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
return 2; return 2;
if (!png_muldiv(&green_inverse, xy->whitey, denominator, left-right) || if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 ||
green_inverse <= xy->whitey) green_inverse <= xy->whitey)
return 1; return 1;
@ -1368,28 +1375,33 @@ png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
*/ */
blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) - blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
png_reciprocal(green_inverse); png_reciprocal(green_inverse);
if (blue_scale <= 0) return 1; if (blue_scale <= 0)
return 1;
/* And fill in the png_XYZ: */ /* And fill in the png_XYZ: */
if (!png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse)) return 1; if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0)
if (!png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse)) return 1; return 1;
if (!png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1, if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0)
red_inverse)) return 1;
if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
red_inverse) == 0)
return 1; return 1;
if (!png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse)) if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0)
return 1; return 1;
if (!png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse)) if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0)
return 1; return 1;
if (!png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1, if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
green_inverse)) green_inverse) == 0)
return 1; return 1;
if (!png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1)) return 1; if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0)
if (!png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1)) return 1; return 1;
if (!png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale, if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0)
PNG_FP_1)) return 1;
if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
PNG_FP_1) == 0)
return 1; return 1;
return 0; /*success*/ return 0; /*success*/
@ -1411,24 +1423,35 @@ png_XYZ_normalize(png_XYZ *XYZ)
* safe. * safe.
*/ */
Y = XYZ->red_Y; Y = XYZ->red_Y;
if (0x7fffffff - Y < XYZ->green_X) return 1; if (0x7fffffff - Y < XYZ->green_X)
return 1;
Y += XYZ->green_Y; Y += XYZ->green_Y;
if (0x7fffffff - Y < XYZ->blue_X) return 1; if (0x7fffffff - Y < XYZ->blue_X)
return 1;
Y += XYZ->blue_Y; Y += XYZ->blue_Y;
if (Y != PNG_FP_1) if (Y != PNG_FP_1)
{ {
if (!png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0)
if (!png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y)) return 1; return 1;
if (!png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0)
return 1;
if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0)
return 1;
if (!png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0)
if (!png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y)) return 1; return 1;
if (!png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0)
return 1;
if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0)
return 1;
if (!png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0)
if (!png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y)) return 1; return 1;
if (!png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y)) return 1; if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0)
return 1;
if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0)
return 1;
} }
return 0; return 0;
@ -1438,14 +1461,16 @@ static int
png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta) png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
{ {
/* Allow an error of +/-0.01 (absolute value) on each chromaticity */ /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
return !(PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) || if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) || PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) || PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) ||
PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) || PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) ||
PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) || PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||
PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) || PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||
PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) || PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) ||
PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta)); PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta))
return 0;
return 1;
} }
/* Added in libpng-1.6.0, a different check for the validity of a set of cHRM /* Added in libpng-1.6.0, a different check for the validity of a set of cHRM
@ -1466,13 +1491,15 @@ png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
/* As a side-effect this routine also returns the XYZ endpoints. */ /* As a side-effect this routine also returns the XYZ endpoints. */
result = png_XYZ_from_xy(XYZ, xy); result = png_XYZ_from_xy(XYZ, xy);
if (result != 0) return result; if (result != 0)
return result;
result = png_xy_from_XYZ(&xy_test, XYZ); result = png_xy_from_XYZ(&xy_test, XYZ);
if (result != 0) return result; if (result != 0)
return result;
if (png_colorspace_endpoints_match(xy, &xy_test, if (png_colorspace_endpoints_match(xy, &xy_test,
5/*actually, the math is pretty accurate*/)) 5/*actually, the math is pretty accurate*/) != 0)
return 0; return 0;
/* Too much slip */ /* Too much slip */
@ -1489,10 +1516,12 @@ png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
png_XYZ XYZtemp; png_XYZ XYZtemp;
result = png_XYZ_normalize(XYZ); result = png_XYZ_normalize(XYZ);
if (result != 0) return result; if (result != 0)
return result;
result = png_xy_from_XYZ(xy, XYZ); result = png_xy_from_XYZ(xy, XYZ);
if (result != 0) return result; if (result != 0)
return result;
XYZtemp = *XYZ; XYZtemp = *XYZ;
return png_colorspace_check_xy(&XYZtemp, xy); return png_colorspace_check_xy(&XYZtemp, xy);
@ -1513,19 +1542,21 @@ png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ, png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
int preferred) int preferred)
{ {
if (colorspace->flags & PNG_COLORSPACE_INVALID) if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return 0; return 0;
/* The consistency check is performed on the chromaticities; this factors out /* The consistency check is performed on the chromaticities; this factors out
* variations because of the normalization (or not) of the end point Y * variations because of the normalization (or not) of the end point Y
* values. * values.
*/ */
if (preferred < 2 && (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS)) if (preferred < 2 &&
(colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
/* The end points must be reasonably close to any we already have. The /* The end points must be reasonably close to any we already have. The
* following allows an error of up to +/-.001 * following allows an error of up to +/-.001
*/ */
if (!png_colorspace_endpoints_match(xy, &colorspace->end_points_xy, 100)) if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
100) == 0)
{ {
colorspace->flags |= PNG_COLORSPACE_INVALID; colorspace->flags |= PNG_COLORSPACE_INVALID;
png_benign_error(png_ptr, "inconsistent chromaticities"); png_benign_error(png_ptr, "inconsistent chromaticities");
@ -1544,7 +1575,7 @@ png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
/* The end points are normally quoted to two decimal digits, so allow +/-0.01 /* The end points are normally quoted to two decimal digits, so allow +/-0.01
* on this test. * on this test.
*/ */
if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000)) if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB; colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
else else
@ -1671,7 +1702,7 @@ png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */ pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */
pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */ pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */
pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */ pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */
if (is_ICC_signature(value)) if (is_ICC_signature(value) != 0)
{ {
/* So 'value' is at most 4 bytes and the following cast is safe */ /* So 'value' is at most 4 bytes and the following cast is safe */
png_icc_tag_name(message+pos, (png_uint_32)value); png_icc_tag_name(message+pos, (png_uint_32)value);
@ -1732,7 +1763,7 @@ png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
}; };
/* Do nothing if the colorspace is already invalidated. */ /* Do nothing if the colorspace is already invalidated. */
if (colorspace->flags & PNG_COLORSPACE_INVALID) if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return 0; return 0;
/* Check the intent, then check for existing settings. It is valid for the /* Check the intent, then check for existing settings. It is valid for the
@ -1910,13 +1941,13 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
switch (temp) switch (temp)
{ {
case 0x52474220: /* 'RGB ' */ case 0x52474220: /* 'RGB ' */
if (!(color_type & PNG_COLOR_MASK_COLOR)) if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"RGB color space not permitted on grayscale PNG"); "RGB color space not permitted on grayscale PNG");
break; break;
case 0x47524159: /* 'GRAY' */ case 0x47524159: /* 'GRAY' */
if (color_type & PNG_COLOR_MASK_COLOR) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"Gray color space not permitted on RGB PNG"); "Gray color space not permitted on RGB PNG");
break; break;
@ -2136,7 +2167,7 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
* are not used by default if there is an MD5!) * are not used by default if there is an MD5!)
*/ */
# if PNG_sRGB_PROFILE_CHECKS == 0 # if PNG_sRGB_PROFILE_CHECKS == 0
if (png_sRGB_checks[i].have_md5) if (png_sRGB_checks[i].have_md5 != 0)
return 1+png_sRGB_checks[i].is_broken; return 1+png_sRGB_checks[i].is_broken;
# endif # endif
@ -2176,7 +2207,7 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
if (crc == png_sRGB_checks[i].crc) if (crc == png_sRGB_checks[i].crc)
# endif # endif
{ {
if (png_sRGB_checks[i].is_broken) if (png_sRGB_checks[i].is_broken != 0)
{ {
/* These profiles are known to have bad data that may cause /* These profiles are known to have bad data that may cause
* problems if they are used, therefore attempt to * problems if they are used, therefore attempt to
@ -2191,7 +2222,7 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
* the profile is perfectly valid, but it would be nice if * the profile is perfectly valid, but it would be nice if
* people used the up-to-date ones. * people used the up-to-date ones.
*/ */
else if (!png_sRGB_checks[i].have_md5) else if (png_sRGB_checks[i].have_md5 == 0)
{ {
png_chunk_report(png_ptr, png_chunk_report(png_ptr,
"out-of-date sRGB profile with no signature", "out-of-date sRGB profile with no signature",
@ -2227,7 +2258,9 @@ png_icc_set_sRGB(png_const_structrp png_ptr,
/* Is this profile one of the known ICC sRGB profiles? If it is, just set /* Is this profile one of the known ICC sRGB profiles? If it is, just set
* the sRGB information. * the sRGB information.
*/ */
if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler)) #if PNG_sRGB_PROFILE_CHECKS >= 0
if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
#endif
(void)png_colorspace_set_sRGB(png_ptr, colorspace, (void)png_colorspace_set_sRGB(png_ptr, colorspace,
(int)/*already checked*/png_get_uint_32(profile+64)); (int)/*already checked*/png_get_uint_32(profile+64));
} }
@ -2238,14 +2271,14 @@ png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
int color_type) int color_type)
{ {
if (colorspace->flags & PNG_COLORSPACE_INVALID) if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return 0; return 0;
if (png_icc_check_length(png_ptr, colorspace, name, profile_length) && if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
png_icc_check_header(png_ptr, colorspace, name, profile_length, profile, png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
color_type) && color_type) != 0 &&
png_icc_check_tag_table(png_ptr, colorspace, name, profile_length, png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
profile)) profile) != 0)
{ {
# ifdef PNG_sRGB_SUPPORTED # ifdef PNG_sRGB_SUPPORTED
/* If no sRGB support, don't try storing sRGB information */ /* If no sRGB support, don't try storing sRGB information */
@ -2428,13 +2461,13 @@ png_check_IHDR(png_const_structrp png_ptr,
* 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->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");
if (filter_type != PNG_FILTER_TYPE_BASE) if (filter_type != PNG_FILTER_TYPE_BASE)
{ {
if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
(filter_type == PNG_INTRAPIXEL_DIFFERENCING) && (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
((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 ||
@ -2444,7 +2477,7 @@ png_check_IHDR(png_const_structrp png_ptr,
error = 1; error = 1;
} }
if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
{ {
png_warning(png_ptr, "Invalid filter method in IHDR"); png_warning(png_ptr, "Invalid filter method in IHDR");
error = 1; error = 1;
@ -2504,7 +2537,7 @@ png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY)) switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
{ {
case PNG_FP_INTEGER + PNG_FP_SAW_SIGN: case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
if (state & PNG_FP_SAW_ANY) if ((state & PNG_FP_SAW_ANY) != 0)
goto PNG_FP_End; /* not a part of the number */ goto PNG_FP_End; /* not a part of the number */
png_fp_add(state, type); png_fp_add(state, type);
@ -2512,10 +2545,10 @@ png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
case PNG_FP_INTEGER + PNG_FP_SAW_DOT: case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
/* Ok as trailer, ok as lead of fraction. */ /* Ok as trailer, ok as lead of fraction. */
if (state & PNG_FP_SAW_DOT) /* two dots */ if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
goto PNG_FP_End; goto PNG_FP_End;
else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */ else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
png_fp_add(state, type); png_fp_add(state, type);
else else
@ -2524,7 +2557,7 @@ png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
break; break;
case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT: case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
if (state & PNG_FP_SAW_DOT) /* delayed fraction */ if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
png_fp_add(state, type | PNG_FP_WAS_VALID); png_fp_add(state, type | PNG_FP_WAS_VALID);
@ -2562,7 +2595,7 @@ png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
break; break;
case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN: case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
if (state & PNG_FP_SAW_ANY) if ((state & PNG_FP_SAW_ANY) != 0)
goto PNG_FP_End; /* not a part of the number */ goto PNG_FP_End; /* not a part of the number */
png_fp_add(state, PNG_FP_SAW_SIGN); png_fp_add(state, PNG_FP_SAW_SIGN);
@ -2605,7 +2638,7 @@ png_check_fp_string(png_const_charp string, png_size_t size)
int state=0; int state=0;
png_size_t char_index=0; png_size_t char_index=0;
if (png_check_fp_number(string, size, &state, &char_index) && if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
(char_index == size || string[char_index] == 0)) (char_index == size || string[char_index] == 0))
return state /* must be non-zero - see above */; return state /* must be non-zero - see above */;
@ -2859,8 +2892,9 @@ png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
if (exp_b10 != (-1)) if (exp_b10 != (-1))
{ {
if (exp_b10 == 0) *ascii++ = 46, --size; /* counted if (exp_b10 == 0)
above */ *ascii++ = 46, --size; /* counted above */
--exp_b10; --exp_b10;
} }
*ascii++ = (char)(48 + (int)d), ++cdigits; *ascii++ = (char)(48 + (int)d), ++cdigits;
@ -3205,7 +3239,7 @@ png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
{ {
png_fixed_point result; png_fixed_point result;
if (png_muldiv(&result, a, times, divisor)) if (png_muldiv(&result, a, times, divisor) != 0)
return result; return result;
png_warning(png_ptr, "fixed point overflow ignored"); png_warning(png_ptr, "fixed point overflow ignored");
@ -3226,7 +3260,7 @@ png_reciprocal(png_fixed_point a)
#else #else
png_fixed_point res; png_fixed_point res;
if (png_muldiv(&res, 100000, 100000, a)) if (png_muldiv(&res, 100000, 100000, a) != 0)
return res; return res;
#endif #endif
@ -3261,7 +3295,7 @@ png_product2(png_fixed_point a, png_fixed_point b)
#else #else
png_fixed_point res; png_fixed_point res;
if (png_muldiv(&res, a, b, 100000)) if (png_muldiv(&res, a, b, 100000) != 0)
return res; return res;
#endif #endif
@ -3596,7 +3630,7 @@ png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
png_int_32 lg2 = png_log8bit(value); png_int_32 lg2 = png_log8bit(value);
png_fixed_point res; png_fixed_point res;
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
return png_exp8bit(res); return png_exp8bit(res);
/* Overflow. */ /* Overflow. */
@ -3619,7 +3653,7 @@ png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
png_int_32 lg2 = png_log16bit(value); png_int_32 lg2 = png_log16bit(value);
png_fixed_point res; png_fixed_point res;
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
return png_exp16bit(res); return png_exp16bit(res);
/* Overflow. */ /* Overflow. */
@ -3934,7 +3968,7 @@ png_build_gamma_table(png_structrp png_ptr, png_fixed_point gamma_val,
hival = ((png_uint_16p)data.table)[size-1] = 65535; hival = ((png_uint_16p)data.table)[size-1] = 65535;
} }
if (png_gamma_significant(gamma_val)) if (png_gamma_significant(gamma_val) != 0)
write_gamma_table(&data, 0, 0, size-1, hival); write_gamma_table(&data, 0, 0, size-1, hival);
else /* gamma_val not significant */ else /* gamma_val not significant */
@ -4033,7 +4067,7 @@ png_build_gamma_tables(png_structrp png_ptr, int bit_depth)
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
{ {
/* This sets the accuracy of 8-bit composition and the 8-bit RGB to gray /* This sets the accuracy of 8-bit composition and the 8-bit RGB to gray
* conversion - PNG_MAX_GAMMA_8 (the number of bits in the sixteen bit * conversion - PNG_MAX_GAMMA_8 (the number of bits in the sixteen bit
@ -4064,7 +4098,7 @@ png_build_gamma_tables(png_structrp png_ptr, int bit_depth)
table_type = PNG_GAMMA_TABLE_8_IN_16; table_type = PNG_GAMMA_TABLE_8_IN_16;
# endif # endif
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
sig_bit = png_ptr->sig_bit.red; sig_bit = png_ptr->sig_bit.red;
@ -4083,7 +4117,7 @@ png_build_gamma_tables(png_structrp png_ptr, int bit_depth)
else else
shift = 0; /* keep all 16 bits */ shift = 0; /* keep all 16 bits */
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_MAX_GAMMA_8 is the number of bits to keep - effectively /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
* the significant bits in the *input* when the output will * the significant bits in the *input* when the output will
@ -4105,7 +4139,7 @@ png_build_gamma_tables(png_structrp png_ptr, int bit_depth)
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
{ {
png_ptr->gamma_16_to_1 = png_voidcast(png_uint_16p, png_ptr->gamma_16_to_1 = png_voidcast(png_uint_16p,
png_build_gamma_table(png_ptr, png_build_gamma_table(png_ptr,
@ -4335,7 +4369,7 @@ png_image_free_function(png_voidp argument)
/* First free any data held in the control structure. */ /* First free any data held in the control structure. */
# ifdef PNG_STDIO_SUPPORTED # ifdef PNG_STDIO_SUPPORTED
if (cp->owned_file) if (cp->owned_file != 0)
{ {
FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr); FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
cp->owned_file = 0; cp->owned_file = 0;
@ -4359,7 +4393,7 @@ png_image_free_function(png_voidp argument)
png_free(c.png_ptr, cp); png_free(c.png_ptr, cp);
/* Then the structures, calling the correct API. */ /* Then the structures, calling the correct API. */
if (c.for_write) if (c.for_write != 0)
{ {
# ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
png_destroy_write_struct(&c.png_ptr, &c.info_ptr); png_destroy_write_struct(&c.png_ptr, &c.info_ptr);

10
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.7.0beta39 - October 17, 2014 * libpng version 1.7.0beta39 - November 1, 2014
* Copyright (c) 1998-2013 Glenn Randers-Pehrson * Copyright (c) 1998-2013 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.7.0beta39 - October 17, 2014: Glenn * libpng versions 0.97, January 1998, through 1.7.0beta39 - November 1, 2014: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@ -200,7 +200,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.7.0beta39, October 17, 2014, are * libpng versions 1.2.6, August 15, 2004, through 1.7.0beta39, November 1, 2014, are
* Copyright (c) 2004, 2006-2013 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2013 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:
@ -312,7 +312,7 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* October 17, 2014 * November 1, 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.
@ -382,7 +382,7 @@
/* 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.7.0beta39" #define PNG_LIBPNG_VER_STRING "1.7.0beta39"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.7.0beta39 - October 17, 2014\n" " libpng version 1.7.0beta39 - November 1, 2014\n"
#define PNG_LIBPNG_VER_SONUM 17 #define PNG_LIBPNG_VER_SONUM 17
#define PNG_LIBPNG_VER_DLLNUM 17 #define PNG_LIBPNG_VER_DLLNUM 17

2
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.7.0beta39 - October 17, 2014 * libpng version 1.7.0beta39 - November 1, 2014
* *
* Copyright (c) 1998-2013 Glenn Randers-Pehrson * Copyright (c) 1998-2013 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

36
pngerror.c
View File

@ -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';
@ -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)
@ -361,7 +361,7 @@ png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
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];
@ -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
@ -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
@ -583,7 +583,8 @@ 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]; msg[fixed_message_ln + iin] = name[iin];
++iin; ++iin;
@ -763,7 +764,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)

105
pngget.c
View File

@ -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");
@ -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,8 +739,9 @@ 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 &&
name != NULL && compression_type != NULL && profile != NULL &&
proflen != NULL) proflen != NULL)
{ {
*name = info_ptr->iccp_name; *name = info_ptr->iccp_name;
@ -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;
@ -871,7 +885,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
@ -894,7 +908,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);
@ -912,7 +926,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;
@ -934,7 +948,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)
{ {
@ -965,8 +979,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;
@ -984,8 +998,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);
@ -1028,8 +1042,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);
@ -1045,7 +1059,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");
@ -1122,7 +1137,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

47
pngpread.c
View File

@ -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[p]"); png_benign_error(png_ptr, "Too many IDATs found[p]");
} }
@ -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);
@ -724,7 +726,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
* or the stream marked as finished. * or the stream marked as finished.
*/ */
while (png_ptr->zstream.avail_in > 0 && while (png_ptr->zstream.avail_in > 0 &&
!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) (png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
{ {
int ret; int ret;
@ -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,
@ -1069,7 +1072,7 @@ png_read_push_finish_row(png_structrp png_ptr)
return; return;
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
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);
@ -1093,7 +1096,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 +

190
pngread.c
View File

@ -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[s]"); png_chunk_benign_error(png_ptr, "Too many IDATs found[s]");
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
@ -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;
@ -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,38 +401,38 @@ 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
} }
@ -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,
@ -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,
@ -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(a1)"); png_benign_error(png_ptr, "Too many IDATs found(a1)");
} }
png_handle_unknown(png_ptr, info_ptr, length, keep); png_handle_unknown(png_ptr, info_ptr, length, keep);
@ -811,7 +814,7 @@ 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(a2)"); png_benign_error(png_ptr, "Too many IDATs found(a2)");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
@ -907,7 +910,7 @@ 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 /* PNG_SEQUENTIAL_READ_SUPPORTED */
@ -922,22 +925,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 +959,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 +1042,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 +1056,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 +1066,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 +1076,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 +1086,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 +1098,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 +1110,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 +1121,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 +1138,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 +1146,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 +1155,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 +1164,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 +1172,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
@ -1313,10 +1330,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 +1347,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 +1447,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 +1481,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;
@ -1529,7 +1546,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
@ -1621,9 +1638,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 +1735,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 +1765,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 +1792,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 +1851,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 +2063,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 +2102,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 +2244,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 +2325,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 +2520,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 +2608,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 +2782,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,7 +2827,7 @@ 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);
@ -3226,7 +3244,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 +3543,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 +3653,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 +3674,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,7 +3689,7 @@ 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
@ -3686,7 +3706,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 +3737,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 +3750,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 +3762,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 +3833,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 +3857,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 +3873,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 +3903,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 +3928,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 +3950,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 +4086,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);

223
pngrtran.c
View File

@ -98,7 +98,7 @@ 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 +127,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_SCREEN && if (background_gamma_code != PNG_BACKGROUND_GAMMA_SCREEN &&
@ -175,7 +175,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;
@ -189,7 +189,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;
@ -202,7 +202,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;
@ -277,7 +277,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*/);
@ -369,7 +369,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->flags &= ~PNG_FLAG_BACKGROUND_EXPAND; png_ptr->flags &= ~PNG_FLAG_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");
@ -413,7 +413,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;
@ -800,7 +800,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. */
@ -853,7 +853,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);
@ -883,7 +883,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);
@ -895,7 +895,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;
@ -907,7 +907,7 @@ 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);
@ -923,7 +923,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);
@ -936,7 +936,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: */
@ -954,7 +954,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)
@ -1517,12 +1517,12 @@ 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)
{ {
if (!(png_ptr->transformations & PNG_FILLER)) if ((png_ptr->transformations & PNG_FILLER) == 0)
png_ptr->transformations &= ~(PNG_INVERT_ALPHA|PNG_SWAP_ALPHA); png_ptr->transformations &= ~(PNG_INVERT_ALPHA|PNG_SWAP_ALPHA);
if (!(png_ptr->transformations & PNG_COMPOSE)) if ((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 transformations, so it cancels out * transformations, before all other transformations, so it cancels out
@ -1548,7 +1548,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;
@ -1559,7 +1559,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
@ -1573,7 +1573,7 @@ png_init_read_transformations(png_structrp png_ptr)
/* Set up the background information if required. It is only used if /* Set up the background information if required. It is only used if
* PNG_COMPOSE is specified. * PNG_COMPOSE is specified.
*/ */
if (png_ptr->transformations & PNG_COMPOSE) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
png_init_background_transformations(png_ptr); png_init_background_transformations(png_ptr);
#endif #endif
@ -1606,19 +1606,19 @@ 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_tables(png_ptr, png_ptr->bit_depth); png_build_gamma_tables(png_ptr, png_ptr->bit_depth);
@ -1632,11 +1632,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)
{ {
unsigned int i, num_palette = png_ptr->num_palette; unsigned int i, num_palette = png_ptr->num_palette;
png_color back; png_color back;
@ -1729,7 +1729,7 @@ png_init_read_transformations(png_structrp png_ptr)
#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;
@ -1767,8 +1767,8 @@ png_init_read_transformations(png_structrp png_ptr)
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ #endif /* PNG_READ_BACKGROUND_SUPPORTED */
#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;
@ -1823,7 +1823,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)
{ {
@ -1845,9 +1845,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)
@ -1863,7 +1863,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
@ -1884,12 +1884,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
@ -1919,23 +1919,23 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
} }
#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;
} }
@ -1943,7 +1943,8 @@ 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->bit_depth == 8 &&
info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
{ {
info_ptr->bit_depth = 16; info_ptr->bit_depth = 16;
@ -1951,21 +1952,22 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
#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);
@ -1973,25 +1975,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;
@ -2142,7 +2144,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;
@ -2154,7 +2156,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;
} }
@ -2568,7 +2570,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;
@ -2603,7 +2605,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;
@ -2645,7 +2647,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;
@ -2684,7 +2686,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;
@ -2745,7 +2747,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)
{ {
@ -2883,8 +2885,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;
@ -3030,9 +3032,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;
@ -4020,7 +4022,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)
{ {
PNG_CONST unsigned int shift = png_ptr->gamma_shift; PNG_CONST unsigned int shift = png_ptr->gamma_shift;
PNG_CONST unsigned int add = (shift > 0 ? 1U<<(shift-1) : 0); PNG_CONST unsigned int add = (shift > 0 ? 1U<<(shift-1) : 0);
@ -4032,7 +4034,7 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (gamma_from_1 != NULL) if (gamma_from_1 != NULL)
{ {
PNG_CONST int step = PNG_CONST int step =
(row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2; (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0 ? 4 : 2;
/* The alpha channel is the last component: */ /* The alpha channel is the last component: */
row += step - 1; row += step - 1;
@ -4051,7 +4053,7 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (gamma_16_from_1 != NULL) if (gamma_16_from_1 != NULL)
{ {
PNG_CONST int step = PNG_CONST int step =
(row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4; (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0 ? 8 : 4;
/* The alpha channel is the last component: */ /* The alpha channel is the last component: */
row += step - 2; row += step - 2;
@ -4248,7 +4250,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)
{ {
@ -4392,7 +4394,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)
{ {
@ -4610,7 +4613,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.
@ -4620,7 +4623,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)
{ {
@ -4630,8 +4633,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));
@ -4643,8 +4646,8 @@ 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,
@ -4652,7 +4655,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#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,
@ -4707,31 +4710,31 @@ 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->flags & PNG_FLAG_BACKGROUND_IS_GRAY)) (png_ptr->flags & PNG_FLAG_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)
/* Because PNG_COMPOSE does the gamma transform if there is something to /* Because PNG_COMPOSE does the gamma transform if there is something to
* do (if there is an alpha channel or transparency.) * do (if there is an alpha channel or transparency.)
*/ */
!((png_ptr->transformations & PNG_COMPOSE) && !((png_ptr->transformations & PNG_COMPOSE) != 0 &&
((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.
@ -4741,8 +4744,8 @@ 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,
@ -4750,13 +4753,13 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
#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
@ -4765,12 +4768,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);
@ -4786,35 +4789,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->flags & PNG_FLAG_BACKGROUND_IS_GRAY)) (png_ptr->flags & PNG_FLAG_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
@ -4826,35 +4829,35 @@ 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 */
@ -4868,10 +4871,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 *

10
pngrutil.c
View File

@ -203,8 +203,8 @@ png_crc_finish(png_structrp png_ptr, png_uint_32 skip)
if (png_crc_error(png_ptr)) if (png_crc_error(png_ptr))
{ {
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ? if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ?
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) : (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) == 0:
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)) (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE) != 0)
{ {
png_chunk_warning(png_ptr, "CRC error"); png_chunk_warning(png_ptr, "CRC error");
} }
@ -2632,10 +2632,10 @@ png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
*/ */
++prefix_length; ++prefix_length;
if (compressed == 0 && prefix_length <= length) if (!compressed && prefix_length <= length)
uncompressed_length = length - prefix_length; uncompressed_length = length - prefix_length;
else if (compressed != 0 && prefix_length < length) else if (compressed && prefix_length < length)
{ {
uncompressed_length = PNG_SIZE_MAX; uncompressed_length = PNG_SIZE_MAX;
@ -2928,7 +2928,7 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
#endif /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */ #endif /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */
/* Check for unhandled critical chunks */ /* Check for unhandled critical chunks */
if (handled == 0 && PNG_CHUNK_CRITICAL(png_ptr->chunk_name)) if (!handled && PNG_CHUNK_CRITICAL(png_ptr->chunk_name))
png_chunk_error(png_ptr, "unhandled critical chunk"); png_chunk_error(png_ptr, "unhandled critical chunk");
} }

44
pngset.c
View File

@ -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);
@ -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,9 +289,11 @@ 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));
@ -595,7 +598,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 |=
@ -662,6 +666,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;
@ -892,7 +897,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 ||
@ -1082,6 +1087,7 @@ png_set_sPLT(png_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;
} }
@ -1116,7 +1122,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,
@ -1162,7 +1168,7 @@ png_set_unknown_chunks(png_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;
@ -1170,7 +1176,7 @@ png_set_unknown_chunks(png_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;
@ -1255,7 +1261,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
@ -1297,11 +1303,14 @@ 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)
{
if (memcmp(list, add, 4) == 0)
{ {
list[4] = (png_byte)keep; list[4] = (png_byte)keep;
return count; return count;
} }
}
if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT) if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
{ {
@ -1424,12 +1433,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)
@ -1437,6 +1449,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)
@ -1488,7 +1501,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;
@ -1508,7 +1522,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;
@ -1516,7 +1530,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)
{ {
@ -1554,7 +1568,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;
} }

58
pngtest.c
View File

@ -283,7 +283,8 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)
png_uint_32 n, nstop; png_uint_32 n, nstop;
int channel; int channel;
int color_channels = row_info->channels; int color_channels = row_info->channels;
if (row_info->color_type > 3)color_channels--; if (row_info->color_type > 3)
color_channels--;
for (n = 0, nstop=row_info->width; n<nstop; n++) for (n = 0, nstop=row_info->width; n<nstop; n++)
{ {
@ -643,7 +644,7 @@ set_location(png_structp png_ptr, struct user_chunk_data *data, int what)
{ {
int location; int location;
if ((data->location[0] & what) || (data->location[1] & what)) if ((data->location[0] & what) != 0 || (data->location[1] & what) != 0)
return 0; /* already have one of these */ return 0; /* already have one of these */
/* Find where we are (the code below zeroes info_ptr to indicate that the /* Find where we are (the code below zeroes info_ptr to indicate that the
@ -652,7 +653,7 @@ set_location(png_structp png_ptr, struct user_chunk_data *data, int what)
if (data->info_ptr == NULL) /* after IDAT */ if (data->info_ptr == NULL) /* after IDAT */
location = what | after_IDAT; location = what | after_IDAT;
else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE)) else if (png_get_valid(png_ptr, data->info_ptr, PNG_INFO_PLTE) != 0)
location = what | before_IDAT; location = what | before_IDAT;
else else
@ -699,7 +700,7 @@ read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
if (chunk->data[0] != 0 && chunk->data[0] != 1) if (chunk->data[0] != 0 && chunk->data[0] != 1)
return (-1); /* Invalid mode */ return (-1); /* Invalid mode */
if (set_location(png_ptr, my_user_chunk_data, have_sTER)) if (set_location(png_ptr, my_user_chunk_data, have_sTER) != 0)
{ {
my_user_chunk_data->sTER_mode=chunk->data[0]; my_user_chunk_data->sTER_mode=chunk->data[0];
return (1); return (1);
@ -718,7 +719,7 @@ read_user_chunk_callback(png_struct *png_ptr, png_unknown_chunkp chunk)
if (chunk->size != 9) if (chunk->size != 9)
return (-1); /* Error return */ return (-1); /* Error return */
if (!set_location(png_ptr, my_user_chunk_data, have_vpAg)) if (set_location(png_ptr, my_user_chunk_data, have_vpAg) == 0)
return (0); /* duplicate vpAg */ return (0); /* duplicate vpAg */
my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data); my_user_chunk_data->vpAg_width = png_get_uint_31(png_ptr, chunk->data);
@ -1049,7 +1050,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int interlace_type, compression_type, filter_type; int interlace_type, compression_type, filter_type;
if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth, if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
&color_type, &interlace_type, &compression_type, &filter_type)) &color_type, &interlace_type, &compression_type, &filter_type) != 0)
{ {
png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth, png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
color_type, interlace_type, compression_type, filter_type); color_type, interlace_type, compression_type, filter_type);
@ -1082,7 +1083,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
blue_y; blue_y;
if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y,
&red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y)) &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
{ {
png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x, png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,
red_y, green_x, green_y, blue_x, blue_y); red_y, green_x, green_y, blue_x, blue_y);
@ -1093,7 +1094,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_fixed_point gamma; png_fixed_point gamma;
if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma)) if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma) != 0)
png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma); png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);
} }
#endif #endif
@ -1105,7 +1106,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
blue_y; blue_y;
if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x, if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
&red_y, &green_x, &green_y, &blue_x, &blue_y)) &red_y, &green_x, &green_y, &blue_x, &blue_y) != 0)
{ {
png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x, png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
red_y, green_x, green_y, blue_x, blue_y); red_y, green_x, green_y, blue_x, blue_y);
@ -1116,7 +1117,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
double gamma; double gamma;
if (png_get_gAMA(read_ptr, read_info_ptr, &gamma)) if (png_get_gAMA(read_ptr, read_info_ptr, &gamma) != 0)
png_set_gAMA(write_ptr, write_info_ptr, gamma); png_set_gAMA(write_ptr, write_info_ptr, gamma);
} }
#endif #endif
@ -1130,7 +1131,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int compression_type; int compression_type;
if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type, if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,
&profile, &proflen)) &profile, &proflen) != 0)
{ {
png_set_iCCP(write_ptr, write_info_ptr, name, compression_type, png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,
profile, proflen); profile, proflen);
@ -1141,7 +1142,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
int intent; int intent;
if (png_get_sRGB(read_ptr, read_info_ptr, &intent)) if (png_get_sRGB(read_ptr, read_info_ptr, &intent) != 0)
png_set_sRGB(write_ptr, write_info_ptr, intent); png_set_sRGB(write_ptr, write_info_ptr, intent);
} }
#endif #endif
@ -1149,14 +1150,14 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_colorp palette; png_colorp palette;
int num_palette; int num_palette;
if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette)) if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette) != 0)
png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette); png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
} }
#ifdef PNG_bKGD_SUPPORTED #ifdef PNG_bKGD_SUPPORTED
{ {
png_color_16p background; png_color_16p background;
if (png_get_bKGD(read_ptr, read_info_ptr, &background)) if (png_get_bKGD(read_ptr, read_info_ptr, &background) != 0)
{ {
png_set_bKGD(write_ptr, write_info_ptr, background); png_set_bKGD(write_ptr, write_info_ptr, background);
} }
@ -1166,7 +1167,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_uint_16p hist; png_uint_16p hist;
if (png_get_hIST(read_ptr, read_info_ptr, &hist)) if (png_get_hIST(read_ptr, read_info_ptr, &hist) != 0)
png_set_hIST(write_ptr, write_info_ptr, hist); png_set_hIST(write_ptr, write_info_ptr, hist);
} }
#endif #endif
@ -1176,7 +1177,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int unit_type; int unit_type;
if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y, if (png_get_oFFs(read_ptr, read_info_ptr, &offset_x, &offset_y,
&unit_type)) &unit_type) != 0)
{ {
png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type); png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
} }
@ -1190,7 +1191,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
int type, nparams; int type, nparams;
if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
&nparams, &units, &params)) &nparams, &units, &params) != 0)
{ {
png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type, png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
nparams, units, params); nparams, units, params);
@ -1202,7 +1203,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_uint_32 res_x, res_y; png_uint_32 res_x, res_y;
int unit_type; int unit_type;
if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type)) if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y,
&unit_type) != 0)
png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type); png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
} }
#endif #endif
@ -1210,7 +1212,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_color_8p sig_bit; png_color_8p sig_bit;
if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit)) if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit) != 0)
png_set_sBIT(write_ptr, write_info_ptr, sig_bit); png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
} }
#endif #endif
@ -1222,7 +1224,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
double scal_width, scal_height; double scal_width, scal_height;
if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width, if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,
&scal_height)) &scal_height) != 0)
{ {
png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height); png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);
} }
@ -1234,7 +1236,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_charp scal_width, scal_height; png_charp scal_width, scal_height;
if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width, if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,
&scal_height)) &scal_height) != 0)
{ {
png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width,
scal_height); scal_height);
@ -1274,11 +1276,11 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_timep mod_time; png_timep mod_time;
if (png_get_tIME(read_ptr, read_info_ptr, &mod_time)) if (png_get_tIME(read_ptr, read_info_ptr, &mod_time) != 0)
{ {
png_set_tIME(write_ptr, write_info_ptr, mod_time); png_set_tIME(write_ptr, write_info_ptr, mod_time);
#ifdef PNG_TIME_RFC1123_SUPPORTED #ifdef PNG_TIME_RFC1123_SUPPORTED
if (png_convert_to_rfc1123_buffer(tIME_string, mod_time)) if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
tIME_string[(sizeof tIME_string) - 1] = '\0'; tIME_string[(sizeof tIME_string) - 1] = '\0';
else else
@ -1299,7 +1301,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
png_color_16p trans_color; png_color_16p trans_color;
if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans, if (png_get_tRNS(read_ptr, read_info_ptr, &trans_alpha, &num_trans,
&trans_color)) &trans_color) != 0)
{ {
int sample_max = (1 << bit_depth); int sample_max = (1 << bit_depth);
/* libpng doesn't reject a tRNS chunk with out-of-range samples */ /* libpng doesn't reject a tRNS chunk with out-of-range samples */
@ -1457,11 +1459,11 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
{ {
png_timep mod_time; png_timep mod_time;
if (png_get_tIME(read_ptr, end_info_ptr, &mod_time)) if (png_get_tIME(read_ptr, end_info_ptr, &mod_time) != 0)
{ {
png_set_tIME(write_ptr, write_end_info_ptr, mod_time); png_set_tIME(write_ptr, write_end_info_ptr, mod_time);
#ifdef PNG_TIME_RFC1123_SUPPORTED #ifdef PNG_TIME_RFC1123_SUPPORTED
if (png_convert_to_rfc1123_buffer(tIME_string, mod_time)) if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0)
tIME_string[(sizeof tIME_string) - 1] = '\0'; tIME_string[(sizeof tIME_string) - 1] = '\0';
else else
@ -1824,7 +1826,7 @@ main(int argc, char *argv[])
#endif #endif
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
for (k = 0; k<256; k++) for (k = 0; k<256; k++)
if (filters_used[k]) if (filters_used[k] != 0)
fprintf(STDERR, " Filter %d was used %lu times\n", fprintf(STDERR, " Filter %d was used %lu times\n",
k, (unsigned long)filters_used[k]); k, (unsigned long)filters_used[k]);
#endif #endif
@ -1915,7 +1917,7 @@ main(int argc, char *argv[])
#endif #endif
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
for (k = 0; k<256; k++) for (k = 0; k<256; k++)
if (filters_used[k]) if (filters_used[k] != 0)
fprintf(STDERR, " Filter %d was used %lu times\n", fprintf(STDERR, " Filter %d was used %lu times\n",
k, (unsigned long)filters_used[k]); k, (unsigned long)filters_used[k]);
#endif #endif

10
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 [(PENDING RELEASE)]
* 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;
} }
@ -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)

191
pngwrite.c
View File

@ -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.
@ -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, jend; int j, jend;
@ -232,42 +232,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;
@ -275,7 +275,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 */
@ -356,7 +356,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
@ -372,8 +372,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
@ -623,7 +623,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;
@ -698,44 +698,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
@ -744,12 +744,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;
@ -757,7 +758,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;
@ -773,7 +774,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;
@ -789,7 +790,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;
@ -797,7 +798,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;
@ -831,7 +832,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 ... */
@ -845,7 +846,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
@ -866,7 +867,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 */
@ -932,18 +933,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
@ -951,10 +958,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
@ -1000,7 +1010,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;
#endif #endif
@ -1233,7 +1243,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. */
@ -1288,7 +1298,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. */
@ -1547,7 +1557,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
@ -1557,16 +1567,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
@ -1574,7 +1584,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
@ -1585,13 +1595,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");
@ -1599,7 +1609,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");
@ -1607,7 +1617,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
@ -1615,7 +1625,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
@ -1623,7 +1633,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
@ -1631,7 +1641,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
@ -1726,10 +1736,10 @@ png_write_image_16bit(png_voidp argument)
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 */
@ -1881,13 +1891,13 @@ png_write_image_8bit(png_voidp argument)
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) ? 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 */
@ -2001,13 +2011,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 */
{ {
@ -2120,11 +2130,9 @@ png_image_write_main(png_voidp argument)
png_uint_32 format = image->format; png_uint_32 format = image->format;
int colormap = (format & PNG_FORMAT_FLAG_COLORMAP) != 0; int colormap = (format & PNG_FORMAT_FLAG_COLORMAP) != 0;
/* input */ int linear = !colormap && (format & PNG_FORMAT_FLAG_LINEAR) != 0; /* input */
int linear = (colormap == 0) && (format & PNG_FORMAT_FLAG_LINEAR) != 0; int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA) != 0;
int alpha = (colormap == 0) && (format & PNG_FORMAT_FLAG_ALPHA) != 0; int write_16bit = linear && !colormap && !display->convert_to_8bit;
int write_16bit = (linear != 0 ) && (colormap == 0) &&
(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 */
@ -2136,7 +2144,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)
{ {
@ -2173,7 +2181,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,
@ -2183,7 +2191,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
@ -2204,23 +2212,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 == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0) if (!colormap && (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 == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0) if (!colormap && (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;
} }
@ -2229,7 +2237,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. */
@ -2267,8 +2275,7 @@ 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 != 0 && alpha != 0 ) || if ((linear && alpha) || (!colormap && display->convert_to_8bit))
(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)));
@ -2317,7 +2324,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;
@ -2372,7 +2379,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 */

24
pngwtran.c
View File

@ -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;
@ -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,50 +521,50 @@ 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) 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
#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
} }

95
pngwutil.c
View File

@ -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,8 +286,6 @@ optimize_cmf(png_bytep data, png_alloc_size_t data_size)
} }
} }
} }
#else
# define optimize_cmf(dp,dl) ((void)0)
#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */ #endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */
/* Initialize the compressor for the appropriate type of compression. */ /* Initialize the compressor for the appropriate type of compression. */
@ -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.)
@ -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)
@ -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;
@ -1343,7 +1342,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;
@ -1376,7 +1375,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
{ {
/* Also checked in png_set_tRNS */ /* Also checked in png_set_tRNS */
@ -1500,8 +1499,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)
{ {
@ -1513,15 +1512,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,
@ -2041,7 +2040,7 @@ png_write_start_row(png_structrp png_ptr)
/* We only need to keep the previous row if we are using one of the following /* We only need to keep the previous row if we are using one of the following
* filters. * filters.
*/ */
if (filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
png_ptr->prev_row = png_voidcast(png_bytep, png_calloc(png_ptr, png_ptr->prev_row = png_voidcast(png_bytep, png_calloc(png_ptr,
buf_size)); buf_size));
@ -2054,9 +2053,9 @@ png_write_start_row(png_structrp png_ptr)
#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];
@ -2111,10 +2110,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++;
} }
@ -2139,7 +2138,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);
@ -2417,7 +2416,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;
@ -2493,7 +2492,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;
@ -2614,7 +2613,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;
@ -2728,7 +2727,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;
@ -2830,7 +2829,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;
@ -2869,7 +2868,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;