From 7011a8cec3a4ca19e0a2ae593a5bf5a3de6e1129 Mon Sep 17 00:00:00 2001 From: Glenn Randers-Pehrson Date: Fri, 27 Feb 2015 18:53:44 -0600 Subject: [PATCH] [libpng16] Added "& 0xff" to things being typecast to "png_byte". --- png.c | 23 ++++--- png.h | 32 ++++----- pngget.c | 2 +- pngpread.c | 2 +- pngpriv.h | 13 ++-- pngread.c | 5 +- pngrtran.c | 195 +++++++++++++++++++++++++++-------------------------- pngrutil.c | 37 +++++----- pngtrans.c | 13 ++-- pngwrite.c | 51 +++++++------- pngwtran.c | 29 ++++---- pngwutil.c | 78 ++++++++++----------- 12 files changed, 249 insertions(+), 231 deletions(-) diff --git a/png.c b/png.c index 7b2a6ea17..bbd0ff213 100644 --- a/png.c +++ b/png.c @@ -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; } diff --git a/png.h b/png.h index 9a679f8c6..6ba4710ef 100644 --- a/png.h +++ b/png.h @@ -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 diff --git a/pngget.c b/pngget.c index 0a47f9784..eb402b42b 100644 --- a/pngget.c +++ b/pngget.c @@ -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 diff --git a/pngpread.c b/pngpread.c index 5282e9155..7afbe9779 100644 --- a/pngpread.c +++ b/pngpread.c @@ -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)) { diff --git a/pngpriv.h b/pngpriv.h index a986b1e16..a59ed6296 100644 --- a/pngpriv.h +++ b/pngpriv.h @@ -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! */ diff --git a/pngread.c b/pngread.c index c658a4692..f23fc7a91 100644 --- a/pngread.c +++ b/pngread.c @@ -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; diff --git a/pngrtran.c b/pngrtran.c index 49efb6d82..ada436efb 100644 --- a/pngrtran.c +++ b/pngrtran.c @@ -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; itrans_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); } diff --git a/pngrutil.c b/pngrutil.c index 39b795d6a..b18ddb8ca 100644 --- a/pngrutil.c +++ b/pngrutil.c @@ -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 diff --git a/pngtrans.c b/pngtrans.c index 56856b480..964d223b0 100644 --- a/pngtrans.c +++ b/pngtrans.c @@ -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 diff --git a/pngwrite.c b/pngwrite.c index f03aed2d9..d1c584b75 100644 --- a/pngwrite.c +++ b/pngwrite.c @@ -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 diff --git a/pngwtran.c b/pngwtran.c index 09562a787..b0e607752 100644 --- a/pngwtran.c +++ b/pngwtran.c @@ -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 */ diff --git a/pngwutil.c b/pngwutil.c index 579604302..3595944fe 100644 --- a/pngwutil.c +++ b/pngwutil.c @@ -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; }