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

[devel] Eliminate more GCC shadow warnings

Browse Source
This commit is contained in:
John Bowler 2011-01-16 19:32:22 -06:00 committed by Glenn Randers-Pehrson
parent 1408c2afeb
commit 168a433352
7 changed files with 80 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ANNOUNCE
View File

@ -61,7 +61,7 @@ Version 1.5.1beta05 [January 16, 2011]
Version 1.5.1beta06 [January 16, 2011]
Prevent png_push_crc_skip() from hanging while reading an unknown chunk
or an over-large compressed zTXT chunk with the progressive reader.
or an over-large compressed zTXt chunk with the progressive reader.
Send comments/corrections/commendations to png-mng-implement at lists.sf.net:
(subscription required; visit

2
CHANGES
View File

@ -3177,7 +3177,7 @@ Version 1.5.1beta05 [January 16, 2011]
Version 1.5.1beta06 [January 16, 2011]
Prevent png_push_crc_skip() from hanging while reading an unknown chunk
or an over-large compressed zTXT chunk with the progressive reader.
or an over-large compressed zTXt chunk with the progressive reader.
Send comments/corrections/commendations to png-mng-implement at lists.sf.net
(subscription required; visit

48
png.c
View File

@ -1792,7 +1792,7 @@ png_8bit_l2[128] =
static png_int_32
png_log8bit(unsigned int x)
{
unsigned int log = 0;
unsigned int lg2 = 0;
/* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
* because the log is actually negate that means adding 1. The final
* returned value thus has the range 0 (for 255 input) to 7.994 (for 1
@ -1803,16 +1803,16 @@ png_log8bit(unsigned int x)
return 0xffffffff;
if ((x & 0xf0) == 0)
log = 4, x <<= 4;
lg2 = 4, x <<= 4;
if ((x & 0xc0) == 0)
log += 2, x <<= 2;
lg2 += 2, x <<= 2;
if ((x & 0x80) == 0)
log += 1, x <<= 1;
lg2 += 1, x <<= 1;
/* result is at most 19 bits, so this cast is safe: */
return (png_int_32)((log << 16) + ((png_8bit_l2[x-128]+32768)>>16));
return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
}
/* The above gives exact (to 16 binary places) log2 values for 8 bit images,
@ -1848,29 +1848,29 @@ png_log8bit(unsigned int x)
static png_int_32
png_log16bit(png_uint_32 x)
{
unsigned int log = 0;
unsigned int lg2 = 0;
/* As above, but now the input has 16 bits. */
if ((x &= 0xffff) == 0)
return 0xffffffff;
if ((x & 0xff00) == 0)
log = 8, x <<= 8;
lg2 = 8, x <<= 8;
if ((x & 0xf000) == 0)
log += 4, x <<= 4;
lg2 += 4, x <<= 4;
if ((x & 0xc000) == 0)
log += 2, x <<= 2;
lg2 += 2, x <<= 2;
if ((x & 0x8000) == 0)
log += 1, x <<= 1;
lg2 += 1, x <<= 1;
/* Calculate the base logarithm from the top 8 bits as a 28 bit fractional
* value.
*/
log <<= 28;
log += (png_8bit_l2[(x>>8)-128]+8) >> 4;
lg2 <<= 28;
lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
/* Now we need to interpolate the factor, this requires a division by the top
* 8 bits. Do this with maximum precision.
@ -1881,19 +1881,19 @@ png_log16bit(png_uint_32 x)
* the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
* 16 bits to interpolate to get the low bits of the result. Round the
* answer. Note that the end point values are scaled by 64 to retain overall
* precision and that 'log' is current scaled by an extra 12 bits, so adjust
* precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
* the overall scaling by 6-12. Round at every step.
*/
x -= 1U << 24;
if (x <= 65536U) /* <= '257' */
log += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
else
log -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
/* Safe, because the result can't have more than 20 bits: */
return (png_int_32)((log + 2048) >> 12);
return (png_int_32)((lg2 + 2048) >> 12);
}
/* The 'exp()' case must invert the above, taking a 20 bit fixed point
@ -1988,10 +1988,10 @@ png_exp(png_fixed_point x)
}
static png_byte
png_exp8bit(png_fixed_point log)
png_exp8bit(png_fixed_point lg2)
{
/* Get a 32 bit value: */
png_uint_32 x = png_exp(log);
png_uint_32 x = png_exp(lg2);
/* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the
* second, rounding, step can't overflow because of the first, subtraction,
@ -2002,10 +2002,10 @@ png_exp8bit(png_fixed_point log)
}
static png_uint_16
png_exp16bit(png_fixed_point log)
png_exp16bit(png_fixed_point lg2)
{
/* Get a 32 bit value: */
png_uint_32 x = png_exp(log);
png_uint_32 x = png_exp(lg2);
/* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */
x -= x >> 16;
@ -2022,10 +2022,10 @@ png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);
return (png_byte)r;
# else
png_int_32 log = png_log8bit(value);
png_int_32 lg2 = png_log8bit(value);
png_fixed_point res;
if (png_muldiv(&res, gamma_val, log, PNG_FP_1))
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
return png_exp8bit(res);
/* Overflow. */
@ -2045,10 +2045,10 @@ png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);
return (png_uint_16)r;
# else
png_int_32 log = png_log16bit(value);
png_int_32 lg2 = png_log16bit(value);
png_fixed_point res;
if (png_muldiv(&res, gamma_val, log, PNG_FP_1))
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))
return png_exp16bit(res);
/* Overflow. */

