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

[libpng16] Added "& 0xff" to things being typecast to "png_byte".

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 2015-02-27 18:53:44 -06:00
parent 9a3de48b48
commit 7011a8cec3
12 changed files with 249 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
png.c
View File

@ -34,7 +34,7 @@ png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
if (num_bytes > 8) if (num_bytes > 8)
png_error(png_ptr, "Too many bytes for PNG signature"); png_error(png_ptr, "Too many bytes for PNG signature");
png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); png_ptr->sig_bytes = (png_byte)((num_bytes < 0 ? 0 : num_bytes) & 0xff);
} }
/* Checks whether the supplied bytes match the PNG signature. We allow /* Checks whether the supplied bytes match the PNG signature. We allow
@ -772,13 +772,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.6.17beta06 - February 25, 2015" PNG_STRING_NEWLINE \ "libpng version 1.6.17beta06 - February 28, 2015" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2015 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2015 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.6.17beta06 - February 25, 2015\ return "libpng version 1.6.17beta06 - February 28, 2015\
Copyright (c) 1998-2015 Glenn Randers-Pehrson\ Copyright (c) 1998-2015 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.";
@ -875,9 +875,9 @@ png_build_grayscale_palette(int bit_depth, png_colorp palette)
for (i = 0, v = 0; i < num_palette; i++, v += color_inc) for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
{ {
palette[i].red = (png_byte)v; palette[i].red = (png_byte)(v & 0xff);
palette[i].green = (png_byte)v; palette[i].green = (png_byte)(v & 0xff);
palette[i].blue = (png_byte)v; palette[i].blue = (png_byte)(v & 0xff);
} }
} }
#endif #endif
@ -3733,7 +3733,7 @@ png_exp8bit(png_fixed_point lg2)
* step. * step.
*/ */
x -= x >> 8; x -= x >> 8;
return (png_byte)((x + 0x7fffffU) >> 24); return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff);
} }
#ifdef PNG_16BIT_SUPPORTED #ifdef PNG_16BIT_SUPPORTED
@ -3794,7 +3794,7 @@ png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
# endif # endif
} }
return (png_byte)value; return (png_byte)(value & 0xff);
} }
#ifdef PNG_16BIT_SUPPORTED #ifdef PNG_16BIT_SUPPORTED
@ -4016,7 +4016,7 @@ png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
else else
for (i=0; i<256; ++i) for (i=0; i<256; ++i)
table[i] = (png_byte)i; table[i] = (png_byte)(i & 0xff);
} }
/* Used from png_read_destroy and below to release the memory used by the gamma /* Used from png_read_destroy and below to release the memory used by the gamma
@ -4156,7 +4156,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
* *
*/ */
if (sig_bit > 0 && sig_bit < 16U) if (sig_bit > 0 && sig_bit < 16U)
shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */ /* shift == insignificant bits */
shift = (png_byte)((16U - sig_bit) & 0xff);
else else
shift = 0; /* keep all 16 bits */ shift = 0; /* keep all 16 bits */
@ -4225,7 +4226,7 @@ png_set_option(png_structrp png_ptr, int option, int onoff)
int setting = (2 + (onoff != 0)) << option; int setting = (2 + (onoff != 0)) << option;
int current = png_ptr->options; int current = png_ptr->options;
png_ptr->options = (png_byte)((current & ~mask) | setting); png_ptr->options = (png_byte)(((current & ~mask) | setting) & 0xff);
return (current & mask) >> option; return (current & mask) >> option;
} }

26
png.h
View File

@ -1,7 +1,7 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.6.17beta06, February 25, 2015 * libpng version 1.6.17beta06, February 28, 2015
* Copyright (c) 1998-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2015 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -11,7 +11,7 @@
* Authors and maintainers: * Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.6.17beta06, February 25, 2015: Glenn * libpng versions 0.97, January 1998, through 1.6.17beta06, February 28, 2015: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@ -244,7 +244,7 @@
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* *
* libpng versions 1.2.6, August 15, 2004, through 1.6.17beta06, February 25, 2015, are * libpng versions 1.2.6, August 15, 2004, through 1.6.17beta06, February 28, 2015, are
* Copyright (c) 2004, 2006-2015 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2015 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:
@ -356,7 +356,7 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* February 25, 2015 * February 28, 2015
* *
* 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.
@ -426,7 +426,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.6.17beta06" #define PNG_LIBPNG_VER_STRING "1.6.17beta06"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.6.17beta06 - February 25, 2015\n" " libpng version 1.6.17beta06 - February 28, 2015\n"
#define PNG_LIBPNG_VER_SONUM 16 #define PNG_LIBPNG_VER_SONUM 16
#define PNG_LIBPNG_VER_DLLNUM 16 #define PNG_LIBPNG_VER_DLLNUM 16
@ -1579,6 +1579,7 @@ PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */
#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */
#ifdef PNG_WRITE_SUPPORTED
/* These functions give the user control over the scan-line filtering in /* These functions give the user control over the scan-line filtering in
* libpng and the compression methods used by zlib. These functions are * libpng and the compression methods used by zlib. These functions are
* mainly useful for testing, as the defaults should work with most users. * mainly useful for testing, as the defaults should work with most users.
@ -1663,7 +1664,6 @@ PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */
#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */
#ifdef PNG_WRITE_SUPPORTED
/* Set the library compression level. Currently, valid values range from /* Set the library compression level. Currently, valid values range from
* 0 - 9, corresponding directly to the zlib compression levels 0 - 9 * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
* (0 - no compression, 9 - "maximal" compression). Note that tests have * (0 - no compression, 9 - "maximal" compression). Note that tests have
@ -2667,26 +2667,28 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
* (png_uint_16)(alpha) \ * (png_uint_16)(alpha) \
+ (png_uint_16)(bg)*(png_uint_16)(255 \ + (png_uint_16)(bg)*(png_uint_16)(255 \
- (png_uint_16)(alpha)) + 128); \ - (png_uint_16)(alpha)) + 128); \
(composite) = (png_byte)((temp + (temp >> 8)) >> 8); } (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); }
# define png_composite_16(composite, fg, alpha, bg) \ # define png_composite_16(composite, fg, alpha, bg) \
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
* (png_uint_32)(alpha) \ * (png_uint_32)(alpha) \
+ (png_uint_32)(bg)*(65535 \ + (png_uint_32)(bg)*(65535 \
- (png_uint_32)(alpha)) + 32768); \ - (png_uint_32)(alpha)) + 32768); \
(composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); }
#else /* Standard method using integer division */ #else /* Standard method using integer division */
# define png_composite(composite, fg, alpha, bg) \ # define png_composite(composite, fg, alpha, bg) \
(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ (composite) = \
(png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
127) / 255) 127) / 255))
# define png_composite_16(composite, fg, alpha, bg) \ # define png_composite_16(composite, fg, alpha, bg) \
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ (composite) = \
(png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
32767) / 65535) 32767) / 65535))
#endif /* READ_COMPOSITE_NODIV */ #endif /* READ_COMPOSITE_NODIV */
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED

