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)
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
@ -772,13 +772,13 @@ png_get_copyright(png_const_structrp png_ptr)
#else
# ifdef __STDC__
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) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE;
# else
return "libpng version 1.6.17beta06 - February 25, 2015\
return "libpng version 1.6.17beta06 - February 28, 2015\
Copyright (c) 1998-2015 Glenn Randers-Pehrson\
Copyright (c) 1996-1997 Andreas Dilger\
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)
{
palette[i].red = (png_byte)v;
palette[i].green = (png_byte)v;
palette[i].blue = (png_byte)v;
palette[i].red = (png_byte)(v & 0xff);
palette[i].green = (png_byte)(v & 0xff);
palette[i].blue = (png_byte)(v & 0xff);
}
}
#endif
@ -3733,7 +3733,7 @@ png_exp8bit(png_fixed_point lg2)
* step.
*/
x -= x >> 8;
return (png_byte)((x + 0x7fffffU) >> 24);
return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff);
}
#ifdef PNG_16BIT_SUPPORTED
@ -3794,7 +3794,7 @@ png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
# endif
}
return (png_byte)value;
return (png_byte)(value & 0xff);
}
#ifdef PNG_16BIT_SUPPORTED
@ -4016,7 +4016,7 @@ png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
else
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
@ -4156,7 +4156,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
*
*/
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
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 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;
}

32
png.h
View File