8
pngpread.c
View File

@ -585,7 +585,7 @@ png_push_crc_finish(png_structp png_ptr)
png_size_t save_size = png_ptr->save_buffer_size;
png_uint_32 skip_length = png_ptr->skip_length;
/* We want the smaller of 'skip_length' and 'current_buffer_size', but
/* We want the smaller of 'skip_length' and 'save_buffer_size', but
* they are of different types and we don't know which variable has the
* fewest bits. Carefully select the smaller and cast it to the type of
* the larger - this cannot overflow. Do not cast in the following test
@ -609,10 +609,8 @@ png_push_crc_finish(png_structp png_ptr)
png_size_t save_size = png_ptr->current_buffer_size;
png_uint_32 skip_length = png_ptr->skip_length;
/* We want the smaller of 'skip_length' and 'current_buffer_size', but
* they are of different types and we don't know which variable has the
* fewest bits. Carefully select the smaller and cast it to the type of
* the larger - this cannot overflow.
/* We want the smaller of 'skip_length' and 'current_buffer_size', here,
* the same problem exists as above and the same solution.
*/
if (skip_length < save_size)
save_size = (png_size_t)skip_length;

16
pngrutil.c
View File

@ -1962,7 +1962,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
void /* PRIVATE */
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_size_t slength, index;
png_size_t slength, i;
int state;
png_debug(1, "in png_handle_sCAL");
@ -2019,21 +2019,21 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
/* Validate the ASCII numbers, need two ASCII numbers separated by
* a '\0' and they need to fit exactly in the chunk data.
*/
index = 0;
i = 0;
state = 0;
if (png_ptr->chunkdata[1] == 45 /* negative width */ ||
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &index) ||
index >= slength || png_ptr->chunkdata[index++] != 0)
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
i >= slength || png_ptr->chunkdata[i++] != 0)
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format");
else
{
png_size_t heighti = index;
png_size_t heighti = i;
if (png_ptr->chunkdata[index] == 45 /* negative height */ ||
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &index) ||
index != slength)
if (png_ptr->chunkdata[i] == 45 /* negative height */ ||
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) ||
i != slength)
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format");
else

8
pngset.c
View File