2
pngget.c
View File

@ -1123,7 +1123,7 @@ png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
png_byte PNGAPI png_byte PNGAPI
png_get_rgb_to_gray_status (png_const_structrp png_ptr) png_get_rgb_to_gray_status (png_const_structrp png_ptr)
{ {
return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); return (png_byte)((png_ptr ? png_ptr->rgb_to_gray_status : 0) & 0xff);
} }
#endif #endif

2
pngpread.c
View File

@ -168,7 +168,7 @@ png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
num_to_check); num_to_check);
png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check); png_ptr->sig_bytes = (png_byte)((png_ptr->sig_bytes + num_to_check) & 0xff);
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
{ {

11
pngpriv.h
View File

@ -748,8 +748,10 @@
* systems where (char) is more than 8 bits. * systems where (char) is more than 8 bits.
*/ */
#define PNG_STRING_FROM_CHUNK(s,c)\ #define PNG_STRING_FROM_CHUNK(s,c)\
(void)(((char*)(s))[0]=(char)(((c)>>24)&0xFF), ((char*)(s))[1]=(char)(((c)>>16)&0xFF),\ (void)(((char*)(s))[0]=(char)(((c)>>24) & 0xff), \
((char*)(s))[2]=(char)(((c)>>8)&0xFF), ((char*)(s))[3]=(char)((c&0xFF))) ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\
((char*)(s))[2]=(char)(((c)>>8) & 0xff), \
((char*)(s))[3]=(char)((c & 0xff)))
/* Do the same but terminate with a null character. */ /* Do the same but terminate with a null character. */
#define PNG_CSTRING_FROM_CHUNK(s,c)\ #define PNG_CSTRING_FROM_CHUNK(s,c)\
@ -811,8 +813,9 @@ PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]); PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]); PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
#define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\ #define PNG_sRGB_FROM_LINEAR(linear) \
((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)) ((png_byte)(0xff & ((png_sRGB_base[(linear)>>15] \
+ ((((linear) & 0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)))
/* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
* encoded value with maximum error 0.646365. Note that the input is not a * encoded value with maximum error 0.646365. Note that the input is not a
* 16-bit value; it has been multiplied by 255! */ * 16-bit value; it has been multiplied by 255! */

5
pngread.c
View File

@ -2052,7 +2052,7 @@ make_rgb_colormap(png_image_read_control *display)
/* Return a palette index to the above palette given three 8-bit sRGB values. */ /* Return a palette index to the above palette given three 8-bit sRGB values. */
#define PNG_RGB_INDEX(r,g,b) \ #define PNG_RGB_INDEX(r,g,b) \
((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b))) ((png_byte)(0xff & (6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b))))
static int static int
png_image_read_colormap(png_voidp argument) png_image_read_colormap(png_voidp argument)
@ -3025,7 +3025,8 @@ png_image_read_and_map(png_voidp argument)
*outrow = gray; *outrow = gray;
else else
*outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1); *outrow =
(png_byte)(0xff & (PNG_CMAP_TRANS_BACKGROUND+1));
} }
break; break;

195
pngrtran.c
View File