@ -1,7 +1,7 @@
/* 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
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -11,7 +11,7 @@
* Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.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.
*
* Note about libpng version numbers:
@ -244,7 +244,7 @@
*
* 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
* distributed according to the same disclaimer and license as libpng-1.2.5
* with the following individual added to the list of Contributing Authors:
@ -356,7 +356,7 @@
* Y2K compliance in libpng:
* =========================
*
* February 25, 2015
* February 28, 2015
*
* Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration.
@ -426,7 +426,7 @@
/* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.6.17beta06"
#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_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_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
* libpng and the compression methods used by zlib. These functions are
* 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_LAST 3 /* Not a valid value */
#ifdef PNG_WRITE_SUPPORTED
/* Set the library compression level. Currently, valid values range from
* 0 - 9, corresponding directly to the zlib compression levels 0 - 9
* (0 - no compression, 9 - "maximal" compression). Note that tests have
@ -2667,26 +2667,28 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
* (png_uint_16)(alpha) \
+ (png_uint_16)(bg)*(png_uint_16)(255 \
- (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) \
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
* (png_uint_32)(alpha) \
+ (png_uint_32)(bg)*(65535 \
- (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 */
# define png_composite(composite, fg, alpha, bg) \
(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
127) / 255)
# define png_composite(composite, fg, alpha, bg) \
(composite) = \
(png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
127) / 255))
# define png_composite_16(composite, fg, alpha, bg) \
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
32767) / 65535)
(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)) + \
32767) / 65535))
#endif /* READ_COMPOSITE_NODIV */
#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_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

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]),
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))
{

13
pngpriv.h
View File

@ -741,15 +741,17 @@
* macro will fail on top-bit-set values because of the sign extension.
*/
#define PNG_CHUNK_FROM_STRING(s)\
PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])
PNG_U32(0xff & (s)[0], 0xff & (s)[1], 0xff & (s)[2], 0xff & (s)[3])
/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
* signed and the argument is a (char[]) This macro will fail miserably on
* systems where (char) is more than 8 bits.
*/
#define PNG_STRING_FROM_CHUNK(s,c)\
(void)(((char*)(s))[0]=(char)(((c)>>24)&0xFF), ((char*)(s))[1]=(char)(((c)>>16)&0xFF),\
((char*)(s))[2]=(char)(((c)>>8)&0xFF), ((char*)(s))[3]=(char)((c&0xFF)))
(void)(((char*)(s))[0]=(char)(((c)>>24) & 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. */
#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_byte, png_sRGB_delta, [512]);
#define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\
((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8))
#define PNG_sRGB_FROM_LINEAR(linear) \
((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
* encoded value with maximum error 0.646365. Note that the input is not a
* 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. */
#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
png_image_read_colormap(png_voidp argument)
@ -3025,7 +3025,8 @@ png_image_read_and_map(png_voidp argument)
*outrow = gray;
else
*outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1);
*outrow =
(png_byte)(0xff & (PNG_CMAP_TRANS_BACKGROUND+1));
}
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_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)
png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
else
@ -1176,8 +1176,8 @@ png_init_palette_transformations(png_structrp png_ptr)
int i, istop = png_ptr->num_trans;
for (i=0; i<istop; i++)
png_ptr->trans_alpha[i] = (png_byte)(255 -
png_ptr->trans_alpha[i]);
png_ptr->trans_alpha[i] = (png_byte)(0xff & (255 -
png_ptr->trans_alpha[i]));
}
}
#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
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
info_ptr->color_type = (png_byte)(info_ptr->color_type |
PNG_COLOR_MASK_COLOR);
info_ptr->color_type = (png_byte)(0xff & (info_ptr->color_type |
PNG_COLOR_MASK_COLOR));
#endif
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
info_ptr->color_type = (png_byte)(info_ptr->color_type &
~PNG_COLOR_MASK_COLOR);
info_ptr->color_type = (png_byte)(0xff & (info_ptr->color_type &
~PNG_COLOR_MASK_COLOR));
#endif
#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
if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
{
info_ptr->color_type = (png_byte)(info_ptr->color_type &
~PNG_COLOR_MASK_ALPHA);
info_ptr->color_type = (png_byte)(0xff & (info_ptr->color_type &
~PNG_COLOR_MASK_ALPHA));
info_ptr->num_trans = 0;
}
#endif
@ -2106,8 +2106,8 @@ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
}
#endif
info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
info_ptr->bit_depth);
info_ptr->pixel_depth = (png_byte)(0xff & (info_ptr->channels *
info_ptr->bit_depth));
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;
}
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;
}
}
@ -2356,8 +2356,8 @@ png_do_unshift(png_row_infop row_info, png_bytep row,
value >>= shift[channel];
if (++channel >= channels)
channel = 0;
*bp++ = (png_byte)(value >> 8);
*bp++ = (png_byte)(value & 0xff);
*bp++ = (png_byte)(0xff & (value >> 8));
*bp++ = (png_byte)(0xff & value);
}
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->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;
}
}
@ -2448,7 +2448,7 @@ png_do_chop(png_row_infop row_info, png_bytep row)
}
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;
}
}
@ -2570,7 +2570,7 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0; i < row_width; i++)
{
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(0xff & (255 - *(--sp)));
/* This does nothing:
*(--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++)
{
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(0xff & (255 - *(--sp)));
*(--dp) = (png_byte)(0xff & (255 - *(--sp)));
/* This does nothing:
*(--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++)
{
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(0xff & (255 - *(--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++)
{
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(255 - *(--sp));
*(--dp) = (png_byte)(0xff & (255 - *(--sp)));
*(--dp) = (png_byte)(0xff & (255 - *(--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->pixel_depth = (png_byte)(row_info->channels *
row_info->bit_depth);
row_info->pixel_depth = (png_byte)(0xff & (row_info->channels *
row_info->bit_depth));
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
* 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
@ -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->color_type = (png_byte)(row_info->color_type &
~PNG_COLOR_MASK_COLOR);
row_info->pixel_depth = (png_byte)(row_info->channels *
row_info->bit_depth);
row_info->channels = (png_byte)(0xff & (row_info->channels - 2));
row_info->color_type = (png_byte)(0xff & (row_info->color_type &
~PNG_COLOR_MASK_COLOR));
row_info->pixel_depth = (png_byte)(0xff & (row_info->channels *
row_info->bit_depth));
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
}
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)
{
/* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.gray >> 8)
& 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.gray
& 0xff);
*sp = (png_byte)(0xff &
(png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(0xff &
png_ptr->background.gray);
}
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)
{
*sp = (png_byte)((png_ptr->background.gray >> 8)
& 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.gray
& 0xff);
*sp = (png_byte)(0xff &
(png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(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)
{
/* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
& 0xff);
*(sp + 3) = (png_byte)(png_ptr->background.green
& 0xff);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
& 0xff);
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
*sp = (png_byte)(0xff &
(png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(0xff &
png_ptr->background.red);
*(sp + 2) = (png_byte)(0xff &
(png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(0xff &
png_ptr->background.green);
*(sp + 4) = (png_byte)(0xff &
(png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(0xff &
png_ptr->background.blue);
}
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 &&
b == png_ptr->trans_color.blue)
{
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
& 0xff);
*(sp + 3) = (png_byte)(png_ptr->background.green
& 0xff);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
& 0xff);
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
*sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(0xff & png_ptr->background.red);
*(sp + 2) = (png_byte)(0xff &
(png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(0xff &
png_ptr->background.green);
*(sp + 4) = (png_byte)(0xff &
(png_ptr->background.blue >> 8));
*(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)
{
/* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.gray >> 8)
& 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
*sp = (png_byte)(0xff &
(png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(0xff & png_ptr->background.gray);
}
else
@ -3686,9 +3690,9 @@ png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
if (a == 0)
{
*sp = (png_byte)((png_ptr->background.gray >> 8)
& 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
*sp = (png_byte)(0xff &
(png_ptr->background.gray >> 8));
*(sp + 1) = (png_byte)(0xff & png_ptr->background.gray);
}
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)
{
/* Background is already in screen gamma */
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
& 0xff);
*(sp + 3) = (png_byte)(png_ptr->background.green
& 0xff);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
& 0xff);
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
*sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(0xff & png_ptr->background.red );
*(sp + 2) = (png_byte)(0xff &
(png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(0xff &
png_ptr->background.green);
*(sp + 4) = (png_byte)(0xff &
(png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(0xff & png_ptr->background.blue);
}
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];
png_composite_16(w, v, a, png_ptr->background_1.red);
if (optimize == 0)
w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >>
8];
w = gamma_16_from_1[((w & 0xff) >>
gamma_shift)][w >> 8];
*sp = (png_byte)((w >> 8) & 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)
{
*sp = (png_byte)((png_ptr->background.red >> 8) & 0xff);
*(sp + 1) = (png_byte)(png_ptr->background.red & 0xff);
*(sp + 2) = (png_byte)((png_ptr->background.green >> 8)
& 0xff);
*(sp + 3) = (png_byte)(png_ptr->background.green
& 0xff);
*(sp + 4) = (png_byte)((png_ptr->background.blue >> 8)
& 0xff);
*(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff);
*sp = (png_byte)(0xff & (png_ptr->background.red >> 8));
*(sp + 1) = (png_byte)(0xff & png_ptr->background.red);
*(sp + 2) = (png_byte)(0xff &
(png_ptr->background.green >> 8));
*(sp + 3) = (png_byte)(0xff &
png_ptr->background.green);
*(sp + 4) = (png_byte)(0xff &
(png_ptr->background.blue >> 8));
*(sp + 5) = (png_byte)(0xff &
png_ptr->background.blue & 0xff);
}
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 d = *sp & 0x03;
*sp = (png_byte)(
((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|
*sp = (png_byte)(0xff &
(((((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[(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++;
}
}
@ -4400,8 +4406,8 @@ png_do_expand(png_row_infop row_info, png_bytep row,
for (i = 0; i < row_width; i++)
{
value = (*sp >> shift) & 0x03;
*dp = (png_byte)(value | (value << 2) | (value << 4) |
(value << 6));
*dp = (png_byte)(0xff & (value | (value << 2) |
(value << 4) | (value << 6)));
if (shift == 6)
{
shift = 0;
@ -4425,7 +4431,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
for (i = 0; i < row_width; i++)
{
value = (*sp >> shift) & 0x0f;
*dp = (png_byte)(value | (value << 4));
*dp = (png_byte)(0xff & (value | (value << 4)));
if (shift == 4)
{
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->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_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->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);
}
}
@ -4596,7 +4603,7 @@ png_do_expand_16(png_row_infop row_info, png_bytep row)
row_info->rowbytes *= 2;
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
@ -4984,8 +4991,8 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
if (png_ptr->user_transform_channels != 0)
row_info->channels = png_ptr->user_transform_channels;
#endif
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);
}

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 */
png_ptr->width = width;
png_ptr->height = height;
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->interlaced = (png_byte)interlace_type;
png_ptr->color_type = (png_byte)color_type;
png_ptr->bit_depth = (png_byte)(bit_depth & 0xff);
png_ptr->interlaced = (png_byte)(interlace_type & 0xff);
png_ptr->color_type = (png_byte)(color_type & 0xff);
#ifdef PNG_MNG_FEATURES_SUPPORTED
png_ptr->filter_type = (png_byte)filter_type;
png_ptr->filter_type = (png_byte)(filter_type & 0xff);
#endif
png_ptr->compression_type = (png_byte)compression_type;
png_ptr->compression_type = (png_byte)(compression_type & 0xff);
/* Find number of channels */
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 */
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_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
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 */
png_ptr->unknown_chunk.size = (png_size_t)length/*SAFE*/;
/* 'mode' is a flag array, only the bottom four bits matter here */
png_ptr->unknown_chunk.location = (png_byte)png_ptr->mode/*SAFE*/;
png_ptr->unknown_chunk.location =
(png_byte)(0xff & png_ptr->mode/*SAFE*/);
if (length == 0)
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 != 0xff)
*dp = (png_byte)((*dp & ~m) | (*sp & m));
*dp = (png_byte)(((*dp & ~m) | (*sp & m)) & 0xff);
else
*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. */
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
@ -3774,16 +3777,14 @@ png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
for (i = 0; i < bpp; i++)
{
*rp = (png_byte)(((int)(*rp) +
((int)(*pp++) / 2 )) & 0xff);
*rp = (png_byte)(((int)(*rp) + ((int)(*pp++) / 2 )) & 0xff);
rp++;
}
for (i = 0; i < istop; i++)
{
*rp = (png_byte)(((int)(*rp) +
(int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
*rp = (png_byte)(((int)(*rp) + (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
rp++;
}
@ -3799,7 +3800,7 @@ png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
/* First pixel/byte */
c = *prev_row++;
a = *row + c;
*row++ = (png_byte)a;
*row++ = (png_byte)(a & 0xff);
/* Remainder */
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;
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)
{
int a = *row + *prev_row++;
*row++ = (png_byte)(a&0xFF);
*row++ = (png_byte)(a & 0xff);
}
/* 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;
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
* 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 */
/* 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++)
{
*rp = (png_byte)(~(*rp));
*rp = (png_byte)((~(*rp)) & 0xff);
rp++;
}
}
@ -287,7 +287,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
for (i = 0; i < istop; i += 2)
{
*rp = (png_byte)(~(*rp));
*rp = (png_byte)((~(*rp)) & 0xff);
rp += 2;
}
}
@ -302,8 +302,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
for (i = 0; i < istop; i += 4)
{
*rp = (png_byte)(~(*rp));
*(rp + 1) = (png_byte)(~(*(rp + 1)));
*rp = (png_byte)((~(*rp)) & 0xff);
*(rp + 1) = (png_byte)((~(*(rp + 1))) & 0xff);
rp += 4;
}
}
@ -803,8 +803,9 @@ png_set_user_transform_info(png_structrp png_ptr, png_voidp
#endif
png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr->user_transform_depth = (png_byte)user_transform_depth;
png_ptr->user_transform_channels = (png_byte)user_transform_channels;
png_ptr->user_transform_depth = (png_byte)(user_transform_depth & 0xff);
png_ptr->user_transform_channels =
(png_byte)(user_transform_channels & 0xff);
}
#endif

51
pngwrite.c
View File

@ -219,7 +219,7 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
int j;
for (j = 0; j<(int)info_ptr->num_trans; j++)
info_ptr->trans_alpha[j] =
(png_byte)(255 - info_ptr->trans_alpha[j]);
(png_byte)((255 - info_ptr->trans_alpha[j]) & 0xff);
}
#endif
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");
ptime->year = (png_uint_16)(1900 + ttime->tm_year);
ptime->month = (png_byte)(ttime->tm_mon + 1);
ptime->day = (png_byte)ttime->tm_mday;
ptime->hour = (png_byte)ttime->tm_hour;
ptime->minute = (png_byte)ttime->tm_min;
ptime->second = (png_byte)ttime->tm_sec;
ptime->month = (png_byte)((ttime->tm_mon + 1) & 0xff);
ptime->day = (png_byte)(ttime->tm_mday & 0xff);
ptime->hour = (png_byte)(ttime->tm_hour & 0xff);
ptime->minute = (png_byte)(ttime->tm_min & 0xff);
ptime->second = (png_byte)(ttime->tm_sec & 0xff);
}
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.channels = png_ptr->usr_channels;
row_info.bit_depth = png_ptr->usr_bit_depth;
row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
row_info.pixel_depth =
(png_byte)(0xff & (row_info.bit_depth * row_info.channels));
row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
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;
default:
png_ptr->do_filter = (png_byte)filters; break;
png_ptr->do_filter = (png_byte)(filters & 0xff); break;
#else
default:
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)
{
png_warning(png_ptr, "Can't add Up filter after starting");
png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
~PNG_FILTER_UP);
png_ptr->do_filter =
(png_byte)((png_ptr->do_filter & ~PNG_FILTER_UP) & 0xff);
}
else
@ -1088,8 +1089,8 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->prev_row == NULL)
{
png_warning(png_ptr, "Can't add Average filter after starting");
png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
~PNG_FILTER_AVG);
png_ptr->do_filter =
(png_byte)((png_ptr->do_filter & ~PNG_FILTER_AVG) & 0xff);
}
else
@ -1106,7 +1107,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->prev_row == NULL)
{
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
@ -1210,7 +1211,7 @@ png_init_filter_heuristics(png_structrp png_ptr, int heuristic_method,
}
/* 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
@ -1890,7 +1891,7 @@ png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
component *= 255;
/* Convert the component to sRGB. */
return (png_byte)PNG_sRGB_FROM_LINEAR(component);
return (png_byte)(PNG_sRGB_FROM_LINEAR(component) & 0xff);
}
else
@ -1939,7 +1940,7 @@ png_write_image_8bit(png_voidp argument)
while (out_ptr < row_end)
{
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;
int c;
@ -1982,7 +1983,7 @@ png_write_image_8bit(png_voidp argument)
png_uint_32 component = *in_ptr++;
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);
@ -2041,23 +2042,23 @@ png_image_set_PLTE(png_image_write_control *display)
{
if (channels >= 3) /* RGB */
{
palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[(2 ^ bgr)]);
palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[1]);
palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[bgr]);
palette[i].blue = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[(2 ^ bgr)]));
palette[i].green = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[1]));
palette[i].red = (png_byte)(0xff & PNG_sRGB_FROM_LINEAR(255 *
entry[bgr]));
}
else /* Gray */
palette[i].blue = palette[i].red = palette[i].green =
(png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
(png_byte)(PNG_sRGB_FROM_LINEAR((255 * *entry)) & 0xff);
}
else /* alpha */
{
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;
/* 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
{
mask = 0x80;
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
dp++;
v = 0;
}
}
if (mask != 0x80)
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
break;
}
@ -90,7 +90,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
if (shift == 0)
{
shift = 6;
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
dp++;
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)
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
break;
}
@ -129,7 +129,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
if (shift == 0)
{
shift = 4;
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
dp++;
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)
*dp = (png_byte)v;
*dp = (png_byte)(v & 0xff);
break;
}
@ -150,8 +150,9 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
break;
}
row_info->bit_depth = (png_byte)bit_depth;
row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
row_info->bit_depth = (png_byte)(bit_depth & 0xff);
row_info->pixel_depth =
(png_byte)((bit_depth * row_info->channels) & 0xff);
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
row_info->width);
}
@ -422,7 +423,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
*(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++);
*/
sp+=6; dp = sp;
*(dp++) = (png_byte)(255 - *(sp++));
*(dp++) = (png_byte)(255 - *(sp++));
*(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
*(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
}
}
#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++)
{
*(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++);
*/
sp+=2; dp = sp;
*(dp++) = (png_byte)(255 - *(sp++));
*(dp++) = (png_byte)(255 - *(sp++));
*(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
*(dp++) = (png_byte)((255 - *(sp++)) & 0xff);
}
}
#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);
data[0] = (png_byte)z_cmf;
data[0] = (png_byte)(z_cmf & 0xff);
tmp = data[1] & 0xe0;
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;
#endif
/* Save the relevent information */
png_ptr->bit_depth = (png_byte)bit_depth;
png_ptr->color_type = (png_byte)color_type;
png_ptr->interlaced = (png_byte)interlace_type;
/* Save the relevant information */
png_ptr->bit_depth = (png_byte)(bit_depth & 0xff);
png_ptr->color_type = (png_byte)(color_type & 0xff);
png_ptr->interlaced = (png_byte)(interlace_type & 0xff);
#ifdef PNG_MNG_FEATURES_SUPPORTED
png_ptr->filter_type = (png_byte)filter_type;
png_ptr->filter_type = (png_byte)(filter_type & 0xff);
#endif
png_ptr->compression_type = (png_byte)compression_type;
png_ptr->compression_type = (png_byte)(compression_type & 0xff);
png_ptr->width = width;
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);
/* Set the usr info, so any transformations can modify it */
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 */
png_save_uint_32(buf, width);
png_save_uint_32(buf + 4, height);
buf[8] = (png_byte)bit_depth;
buf[9] = (png_byte)color_type;
buf[10] = (png_byte)compression_type;
buf[11] = (png_byte)filter_type;
buf[12] = (png_byte)interlace_type;
buf[8] = (png_byte)(bit_depth & 0xff);
buf[9] = (png_byte)(color_type & 0xff);
buf[10] = (png_byte)(compression_type & 0xff);
buf[11] = (png_byte)(filter_type & 0xff);
buf[12] = (png_byte)(interlace_type & 0xff);
/* Write the chunk */
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,
"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);
}
#endif
@ -1285,10 +1285,10 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
{
if (spalette->depth == 8)
{
entrybuf[0] = (png_byte)ep->red;
entrybuf[1] = (png_byte)ep->green;
entrybuf[2] = (png_byte)ep->blue;
entrybuf[3] = (png_byte)ep->alpha;
entrybuf[0] = (png_byte)(ep->red & 0xff);
entrybuf[1] = (png_byte)(ep->green & 0xff);
entrybuf[2] = (png_byte)(ep->blue & 0xff);
entrybuf[3] = (png_byte)(ep->alpha & 0xff);
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)
{
entrybuf[0] = (png_byte)ep[i].red;
entrybuf[1] = (png_byte)ep[i].green;
entrybuf[2] = (png_byte)ep[i].blue;
entrybuf[3] = (png_byte)ep[i].alpha;
entrybuf[0] = (png_byte)(ep[i].red & 0xff);
entrybuf[1] = (png_byte)(ep[i].green & 0xff);
entrybuf[2] = (png_byte)(ep[i].blue & 0xff);
entrybuf[3] = (png_byte)(ep[i].alpha & 0xff);
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;
maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
png_ptr->usr_bit_depth);
maxbits = color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
(png_byte)(png_ptr->usr_bit_depth & 0xff);
if (sbit->red == 0 || sbit->red > 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 + 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);
}
@ -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_save_int_32(buf, X0);
png_save_int_32(buf + 4, X1);
buf[8] = (png_byte)type;
buf[9] = (png_byte)nparams;
buf[8] = (png_byte)(type & 0xff);
buf[9] = (png_byte)(nparams & 0xff);
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);
@ -1877,7 +1877,7 @@ png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
return;
}
buf[0] = (png_byte)unit;
buf[0] = (png_byte)(unit & 0xff);
memcpy(buf + 1, width, wlen + 1); /* 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 + 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);
}
@ -1968,7 +1968,7 @@ png_write_start_row(png_structrp png_ptr)
/* 1.5.6: added to allow checking in the row write code. */
png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
png_ptr->maximum_pixel_depth = (png_byte)(usr_pixel_depth & 0xff);
/* Set up row buffer */
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)
{
shift = 7;
*dp++ = (png_byte)d;
*dp++ = (png_byte)(d & 0xff);
d = 0;
}
@ -2189,7 +2189,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
}
if (shift != 7)
*dp = (png_byte)d;
*dp = (png_byte)(d & 0xff);
break;
}
@ -2218,7 +2218,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
if (shift == 0)
{
shift = 6;
*dp++ = (png_byte)d;
*dp++ = (png_byte)(d & 0xff);
d = 0;
}
@ -2226,7 +2226,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
shift -= 2;
}
if (shift != 6)
*dp = (png_byte)d;
*dp = (png_byte)(d & 0xff);
break;
}
@ -2254,7 +2254,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
if (shift == 0)
{
shift = 4;
*dp++ = (png_byte)d;
*dp++ = (png_byte)(d & 0xff);
d = 0;
}
@ -2262,7 +2262,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
shift -= 4;
}
if (shift != 4)
*dp = (png_byte)d;
*dp = (png_byte)(d & 0xff);
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++)
{
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
& 0xff);
*dp++ =
(png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
}
best_row = png_ptr->avg_row;
}