@ -87,7 +87,7 @@ png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
#ifdef PNG_gAMA_SUPPORTED
void PNGFAPI
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
gamma)
file_gamma)
{
png_debug1(1, "in %s storage function", "gAMA");
@ -98,15 +98,15 @@ png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
* wrong, therefore storing them (and setting PNG_INFO_gAMA)
* must be wrong too.
*/
if (gamma > (png_fixed_point)PNG_UINT_31_MAX)
if (file_gamma > (png_fixed_point)PNG_UINT_31_MAX)
png_warning(png_ptr, "Gamma too large, ignored");
else if (gamma <= 0)
else if (file_gamma <= 0)
png_warning(png_ptr, "Negative or zero gamma ignored");
else
{
info_ptr->gamma = gamma;
info_ptr->gamma = file_gamma;
info_ptr->valid |= PNG_INFO_gAMA;
}
}

71
pngvalid.c
View File

@ -238,28 +238,28 @@ next_format(png_bytep colour_type, png_bytep bit_depth)
static unsigned int
sample(png_const_bytep row, png_byte colour_type, png_byte bit_depth,
png_uint_32 x, unsigned int sample)
png_uint_32 x, unsigned int sample_index)
{
png_uint_32 index, result;
png_uint_32 bit_index, result;
/* Find a sample index for the desired sample: */
x *= bit_depth;
index = x;
bit_index = x;
if ((colour_type & 1) == 0) /* !palette */
{
if (colour_type & 2)
index *= 3;
bit_index *= 3;
if (colour_type & 4)
index += x; /* Alpha channel */
bit_index += x; /* Alpha channel */
if (colour_type & (2+4))
index += sample * bit_depth; /* Multiple channels: select one */
bit_index += sample_index * bit_depth; /* Multiple channels: select one */
}
/* Return the sample from the row as an integer. */
row += index >> 3;
row += bit_index >> 3;
result = *row;
if (bit_depth == 8)
@ -269,8 +269,8 @@ sample(png_const_bytep row, png_byte colour_type, png_byte bit_depth,
return (result << 8) + *++row;
/* Less than 8 bits per sample. */
index &= 7;
return (result >> (8-index-bit_depth)) & ((1U<<bit_depth)-1);
bit_index &= 7;
return (result >> (8-bit_index-bit_depth)) & ((1U<<bit_depth)-1);
}
/* Copy a single pixel, of a given size, from one buffer to another -
@ -2493,6 +2493,8 @@ make_error(png_store* volatile ps, png_byte PNG_CONST colour_type,
/* Time for a few errors, these are in various optional chunks, the
* standard tests test the standard chunks pretty well.
*/
# define exception__prev exception_prev_1
# define exception__env exception_env_1
Try
{
/* Expect this to throw: */
@ -2516,6 +2518,8 @@ make_error(png_store* volatile ps, png_byte PNG_CONST colour_type,
Catch (fault)
ps = fault; /* expected exit, make sure ps is not clobbered */
#undef exception__prev
#undef exception__env
/* And clear these flags */
ps->expect_error = 0;
@ -3236,7 +3240,7 @@ gamma_modify(png_modifier *pm, png_modification *me, int add)
}
static void
gamma_modification_init(gamma_modification *me, png_modifier *pm, double gamma)
gamma_modification_init(gamma_modification *me, png_modifier *pm, double gammad)
{
double g;
@ -3244,7 +3248,7 @@ gamma_modification_init(gamma_modification *me, png_modifier *pm, double gamma)
me->this.chunk = CHUNK_gAMA;
me->this.modify_fn = gamma_modify;
me->this.add = CHUNK_PLTE;
g = floor(gamma * 100000 + .5);
g = floor(gammad * 100000 + .5);
me->gamma = (png_fixed_point)g;
me->this.next = pm->modifications;
pm->modifications = &me->this;
@ -3501,7 +3505,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
PNG_CONST unsigned int samples_per_pixel = (out_ct & 2U) ? 3U : 1U;
PNG_CONST double gamma = 1/(file_gamma*screen_gamma); /* Overall */
PNG_CONST double gamma_correction = 1/(file_gamma*screen_gamma);/* Overall */
double maxerrout = 0, maxerrabs = 0, maxerrpc = 0;
png_uint_32 y;
@ -3527,7 +3531,8 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
PNG_CONST unsigned int
isbit = id >> (in_bd-sbit);
double i, sample, encoded_sample, output, encoded_error, error;
double i, input_sample, encoded_sample, output;
double encoded_error, error;
double es_lo, es_hi;
/* First check on the 'perfect' result obtained from the
@ -3546,7 +3551,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
* value (nevertheless the error is still recorded - it's
* interesting ;-)
*/
encoded_sample = pow(i, gamma) * outmax;
encoded_sample = pow(i, gamma_correction) * outmax;
encoded_error = fabs(od-encoded_sample);
if (encoded_error > maxerrout)
@ -3564,7 +3569,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
* know what it is - so assume the unencoded value is
* perceptually linear.
*/
sample = pow(i, 1/file_gamma); /* In range 0..1 */
input_sample = pow(i, 1/file_gamma); /* In range 0..1 */
output = od;
output /= outmax;
output = pow(output, screen_gamma);
@ -3572,7 +3577,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
/* Now we have the numbers for real errors, both absolute
* values as as a percentage of the correct value (output):
*/
error = fabs(sample-output);
error = fabs(input_sample-output);
if (error > maxerrabs)
maxerrabs = error;
@ -3581,10 +3586,10 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
* quantization to dominate the percentage errors for low
* output sample values:
*/
if (sample*maxpc > .5+maxabs)
if (input_sample*maxpc > .5+maxabs)
{
double pcerr = error/sample;
if (pcerr > maxerrpc) maxerrpc = pcerr;
double percentage_error = error/input_sample;
if (percentage_error > maxerrpc) maxerrpc = percentage_error;
}
/* Now calculate the digitization limits for
@ -3596,16 +3601,17 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
* range 0..1:
*/
{
double tmp = sample * maxpc;
double tmp = input_sample * maxpc;
if (tmp < maxabs) tmp = maxabs;
/* Low bound - the minimum of the three: */
es_lo = encoded_sample - maxout;
if (es_lo > 0 && sample-tmp > 0)
if (es_lo > 0 && input_sample-tmp > 0)
{
double l = outmax * pow(sample-tmp, 1/screen_gamma);
if (l < es_lo) es_lo = l;
double low_value = outmax * pow(input_sample-tmp,
1/screen_gamma);
if (low_value < es_lo) es_lo = low_value;
}
else
@ -3613,10 +3619,11 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
es_hi = encoded_sample + maxout;
if (es_hi < outmax && sample+tmp < 1)
if (es_hi < outmax && input_sample+tmp < 1)
{
double h = outmax * pow(sample+tmp, 1/screen_gamma);
if (h > es_hi) es_hi = h;
double high_value = outmax * pow(input_sample+tmp,
1/screen_gamma);
if (high_value > es_hi) es_hi = high_value;
}
else
@ -3645,7 +3652,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
if (tmp > 0)
{
is_lo = outmax * pow(tmp, gamma) - maxout;
is_lo = outmax * pow(tmp, gamma_correction) - maxout;
if (is_lo < 0) is_lo = 0;
}
@ -3656,7 +3663,7 @@ gamma_image_validate(gamma_display *dp, png_structp pp, png_infop pi,
if (tmp < 1)
{
is_hi = outmax * pow(tmp, gamma) + maxout;
is_hi = outmax * pow(tmp, gamma_correction) + maxout;
if (is_hi > outmax) is_hi = outmax;
}
@ -3883,15 +3890,15 @@ perform_gamma_threshold_tests(png_modifier *pm)
while (next_format(&colour_type, &bit_depth))
{
double gamma = 1.0;
while (gamma >= .4)
double test_gamma = 1.0;
while (test_gamma >= .4)
{
/* There's little point testing the interlacing vs non-interlacing,
* but this can be set from the command line.
*/
gamma_threshold_test(pm, colour_type, bit_depth, pm->interlace_type,
gamma, 1/gamma);
gamma *= .95;
test_gamma, 1/test_gamma);
test_gamma *= .95;
}
/* And a special test for sRGB */