@ -143,7 +143,7 @@ png_set_background_fixed(png_structrp png_ptr,
png_ptr->background = *background_color; png_ptr->background = *background_color;
png_ptr->background_gamma = background_gamma; png_ptr->background_gamma = background_gamma;
png_ptr->background_gamma_type = (png_byte)(background_gamma_code); png_ptr->background_gamma_type = (png_byte)(0xff & background_gamma_code);
if (need_expand != 0) if (need_expand != 0)
png_ptr->transformations |= PNG_BACKGROUND_EXPAND; png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
else else
@ -1176,8 +1176,8 @@ png_init_palette_transformations(png_structrp png_ptr)
int i, istop = png_ptr->num_trans; int i, istop = png_ptr->num_trans;
for (i=0; i<istop; i++) for (i=0; i<istop; i++)
png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i] = (png_byte)(0xff & (255 -
png_ptr->trans_alpha[i]); png_ptr->trans_alpha[i]));
} }
} }
#endif /* READ_INVERT_ALPHA */ #endif /* READ_INVERT_ALPHA */
@ -2023,14 +2023,14 @@ 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) != 0) 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)(0xff & (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) != 0) 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)(0xff & (info_ptr->color_type &
~PNG_COLOR_MASK_COLOR); ~PNG_COLOR_MASK_COLOR));
#endif #endif
#ifdef PNG_READ_QUANTIZE_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
@ -2072,8 +2072,8 @@ png_read_transform_info(png_structrp png_ptr, png_inforp info_ptr)
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0) if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
{ {
info_ptr->color_type = (png_byte)(info_ptr->color_type & info_ptr->color_type = (png_byte)(0xff & (info_ptr->color_type &
~PNG_COLOR_MASK_ALPHA); ~PNG_COLOR_MASK_ALPHA));
info_ptr->num_trans = 0; info_ptr->num_trans = 0;
} }
#endif #endif
@ -2106,8 +2106,8 @@ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
} }
#endif #endif
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->pixel_depth = (png_byte)(0xff & (info_ptr->channels *
info_ptr->bit_depth); info_ptr->bit_depth));
info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
@ -2218,7 +2218,7 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
break; break;
} }
row_info->bit_depth = 8; row_info->bit_depth = 8;
row_info->pixel_depth = (png_byte)(8 * row_info->channels); row_info->pixel_depth = (png_byte)(0xff & (8 * row_info->channels));
row_info->rowbytes = row_width * row_info->channels; row_info->rowbytes = row_width * row_info->channels;
} }
} }
@ -2356,8 +2356,8 @@ png_do_unshift(png_row_infop row_info, png_bytep row,
value >>= shift[channel]; value >>= shift[channel];
if (++channel >= channels) if (++channel >= channels)
channel = 0; channel = 0;
*bp++ = (png_byte)(value >> 8); *bp++ = (png_byte)(0xff & (value >> 8));
*bp++ = (png_byte)(value & 0xff); *bp++ = (png_byte)(0xff & value);
} }
break; break;
} }
@ -2420,7 +2420,7 @@ png_do_scale_16_to_8(png_row_infop row_info, png_bytep row)
} }
row_info->bit_depth = 8; row_info->bit_depth = 8;
row_info->pixel_depth = (png_byte)(8 * row_info->channels); row_info->pixel_depth = (png_byte)(0xff & (8 * row_info->channels));
row_info->rowbytes = row_info->width * row_info->channels; row_info->rowbytes = row_info->width * row_info->channels;
} }
} }
@ -2448,7 +2448,7 @@ png_do_chop(png_row_infop row_info, png_bytep row)
} }
row_info->bit_depth = 8; row_info->bit_depth = 8;
row_info->pixel_depth = (png_byte)(8 * row_info->channels); row_info->pixel_depth = (png_byte)(0xff & (8 * row_info->channels));
row_info->rowbytes = row_info->width * row_info->channels; row_info->rowbytes = row_info->width * row_info->channels;
} }
} }
@ -2570,7 +2570,7 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
/* This does nothing: /* This does nothing:
*(--dp) = *(--sp); *(--dp) = *(--sp);
@ -2593,8 +2593,8 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
/* This does nothing: /* This does nothing:
*(--dp) = *(--sp); *(--dp) = *(--sp);
@ -2622,7 +2622,7 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
*(--dp) = *(--sp); *(--dp) = *(--sp);
} }
} }
@ -2637,8 +2637,8 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
*(--dp) = (png_byte)(255 - *(--sp)); *(--dp) = (png_byte)(0xff & (255 - *(--sp)));
/* /*
*(--dp) = *(--sp); *(--dp) = *(--sp);
*(--dp) = *(--sp); *(--dp) = *(--sp);
@ -2918,10 +2918,10 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
} }
} }
} }
row_info->channels = (png_byte)(row_info->channels + 2); row_info->channels = (png_byte)(0xff & (row_info->channels + 2));
row_info->color_type |= PNG_COLOR_MASK_COLOR; row_info->color_type |= PNG_COLOR_MASK_COLOR;
row_info->pixel_depth = (png_byte)(row_info->channels * row_info->pixel_depth = (png_byte)(0xff & (row_info->channels *
row_info->bit_depth); row_info->bit_depth));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
} }
} }
@ -3063,7 +3063,8 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
/* NOTE: this is the historical approach which simply /* NOTE: this is the historical approach which simply
* truncates the results. * truncates the results.
*/ */
*(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); *(dp++) =
(png_byte)(0xff & ((rc*red + gc*green + bc*blue)>>15));
} }
else else
@ -3166,11 +3167,11 @@ png_do_rgb_to_gray(png_structrp png_ptr, png_row_infop row_info, png_bytep row)
} }
} }
row_info->channels = (png_byte)(row_info->channels - 2); row_info->channels = (png_byte)(0xff & (row_info->channels - 2));
row_info->color_type = (png_byte)(row_info->color_type & row_info->color_type = (png_byte)(0xff & (row_info->color_type &
~PNG_COLOR_MASK_COLOR); ~PNG_COLOR_MASK_COLOR));
row_info->pixel_depth = (png_byte)(row_info->channels * row_info->pixel_depth = (png_byte)(0xff & (row_info->channels *
row_info->bit_depth); row_info->bit_depth));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
} }
return rgb_error; return rgb_error;
@ -3412,10 +3413,10 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (v == png_ptr->trans_color.gray) if (v == png_ptr->trans_color.gray)
{ {
/* Background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.gray >> 8) *sp = (png_byte)(0xff &
& 0xff); (png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.gray *(sp + 1) = (png_byte)(0xff &
& 0xff); png_ptr->background.gray);
} }
else else
@ -3438,10 +3439,10 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (v == png_ptr->trans_color.gray) if (v == png_ptr->trans_color.gray)
{ {
*sp = (png_byte)((png_ptr->background.gray >> 8) *sp = (png_byte)(0xff &
& 0xff); (png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.gray *(sp + 1) = (png_byte)(0xff &
& 0xff); png_ptr->background.gray);
} }
} }
} }
@ -3519,15 +3520,18 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
b == png_ptr->trans_color.blue) b == png_ptr->trans_color.blue)
{ {
/* Background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); *sp = (png_byte)(0xff &
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); (png_ptr->background.red >> 8));
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) *(sp + 1) = (png_byte)(0xff &
& 0xff); png_ptr->background.red);
*(sp + 3) = (png_byte)(png_ptr->background.green *(sp + 2) = (png_byte)(0xff &
& 0xff); (png_ptr->background.green >> 8));
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) *(sp + 3) = (png_byte)(0xff &
& 0xff); png_ptr->background.green);
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); *(sp + 4) = (png_byte)(0xff &
(png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(0xff &
png_ptr->background.blue);
} }
else else
@ -3565,15 +3569,15 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
g == png_ptr->trans_color.green && g == png_ptr->trans_color.green &&
b == png_ptr->trans_color.blue) b == png_ptr->trans_color.blue)
{ {
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); *sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); *(sp + 1) = (png_byte)(0xff & png_ptr->background.red);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) *(sp + 2) = (png_byte)(0xff &
& 0xff); (png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(png_ptr->background.green *(sp + 3) = (png_byte)(0xff &
& 0xff); png_ptr->background.green);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) *(sp + 4) = (png_byte)(0xff &
& 0xff); (png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); *(sp + 5) = (png_byte)(0xff & png_ptr->background.blue);
} }
} }
} }
@ -3655,9 +3659,9 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
else if (a == 0) else if (a == 0)
{ {
/* Background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.gray >> 8) *sp = (png_byte)(0xff &
& 0xff); (png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); *(sp + 1) = (png_byte)(0xff & png_ptr->background.gray);
} }
else else
@ -3686,9 +3690,9 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (a == 0) if (a == 0)
{ {
*sp = (png_byte)((png_ptr->background.gray >> 8) *sp = (png_byte)(0xff &
& 0xff); (png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); *(sp + 1) = (png_byte)(0xff & png_ptr->background.gray);
} }
else if (a < 0xffff) else if (a < 0xffff)
@ -3815,15 +3819,15 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
else if (a == 0) else if (a == 0)
{ {
/* Background is already in screen gamma */ /* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); *sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); *(sp + 1) = (png_byte)(0xff & png_ptr->background.red );
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) *(sp + 2) = (png_byte)(0xff &
& 0xff); (png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(png_ptr->background.green *(sp + 3) = (png_byte)(0xff &
& 0xff); png_ptr->background.green);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) *(sp + 4) = (png_byte)(0xff &
& 0xff); (png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); *(sp + 5) = (png_byte)(0xff & png_ptr->background.blue);
} }
else else
@ -3833,8 +3837,8 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
png_composite_16(w, v, a, png_ptr->background_1.red); png_composite_16(w, v, a, png_ptr->background_1.red);
if (optimize == 0) if (optimize == 0)
w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> w = gamma_16_from_1[((w & 0xff) >>
8]; gamma_shift)][w >> 8];
*sp = (png_byte)((w >> 8) & 0xff); *sp = (png_byte)((w >> 8) & 0xff);
*(sp + 1) = (png_byte)(w & 0xff); *(sp + 1) = (png_byte)(w & 0xff);
@ -3870,15 +3874,16 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (a == 0) if (a == 0)
{ {
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); *sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); *(sp + 1) = (png_byte)(0xff & png_ptr->background.red);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8) *(sp + 2) = (png_byte)(0xff &
& 0xff); (png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(png_ptr->background.green *(sp + 3) = (png_byte)(0xff &
& 0xff); png_ptr->background.green);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) *(sp + 4) = (png_byte)(0xff &
& 0xff); (png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); *(sp + 5) = (png_byte)(0xff &
png_ptr->background.blue & 0xff);
} }
else if (a < 0xffff) else if (a < 0xffff)
@ -4065,11 +4070,12 @@ png_do_gamma(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
int c = *sp & 0x0c; int c = *sp & 0x0c;
int d = *sp & 0x03; int d = *sp & 0x03;
*sp = (png_byte)( *sp = (png_byte)(0xff &
((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| (((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|
((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|
((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|
((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) & 0xff))
);
sp++; sp++;
} }
} }
@ -4400,8 +4406,8 @@ png_do_expand(png_row_infop row_info, png_bytep row,
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
value = (*sp >> shift) & 0x03; value = (*sp >> shift) & 0x03;
*dp = (png_byte)(value | (value << 2) | (value << 4) | *dp = (png_byte)(0xff & (value | (value << 2) |
(value << 6)); (value << 4) | (value << 6)));
if (shift == 6) if (shift == 6)
{ {
shift = 0; shift = 0;
@ -4425,7 +4431,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
for (i = 0; i < row_width; i++) for (i = 0; i < row_width; i++)
{ {
value = (*sp >> shift) & 0x0f; value = (*sp >> shift) & 0x0f;
*dp = (png_byte)(value | (value << 4)); *dp = (png_byte)(0xff & (value | (value << 4)));
if (shift == 4) if (shift == 4)
{ {
shift = 0; shift = 0;
@ -4496,7 +4502,8 @@ png_do_expand(png_row_infop row_info, png_bytep row,
row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
row_info->channels = 2; row_info->channels = 2;
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); row_info->pixel_depth =
(png_byte)(0xff & (row_info->bit_depth << 1));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
row_width); row_width);
} }
@ -4563,7 +4570,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
} }
row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
row_info->channels = 4; row_info->channels = 4;
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); row_info->pixel_depth = (png_byte)(0xff & (row_info->bit_depth << 2));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
} }
} }
@ -4596,7 +4603,7 @@ png_do_expand_16(png_row_infop row_info, png_bytep row)
row_info->rowbytes *= 2; row_info->rowbytes *= 2;
row_info->bit_depth = 16; row_info->bit_depth = 16;
row_info->pixel_depth = (png_byte)(row_info->channels * 16); row_info->pixel_depth = (png_byte)(0xff & (row_info->channels * 16));
} }
} }
#endif #endif
@ -4984,8 +4991,8 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
if (png_ptr->user_transform_channels != 0) 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)(0xff & (row_info->bit_depth *
row_info->channels); row_info->channels));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width);
} }

37
pngrutil.c
View File

@ -822,13 +822,13 @@ png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
/* Set internal variables */ /* Set internal variables */
png_ptr->width = width; png_ptr->width = width;
png_ptr->height = height; png_ptr->height = height;
png_ptr->bit_depth = (png_byte)bit_depth; png_ptr->bit_depth = (png_byte)(bit_depth & 0xff);
png_ptr->interlaced = (png_byte)interlace_type; png_ptr->interlaced = (png_byte)(interlace_type & 0xff);
png_ptr->color_type = (png_byte)color_type; png_ptr->color_type = (png_byte)(color_type & 0xff);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
png_ptr->filter_type = (png_byte)filter_type; png_ptr->filter_type = (png_byte)(filter_type & 0xff);
#endif #endif
png_ptr->compression_type = (png_byte)compression_type; png_ptr->compression_type = (png_byte)(compression_type & 0xff);
/* Find number of channels */ /* Find number of channels */
switch (png_ptr->color_type) switch (png_ptr->color_type)
@ -853,7 +853,8 @@ png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
} }
/* Set up other useful info */ /* Set up other useful info */
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * png_ptr->channels); png_ptr->pixel_depth =
(png_byte)(0xff & (png_ptr->bit_depth * png_ptr->channels));
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width); png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
png_debug1(3, "bit_depth = %d", png_ptr->bit_depth); png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
png_debug1(3, "channels = %d", png_ptr->channels); png_debug1(3, "channels = %d", png_ptr->channels);
@ -2731,7 +2732,8 @@ png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
/* The following is safe because of the PNG_SIZE_MAX init above */ /* The following is safe because of the PNG_SIZE_MAX init above */
png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/; png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
/* 'mode' is a flag array, only the bottom four bits matter here */ /* 'mode' is a flag array, only the bottom four bits matter here */
png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/; png_ptr->unknown_chunk.location =
(png_byte)(0xff & png_ptr->mode/*SAFE*/);
if (length == 0) if (length == 0)
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
@ -3228,7 +3230,7 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
if (m != 0) /* something to copy */ if (m != 0) /* something to copy */
{ {
if (m != 0xff) if (m != 0xff)
*dp = (png_byte)((*dp & ~m) | (*sp & m)); *dp = (png_byte)(((*dp & ~m) | (*sp & m)) & 0xff);
else else
*dp = *sp; *dp = *sp;
} }
@ -3480,7 +3482,8 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
/* Restore the overwritten bits from the last byte if necessary. */ /* Restore the overwritten bits from the last byte if necessary. */
if (end_ptr != NULL) if (end_ptr != NULL)
*end_ptr = (png_byte)((end_byte & end_mask) | (*end_ptr & ~end_mask)); *end_ptr =
(png_byte)(0xff & ((end_byte & end_mask) | (*end_ptr & ~end_mask)));
} }
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
@ -3774,16 +3777,14 @@ png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
for (i = 0; i < bpp; i++) for (i = 0; i < bpp; i++)
{ {
*rp = (png_byte)(((int)(*rp) + *rp = (png_byte)(((int)(*rp) + ((int)(*pp++) / 2 )) & 0xff);
((int)(*pp++) / 2 )) & 0xff);
rp++; rp++;
} }
for (i = 0; i < istop; i++) for (i = 0; i < istop; i++)
{ {
*rp = (png_byte)(((int)(*rp) + *rp = (png_byte)(((int)(*rp) + (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
(int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
rp++; rp++;
} }
@ -3799,7 +3800,7 @@ png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
/* First pixel/byte */ /* First pixel/byte */
c = *prev_row++; c = *prev_row++;
a = *row + c; a = *row + c;
*row++ = (png_byte)a; *row++ = (png_byte)(a & 0xff);
/* Remainder */ /* Remainder */
while (row < rp_end) while (row < rp_end)
@ -3833,7 +3834,7 @@ png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
*/ */
c = b; c = b;
a += *row; a += *row;
*row++ = (png_byte)a; *row++ = (png_byte)(a & 0xff);
} }
} }
@ -3850,7 +3851,7 @@ png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
while (row < rp_end) while (row < rp_end)
{ {
int a = *row + *prev_row++; int a = *row + *prev_row++;
*row++ = (png_byte)(a&0xFF); *row++ = (png_byte)(a & 0xff);
} }
/* Remainder */ /* Remainder */
@ -3881,7 +3882,7 @@ png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
if (pc < pa) a = c; if (pc < pa) a = c;
a += *row; a += *row;
*row++ = (png_byte)(a&0xFF); *row++ = (png_byte)(a & 0xff);
} }
} }
@ -4374,7 +4375,7 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
/* This value is stored in png_struct and double checked in the row read /* This value is stored in png_struct and double checked in the row read
* code. * code.
*/ */
png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth; png_ptr->maximum_pixel_depth = (png_byte)(max_pixel_depth & 0xff);
png_ptr->transformed_pixel_depth = 0; /* calculated on demand */ png_ptr->transformed_pixel_depth = 0; /* calculated on demand */
/* Align the width on the next larger 8 pixels. Mainly used /* Align the width on the next larger 8 pixels. Mainly used

13
pngtrans.c
View File

@ -273,7 +273,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
for (i = 0; i < istop; i++) for (i = 0; i < istop; i++)
{ {
*rp = (png_byte)(~(*rp)); *rp = (png_byte)((~(*rp)) & 0xff);
rp++; rp++;
} }
} }
@ -287,7 +287,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
for (i = 0; i < istop; i += 2) for (i = 0; i < istop; i += 2)
{ {
*rp = (png_byte)(~(*rp)); *rp = (png_byte)((~(*rp)) & 0xff);
rp += 2; rp += 2;
} }
} }
@ -302,8 +302,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
for (i = 0; i < istop; i += 4) for (i = 0; i < istop; i += 4)
{ {
*rp = (png_byte)(~(*rp)); *rp = (png_byte)((~(*rp)) & 0xff);
*(rp + 1) = (png_byte)(~(*(rp + 1))); *(rp + 1) = (png_byte)((~(*(rp + 1))) & 0xff);
rp += 4; rp += 4;
} }
} }
@ -803,8 +803,9 @@ png_set_user_transform_info(png_structrp png_ptr, png_voidp
#endif #endif
png_ptr->user_transform_ptr = user_transform_ptr; png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr->user_transform_depth = (png_byte)user_transform_depth; png_ptr->user_transform_depth = (png_byte)(user_transform_depth & 0xff);
png_ptr->user_transform_channels = (png_byte)user_transform_channels; png_ptr->user_transform_channels =
(png_byte)(user_transform_channels & 0xff);
} }
#endif #endif

51
pngwrite.c
View File

@ -219,7 +219,7 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
int j; int j;
for (j = 0; j<(int)info_ptr->num_trans; j++) for (j = 0; j<(int)info_ptr->num_trans; j++)
info_ptr->trans_alpha[j] = info_ptr->trans_alpha[j] =
(png_byte)(255 - info_ptr->trans_alpha[j]); (png_byte)((255 - info_ptr->trans_alpha[j]) & 0xff);
} }
#endif #endif
png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color), png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
@ -457,11 +457,11 @@ png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
png_debug(1, "in png_convert_from_struct_tm"); png_debug(1, "in png_convert_from_struct_tm");
ptime->year = (png_uint_16)(1900 + ttime->tm_year); ptime->year = (png_uint_16)(1900 + ttime->tm_year);
ptime->month = (png_byte)(ttime->tm_mon + 1); ptime->month = (png_byte)((ttime->tm_mon + 1) & 0xff);
ptime->day = (png_byte)ttime->tm_mday; ptime->day = (png_byte)(ttime->tm_mday & 0xff);
ptime->hour = (png_byte)ttime->tm_hour; ptime->hour = (png_byte)(ttime->tm_hour & 0xff);
ptime->minute = (png_byte)ttime->tm_min; ptime->minute = (png_byte)(ttime->tm_min & 0xff);
ptime->second = (png_byte)ttime->tm_sec; ptime->second = (png_byte)(ttime->tm_sec & 0xff);
} }
void PNGAPI void PNGAPI
@ -811,7 +811,8 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
row_info.width = png_ptr->usr_width; row_info.width = png_ptr->usr_width;
row_info.channels = png_ptr->usr_channels; row_info.channels = png_ptr->usr_channels;
row_info.bit_depth = png_ptr->usr_bit_depth; row_info.bit_depth = png_ptr->usr_bit_depth;
row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels); row_info.pixel_depth =
(png_byte)(0xff & (row_info.bit_depth * row_info.channels));
row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
png_debug1(3, "row_info->color_type = %d", row_info.color_type); png_debug1(3, "row_info->color_type = %d", row_info.color_type);
@ -1037,7 +1038,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
png_ptr->do_filter = PNG_FILTER_PAETH; break; png_ptr->do_filter = PNG_FILTER_PAETH; break;
default: default:
png_ptr->do_filter = (png_byte)filters; break; png_ptr->do_filter = (png_byte)(filters & 0xff); break;
#else #else
default: default:
png_app_error(png_ptr, "Unknown row filter for method 0"); png_app_error(png_ptr, "Unknown row filter for method 0");
@ -1070,8 +1071,8 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
{ {
png_warning(png_ptr, "Can't add Up filter after starting"); png_warning(png_ptr, "Can't add Up filter after starting");
png_ptr->do_filter = (png_byte)(png_ptr->do_filter & png_ptr->do_filter =
~PNG_FILTER_UP); (png_byte)((png_ptr->do_filter & ~PNG_FILTER_UP) & 0xff);
} }
else else
@ -1088,8 +1089,8 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
{ {
png_warning(png_ptr, "Can't add Average filter after starting"); png_warning(png_ptr, "Can't add Average filter after starting");
png_ptr->do_filter = (png_byte)(png_ptr->do_filter & png_ptr->do_filter =
~PNG_FILTER_AVG); (png_byte)((png_ptr->do_filter & ~PNG_FILTER_AVG) & 0xff);
} }
else else
@ -1106,7 +1107,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->prev_row == NULL) if (png_ptr->prev_row == NULL)
{ {
png_warning(png_ptr, "Can't add Paeth filter after starting"); png_warning(png_ptr, "Can't add Paeth filter after starting");
png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); png_ptr->do_filter &= (png_byte)((~PNG_FILTER_PAETH) & 0xff);
} }
else else
@ -1210,7 +1211,7 @@ png_init_filter_heuristics(png_structrp png_ptr, int heuristic_method,
} }
/* Safe to set this now */ /* Safe to set this now */
png_ptr->num_prev_filters = (png_byte)num_weights; png_ptr->num_prev_filters = (png_byte)(num_weights & 0xff);
} }
/* If, in the future, there are other filter methods, this would /* If, in the future, there are other filter methods, this would
@ -1890,7 +1891,7 @@ png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
component *= 255; component *= 255;
/* Convert the component to sRGB. */ /* Convert the component to sRGB. */
return (png_byte)PNG_sRGB_FROM_LINEAR(component); return (png_byte)(PNG_sRGB_FROM_LINEAR(component) & 0xff);
} }
else else
@ -1939,7 +1940,7 @@ png_write_image_8bit(png_voidp argument)
while (out_ptr < row_end) while (out_ptr < row_end)
{ {
png_uint_16 alpha = in_ptr[aindex]; png_uint_16 alpha = in_ptr[aindex];
png_byte alphabyte = (png_byte)PNG_DIV257(alpha); png_byte alphabyte = (png_byte)(PNG_DIV257(alpha) & 0xff);
png_uint_32 reciprocal = 0; png_uint_32 reciprocal = 0;
int c; int c;
@ -1982,7 +1983,7 @@ png_write_image_8bit(png_voidp argument)
png_uint_32 component = *in_ptr++; png_uint_32 component = *in_ptr++;
component *= 255; component *= 255;
*out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component); *out_ptr++ = (png_byte)(PNG_sRGB_FROM_LINEAR(component) & 0xff);
} }
png_write_row(png_ptr, output_row); png_write_row(png_ptr, output_row);
@ -2041,23 +2042,23 @@ png_image_set_PLTE(png_image_write_control *display)
{ {
if (channels >= 3) /* RGB */ if (channels >= 3) /* RGB */
{ {
palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].blue = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[(2 ^ bgr)]); entry[(2 ^ bgr)]));
palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].green = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[1]); entry[1]));
palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].red = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[bgr]); entry[bgr]));
} }
else /* Gray */ else /* Gray */
palette[i].blue = palette[i].red = palette[i].green = palette[i].blue = palette[i].red = palette[i].green =
(png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry); (png_byte)(PNG_sRGB_FROM_LINEAR((255 * *entry)) & 0xff);
} }
else /* alpha */ else /* alpha */
{ {
png_uint_16 alpha = entry[afirst ? 0 : channels-1]; png_uint_16 alpha = entry[afirst ? 0 : channels-1];
png_byte alphabyte = (png_byte)PNG_DIV257(alpha); png_byte alphabyte = (png_byte)(PNG_DIV257(alpha) & 0xff);
png_uint_32 reciprocal = 0; png_uint_32 reciprocal = 0;
/* Calculate a reciprocal, as in the png_write_image_8bit code above /* Calculate a reciprocal, as in the png_write_image_8bit code above

29
pngwtran.c
View File

@ -56,14 +56,14 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
else else
{ {
mask = 0x80; mask = 0x80;
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
dp++; dp++;
v = 0; v = 0;
} }
} }
if (mask != 0x80) if (mask != 0x80)
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
break; break;
} }
@ -90,7 +90,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
if (shift == 0) if (shift == 0)
{ {
shift = 6; shift = 6;
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
dp++; dp++;
v = 0; v = 0;
} }
@ -102,7 +102,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
} }
if (shift != 6) if (shift != 6)
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
break; break;
} }
@ -129,7 +129,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
if (shift == 0) if (shift == 0)
{ {
shift = 4; shift = 4;
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
dp++; dp++;
v = 0; v = 0;
} }
@ -141,7 +141,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
} }
if (shift != 4) if (shift != 4)
*dp = (png_byte)v; *dp = (png_byte)(v & 0xff);
break; break;
} }
@ -150,8 +150,9 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
break; break;
} }
row_info->bit_depth = (png_byte)bit_depth; row_info->bit_depth = (png_byte)(bit_depth & 0xff);
row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); row_info->pixel_depth =
(png_byte)((bit_depth * row_info->channels) & 0xff);
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
row_info->width); row_info->width);
} }
@ -422,7 +423,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = *(sp++); *(dp++) = *(sp++);
*/ */
sp+=3; dp = sp; sp+=3; dp = sp;
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
} }
} }
@ -445,8 +446,8 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = *(sp++); *(dp++) = *(sp++);
*/ */
sp+=6; dp = sp; sp+=6; dp = sp;
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
} }
} }
#endif /* WRITE_16BIT */ #endif /* WRITE_16BIT */
@ -464,7 +465,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
} }
} }
@ -483,8 +484,8 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(dp++) = *(sp++); *(dp++) = *(sp++);
*/ */
sp+=2; dp = sp; sp+=2; dp = sp;
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
*(dp++) = (png_byte)(255 - *(sp++)); *(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
} }
} }
#endif /* WRITE_16BIT */ #endif /* WRITE_16BIT */

78
pngwutil.c
View File

@ -278,10 +278,10 @@ optimize_cmf(png_bytep data, png_alloc_size_t data_size)
z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
data[0] = (png_byte)z_cmf; data[0] = (png_byte)(z_cmf & 0xff);
tmp = data[1] & 0xe0; tmp = data[1] & 0xe0;
tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
data[1] = (png_byte)tmp; data[1] = (png_byte)(tmp & 0xff);
} }
} }
} }
@ -871,18 +871,18 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
interlace_type=PNG_INTERLACE_NONE; interlace_type=PNG_INTERLACE_NONE;
#endif #endif
/* Save the relevent information */ /* Save the relevant information */
png_ptr->bit_depth = (png_byte)bit_depth; png_ptr->bit_depth = (png_byte)(bit_depth & 0xff);
png_ptr->color_type = (png_byte)color_type; png_ptr->color_type = (png_byte)(color_type & 0xff);
png_ptr->interlaced = (png_byte)interlace_type; png_ptr->interlaced = (png_byte)(interlace_type & 0xff);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
png_ptr->filter_type = (png_byte)filter_type; png_ptr->filter_type = (png_byte)(filter_type & 0xff);
#endif #endif
png_ptr->compression_type = (png_byte)compression_type; png_ptr->compression_type = (png_byte)(compression_type & 0xff);
png_ptr->width = width; png_ptr->width = width;
png_ptr->height = height; png_ptr->height = height;
png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); png_ptr->pixel_depth = (png_byte)((bit_depth * png_ptr->channels) & 0xff);
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
/* Set the usr info, so any transformations can modify it */ /* Set the usr info, so any transformations can modify it */
png_ptr->usr_width = png_ptr->width; png_ptr->usr_width = png_ptr->width;
@ -892,11 +892,11 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
/* Pack the header information into the buffer */ /* Pack the header information into the buffer */
png_save_uint_32(buf, width); png_save_uint_32(buf, width);
png_save_uint_32(buf + 4, height); png_save_uint_32(buf + 4, height);
buf[8] = (png_byte)bit_depth; buf[8] = (png_byte)(bit_depth & 0xff);
buf[9] = (png_byte)color_type; buf[9] = (png_byte)(color_type & 0xff);
buf[10] = (png_byte)compression_type; buf[10] = (png_byte)(compression_type & 0xff);
buf[11] = (png_byte)filter_type; buf[11] = (png_byte)(filter_type & 0xff);
buf[12] = (png_byte)interlace_type; buf[12] = (png_byte)(interlace_type & 0xff);
/* Write the chunk */ /* Write the chunk */
png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
@ -1181,7 +1181,7 @@ png_write_sRGB(png_structrp png_ptr, int srgb_intent)
png_warning(png_ptr, png_warning(png_ptr,
"Invalid sRGB rendering intent specified"); "Invalid sRGB rendering intent specified");
buf[0]=(png_byte)srgb_intent; buf[0]=(png_byte)(srgb_intent & 0xff);
png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
} }
#endif #endif
@ -1285,10 +1285,10 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
{ {
if (spalette->depth == 8) if (spalette->depth == 8)
{ {
entrybuf[0] = (png_byte)ep->red; entrybuf[0] = (png_byte)(ep->red & 0xff);
entrybuf[1] = (png_byte)ep->green; entrybuf[1] = (png_byte)(ep->green & 0xff);
entrybuf[2] = (png_byte)ep->blue; entrybuf[2] = (png_byte)(ep->blue & 0xff);
entrybuf[3] = (png_byte)ep->alpha; entrybuf[3] = (png_byte)(ep->alpha & 0xff);
png_save_uint_16(entrybuf + 4, ep->frequency); png_save_uint_16(entrybuf + 4, ep->frequency);
} }
@ -1309,10 +1309,10 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
{ {
if (spalette->depth == 8) if (spalette->depth == 8)
{ {
entrybuf[0] = (png_byte)ep[i].red; entrybuf[0] = (png_byte)(ep[i].red & 0xff);
entrybuf[1] = (png_byte)ep[i].green; entrybuf[1] = (png_byte)(ep[i].green & 0xff);
entrybuf[2] = (png_byte)ep[i].blue; entrybuf[2] = (png_byte)(ep[i].blue & 0xff);
entrybuf[3] = (png_byte)ep[i].alpha; entrybuf[3] = (png_byte)(ep[i].alpha & 0xff);
png_save_uint_16(entrybuf + 4, ep[i].frequency); png_save_uint_16(entrybuf + 4, ep[i].frequency);
} }
@ -1348,8 +1348,8 @@ png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
{ {
png_byte maxbits; png_byte maxbits;
maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : maxbits = color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
png_ptr->usr_bit_depth); (png_byte)(png_ptr->usr_bit_depth & 0xff);
if (sbit->red == 0 || sbit->red > maxbits || if (sbit->red == 0 || sbit->red > maxbits ||
sbit->green == 0 || sbit->green > maxbits || sbit->green == 0 || sbit->green > maxbits ||
@ -1786,7 +1786,7 @@ png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
png_save_int_32(buf, x_offset); png_save_int_32(buf, x_offset);
png_save_int_32(buf + 4, y_offset); png_save_int_32(buf + 4, y_offset);
buf[8] = (png_byte)unit_type; buf[8] = (png_byte)(unit_type & 0xff);
png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
} }
@ -1841,8 +1841,8 @@ png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
png_write_chunk_data(png_ptr, new_purpose, purpose_len); png_write_chunk_data(png_ptr, new_purpose, purpose_len);
png_save_int_32(buf, X0); png_save_int_32(buf, X0);
png_save_int_32(buf + 4, X1); png_save_int_32(buf + 4, X1);
buf[8] = (png_byte)type; buf[8] = (png_byte)(type & 0xff);
buf[9] = (png_byte)nparams; buf[9] = (png_byte)(nparams & 0xff);
png_write_chunk_data(png_ptr, buf, (png_size_t)10); png_write_chunk_data(png_ptr, buf, (png_size_t)10);
png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len); png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
@ -1877,7 +1877,7 @@ png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
return; return;
} }
buf[0] = (png_byte)unit; buf[0] = (png_byte)(unit & 0xff);
memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
@ -1902,7 +1902,7 @@ png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
png_save_uint_32(buf, x_pixels_per_unit); png_save_uint_32(buf, x_pixels_per_unit);
png_save_uint_32(buf + 4, y_pixels_per_unit); png_save_uint_32(buf + 4, y_pixels_per_unit);
buf[8] = (png_byte)unit_type; buf[8] = (png_byte)(unit_type & 0xff);
png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
} }
@ -1968,7 +1968,7 @@ png_write_start_row(png_structrp png_ptr)
/* 1.5.6: added to allow checking in the row write code. */ /* 1.5.6: added to allow checking in the row write code. */
png_ptr->transformed_pixel_depth = png_ptr->pixel_depth; png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth; png_ptr->maximum_pixel_depth = (png_byte)(usr_pixel_depth & 0xff);
/* Set up row buffer */ /* Set up row buffer */
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size); png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
@ -2180,7 +2180,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
if (shift == 0) if (shift == 0)
{ {
shift = 7; shift = 7;
*dp++ = (png_byte)d; *dp++ = (png_byte)(d & 0xff);
d = 0; d = 0;
} }
@ -2189,7 +2189,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
} }
if (shift != 7) if (shift != 7)
*dp = (png_byte)d; *dp = (png_byte)(d & 0xff);
break; break;
} }
@ -2218,7 +2218,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
if (shift == 0) if (shift == 0)
{ {
shift = 6; shift = 6;
*dp++ = (png_byte)d; *dp++ = (png_byte)(d & 0xff);
d = 0; d = 0;
} }
@ -2226,7 +2226,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
shift -= 2; shift -= 2;
} }
if (shift != 6) if (shift != 6)
*dp = (png_byte)d; *dp = (png_byte)(d & 0xff);
break; break;
} }
@ -2254,7 +2254,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
if (shift == 0) if (shift == 0)
{ {
shift = 4; shift = 4;
*dp++ = (png_byte)d; *dp++ = (png_byte)(d & 0xff);
d = 0; d = 0;
} }
@ -2262,7 +2262,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
shift -= 4; shift -= 4;
} }
if (shift != 4) if (shift != 4)
*dp = (png_byte)d; *dp = (png_byte)(d & 0xff);
break; break;
} }
@ -2688,8 +2688,8 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
for (lp = row_buf + 1; i < row_bytes; i++) for (lp = row_buf + 1; i < row_bytes; i++)
{ {
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) *dp++ =
& 0xff); (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
} }
best_row = png_ptr->avg_row; best_row = png_ptr->avg_row;
} }