jdk-sandbox: comparison src/java.desktop/share/native/libsplashscreen/libpng/pngrtran.c

equal deleted inserted replaced

-:0eeff620cdf5
+:66d9993dd4ad
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file and, per its terms, should not be removed:
 *
-* Last changed in libpng 1.6.33 [September 28, 2017]
+* Last changed in libpng 1.6.35 [July 15, 2018]
-* Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
+* Copyright (c) 1998-2002,2004,2006-2018 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.)
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
 * is expected to be 1 or greater, but this range test allows for some
 * viewing correction values.  The intent is to weed out users of this API
 * who use the inverse of the gamma value accidentally!  Since some of these
 * values are reasonable this may have to be changed:
 *
-* 1.6.x: changed from 0.07..3 to 0.01..100 (to accomodate the optimal 16-bit
+* 1.6.x: changed from 0.07..3 to 0.01..100 (to accommodate the optimal 16-bit
 * gamma of 36, and its reciprocal.)
 */
 if (output_gamma < 1000 || output_gamma > 10000000)
 png_error(png_ptr, "output gamma out of expected range");
 int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS +
 PNG_QUANTIZE_BLUE_BITS;
 int num_red = (1 << PNG_QUANTIZE_RED_BITS);
 int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
 int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
-png_size_t num_entries = ((png_size_t)1 << total_bits);
+size_t num_entries = ((size_t)1 << total_bits);
 png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
 (png_alloc_size_t)(num_entries * (sizeof (png_byte))));
 distance = (png_bytep)png_malloc(png_ptr, (png_alloc_size_t)(num_entries *
 png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma);
 }
 else if (png_ptr->screen_gamma != 0)
 /* The converse - assume the file matches the screen, note that this
-* perhaps undesireable default can (from 1.5.4) be changed by calling
+* perhaps undesirable default can (from 1.5.4) be changed by calling
 * png_set_alpha_mode (even if the alpha handling mode isn't required
 * or isn't changed from the default.)
 */
 png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma);
 int istop = png_ptr->num_palette;
 int shift = 8 - png_ptr->sig_bit.red;
 png_ptr->transformations &= ~PNG_SHIFT;
-/* significant bits can be in the range 1 to 7 for a meaninful result, if
+/* significant bits can be in the range 1 to 7 for a meaningful result, if
 * the number of significant bits is 0 then no shift is done (this is an
 * error condition which is silently ignored.)
 */
 if (shift > 0 && shift < 8)
 for (i=0; i<istop; ++i)
 switch (row_info->bit_depth)
 {
 case 1:
 {
-png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);
+png_bytep sp = row + (size_t)((row_width - 1) >> 3);
-png_bytep dp = row + (png_size_t)row_width - 1;
+png_bytep dp = row + (size_t)row_width - 1;
 png_uint_32 shift = 7U - ((row_width + 7U) & 0x07);
 for (i = 0; i < row_width; i++)
 {
 *dp = (png_byte)((*sp >> shift) & 0x01);
 }
 case 2:
 {
-png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);
+png_bytep sp = row + (size_t)((row_width - 1) >> 2);
-png_bytep dp = row + (png_size_t)row_width - 1;
+png_bytep dp = row + (size_t)row_width - 1;
 png_uint_32 shift = ((3U - ((row_width + 3U) & 0x03)) << 1);
 for (i = 0; i < row_width; i++)
 {
 *dp = (png_byte)((*sp >> shift) & 0x03);
 break;
 }
 case 4:
 {
-png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);
+png_bytep sp = row + (size_t)((row_width - 1) >> 1);
-png_bytep dp = row + (png_size_t)row_width - 1;
+png_bytep dp = row + (size_t)row_width - 1;
 png_uint_32 shift = ((1U - ((row_width + 1U) & 0x01)) << 2);
 for (i = 0; i < row_width; i++)
 {
 *dp = (png_byte)((*sp >> shift) & 0x0f);
 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
 static void
 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
 {
+png_uint_32 row_width = row_info->width;
 png_debug(1, "in png_do_read_swap_alpha");
-{
+if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-png_uint_32 row_width = row_info->width;
+{
-if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+/* This converts from RGBA to ARGB */
-{
+if (row_info->bit_depth == 8)
-/* This converts from RGBA to ARGB */
+{
-if (row_info->bit_depth == 8)
+png_bytep sp = row + row_info->rowbytes;
-{
+png_bytep dp = sp;
-png_bytep sp = row + row_info->rowbytes;
+png_byte save;
-png_bytep dp = sp;
+png_uint_32 i;
-png_byte save;
-png_uint_32 i;
+for (i = 0; i < row_width; i++)
+{
-for (i = 0; i < row_width; i++)
+save = *(--sp);
-{
+*(--dp) = *(--sp);
-save = *(--sp);
+*(--dp) = *(--sp);
 *(--dp) = *(--sp);
-*(--dp) = *(--sp);
+*(--dp) = save;
-*(--dp) = *(--sp);
+}
-*(--dp) = save;
+}
-}
-}
 #ifdef PNG_READ_16BIT_SUPPORTED
 /* This converts from RRGGBBAA to AARRGGBB */
 else
 {
 png_bytep sp = row + row_info->rowbytes;
 png_bytep dp = sp;
 png_byte save[2];
 png_uint_32 i;
 for (i = 0; i < row_width; i++)
 {
 save[0] = *(--sp);
 save[1] = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = save[0];
 *(--dp) = save[1];
 }
 }
 #endif
 }
 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 {
 /* This converts from GA to AG */
 if (row_info->bit_depth == 8)
 {
 png_bytep sp = row + row_info->rowbytes;
 png_bytep dp = sp;
 png_byte save;
 png_uint_32 i;
 for (i = 0; i < row_width; i++)
 {
 save = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = save;
 }
 }
 #ifdef PNG_READ_16BIT_SUPPORTED
 /* This converts from GGAA to AAGG */
 else
 {
 png_bytep sp = row + row_info->rowbytes;
 png_bytep dp = sp;
 png_byte save[2];
 png_uint_32 i;
 for (i = 0; i < row_width; i++)
 {
 save[0] = *(--sp);
 save[1] = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = save[0];
 *(--dp) = save[1];
 }
 }
 #endif
-}
 }
 }
 #endif
 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 if (row_info->bit_depth == 8)
 {
 if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
 {
 /* This changes the data from G to GX */
-png_bytep sp = row + (png_size_t)row_width;
+png_bytep sp = row + (size_t)row_width;
-png_bytep dp =  sp + (png_size_t)row_width;
+png_bytep dp =  sp + (size_t)row_width;
 for (i = 1; i < row_width; i++)
 {
 *(--dp) = lo_filler;
 *(--dp) = *(--sp);
 }
 }
 else
 {
 /* This changes the data from G to XG */
-png_bytep sp = row + (png_size_t)row_width;
+png_bytep sp = row + (size_t)row_width;
-png_bytep dp = sp  + (png_size_t)row_width;
+png_bytep dp = sp  + (size_t)row_width;
 for (i = 0; i < row_width; i++)
 {
 *(--dp) = *(--sp);
 *(--dp) = lo_filler;
 }
 else if (row_info->bit_depth == 16)
 {
 if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
 {
 /* This changes the data from GG to GGXX */
-png_bytep sp = row + (png_size_t)row_width * 2;
+png_bytep sp = row + (size_t)row_width * 2;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 1; i < row_width; i++)
 {
 *(--dp) = lo_filler;
 *(--dp) = hi_filler;
 *(--dp) = *(--sp);
 }
 else
 {
 /* This changes the data from GG to XXGG */
-png_bytep sp = row + (png_size_t)row_width * 2;
+png_bytep sp = row + (size_t)row_width * 2;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 0; i < row_width; i++)
 {
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = lo_filler;
 if (row_info->bit_depth == 8)
 {
 if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
 {
 /* This changes the data from RGB to RGBX */
-png_bytep sp = row + (png_size_t)row_width * 3;
+png_bytep sp = row + (size_t)row_width * 3;
-png_bytep dp = sp  + (png_size_t)row_width;
+png_bytep dp = sp  + (size_t)row_width;
 for (i = 1; i < row_width; i++)
 {
 *(--dp) = lo_filler;
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 }
 else
 {
 /* This changes the data from RGB to XRGB */
-png_bytep sp = row + (png_size_t)row_width * 3;
+png_bytep sp = row + (size_t)row_width * 3;
-png_bytep dp = sp + (png_size_t)row_width;
+png_bytep dp = sp + (size_t)row_width;
 for (i = 0; i < row_width; i++)
 {
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 else if (row_info->bit_depth == 16)
 {
 if ((flags & PNG_FLAG_FILLER_AFTER) != 0)
 {
 /* This changes the data from RRGGBB to RRGGBBXX */
-png_bytep sp = row + (png_size_t)row_width * 6;
+png_bytep sp = row + (size_t)row_width * 6;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 1; i < row_width; i++)
 {
 *(--dp) = lo_filler;
 *(--dp) = hi_filler;
 *(--dp) = *(--sp);
 }
 else
 {
 /* This changes the data from RRGGBB to XXRRGGBB */
-png_bytep sp = row + (png_size_t)row_width * 6;
+png_bytep sp = row + (size_t)row_width * 6;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 0; i < row_width; i++)
 {
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 *(--dp) = *(--sp);
 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
 {
 if (row_info->bit_depth == 8)
 {
 /* This changes G to RGB */
-png_bytep sp = row + (png_size_t)row_width - 1;
+png_bytep sp = row + (size_t)row_width - 1;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 0; i < row_width; i++)
 {
 *(dp--) = *sp;
 *(dp--) = *sp;
 *(dp--) = *(sp--);
 }
 else
 {
 /* This changes GG to RRGGBB */
-png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+png_bytep sp = row + (size_t)row_width * 2 - 1;
-png_bytep dp = sp  + (png_size_t)row_width * 4;
+png_bytep dp = sp  + (size_t)row_width * 4;
 for (i = 0; i < row_width; i++)
 {
 *(dp--) = *sp;
 *(dp--) = *(sp - 1);
 *(dp--) = *sp;
 else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 {
 if (row_info->bit_depth == 8)
 {
 /* This changes GA to RGBA */
-png_bytep sp = row + (png_size_t)row_width * 2 - 1;
+png_bytep sp = row + (size_t)row_width * 2 - 1;
-png_bytep dp = sp  + (png_size_t)row_width * 2;
+png_bytep dp = sp  + (size_t)row_width * 2;
 for (i = 0; i < row_width; i++)
 {
 *(dp--) = *(sp--);
 *(dp--) = *sp;
 *(dp--) = *sp;
 }
 else
 {
 /* This changes GGAA to RRGGBBAA */
-png_bytep sp = row + (png_size_t)row_width * 4 - 1;
+png_bytep sp = row + (size_t)row_width * 4 - 1;
-png_bytep dp = sp  + (png_size_t)row_width * 4;
+png_bytep dp = sp  + (size_t)row_width * 4;
 for (i = 0; i < row_width; i++)
 {
 *(dp--) = *(sp--);
 *(dp--) = *(sp--);
 *(dp--) = *sp;
 *  In all cases the calculation is to be done in a linear colorspace.  If no
 *  gamma information is available to correct the encoding of the original RGB
 *  values this results in an implicit assumption that the original PNG RGB
 *  values were linear.
 *
-*  Other integer coefficents can be used via png_set_rgb_to_gray().  Because
+*  Other integer coefficients can be used via png_set_rgb_to_gray().  Because
 *  the API takes just red and green coefficients the blue coefficient is
 *  calculated to make the sum 32768.  This will result in different rounding
 *  to that used above.
 */
 static int
 png_uint_32 row_width = row_info->width;
 int shift;
 png_debug(1, "in png_do_compose");
-{
+switch (row_info->color_type)
-switch (row_info->color_type)
+{
-{
+case PNG_COLOR_TYPE_GRAY:
-case PNG_COLOR_TYPE_GRAY:
+{
-{
+switch (row_info->bit_depth)
-switch (row_info->bit_depth)
+{
-{
+case 1:
-case 1:
+{
+sp = row;
+shift = 7;
+for (i = 0; i < row_width; i++)
+{
+if ((png_uint_16)((*sp >> shift) & 0x01)
+== png_ptr->trans_color.gray)
+{
+unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
+tmp |=
+(unsigned int)(png_ptr->background.gray << shift);
+*sp = (png_byte)(tmp & 0xff);
+}
+if (shift == 0)
+{
+shift = 7;
+sp++;
+}
+else
+shift--;
+}
+break;
+}
+case 2:
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_table != NULL)
 {
 sp = row;
-shift = 7;
+shift = 6;
 for (i = 0; i < row_width; i++)
 {
-if ((png_uint_16)((*sp >> shift) & 0x01)
+if ((png_uint_16)((*sp >> shift) & 0x03)
 == png_ptr->trans_color.gray)
 {
-unsigned int tmp = *sp & (0x7f7f >> (7 - shift));
+unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
 tmp |=
-(unsigned int)(png_ptr->background.gray << shift);
+(unsigned int)png_ptr->background.gray << shift;
 *sp = (png_byte)(tmp & 0xff);
 }
+else
+{
+unsigned int p = (*sp >> shift) & 0x03;
+unsigned int g = (gamma_table [p | (p << 2) |
+(p << 4) | (p << 6)] >> 6) & 0x03;
+unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
+tmp |= (unsigned int)(g << shift);
+*sp = (png_byte)(tmp & 0xff);
+}
 if (shift == 0)
 {
-shift = 7;
+shift = 6;
 sp++;
 }
 else
-shift--;
+shift -= 2;
 }
-break;
+}
-}
+else
-case 2:
+#endif
 {
-#ifdef PNG_READ_GAMMA_SUPPORTED
+sp = row;
-if (gamma_table != NULL)
+shift = 6;
+for (i = 0; i < row_width; i++)
 {
-sp = row;
+if ((png_uint_16)((*sp >> shift) & 0x03)
-shift = 6;
+== png_ptr->trans_color.gray)
-for (i = 0; i < row_width; i++)
 {
-if ((png_uint_16)((*sp >> shift) & 0x03)
+unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-== png_ptr->trans_color.gray)
+tmp |=
-{
+(unsigned int)png_ptr->background.gray << shift;
-unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
+*sp = (png_byte)(tmp & 0xff);
-tmp |=
-(unsigned int)png_ptr->background.gray << shift;
-*sp = (png_byte)(tmp & 0xff);
-}
-else
-{
-unsigned int p = (*sp >> shift) & 0x03;
-unsigned int g = (gamma_table [p | (p << 2) |
-(p << 4) | (p << 6)] >> 6) & 0x03;
-unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-tmp |= (unsigned int)(g << shift);
-*sp = (png_byte)(tmp & 0xff);
-}
-if (shift == 0)
-{
-shift = 6;
-sp++;
-}
-else
-shift -= 2;
 }
+if (shift == 0)
+{
+shift = 6;
+sp++;
+}
+else
+shift -= 2;
 }
+}
-else
+break;
-#endif
+}
-{
-sp = row;
+case 4:
-shift = 6;
-for (i = 0; i < row_width; i++)
-{
-if ((png_uint_16)((*sp >> shift) & 0x03)
-== png_ptr->trans_color.gray)
-{
-unsigned int tmp = *sp & (0x3f3f >> (6 - shift));
-tmp |=
-(unsigned int)png_ptr->background.gray << shift;
-*sp = (png_byte)(tmp & 0xff);
-}
-if (shift == 0)
-{
-shift = 6;
-sp++;
-}
-else
-shift -= 2;
-}
-}
-break;
-}
-case 4:
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_table != NULL)
-{
-sp = row;
-shift = 4;
-for (i = 0; i < row_width; i++)
-{
-if ((png_uint_16)((*sp >> shift) & 0x0f)
-== png_ptr->trans_color.gray)
-{
-unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-tmp |=
-(unsigned int)(png_ptr->background.gray << shift);
-*sp = (png_byte)(tmp & 0xff);
-}
-else
-{
-unsigned int p = (*sp >> shift) & 0x0f;
-unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
-0x0f;
-unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-tmp |= (unsigned int)(g << shift);
-*sp = (png_byte)(tmp & 0xff);
-}
-if (shift == 0)
-{
-shift = 4;
-sp++;
-}
-else
-shift -= 4;
-}
-}
-else
-#endif
-{
-sp = row;
-shift = 4;
-for (i = 0; i < row_width; i++)
-{
-if ((png_uint_16)((*sp >> shift) & 0x0f)
-== png_ptr->trans_color.gray)
-{
-unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-tmp |=
-(unsigned int)(png_ptr->background.gray << shift);
-*sp = (png_byte)(tmp & 0xff);
-}
-if (shift == 0)
-{
-shift = 4;
-sp++;
-}
-else
-shift -= 4;
-}
-}
-break;
-}
-case 8:
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_table != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp++)
-{
-if (*sp == png_ptr->trans_color.gray)
-*sp = (png_byte)png_ptr->background.gray;
-else
-*sp = gamma_table[*sp];
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp++)
-{
-if (*sp == png_ptr->trans_color.gray)
-*sp = (png_byte)png_ptr->background.gray;
-}
-}
-break;
-}
-case 16:
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_16 != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 2)
-{
-png_uint_16 v;
-v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-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);
-}
-else
-{
-v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(v & 0xff);
-}
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 2)
-{
-png_uint_16 v;
-v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-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);
-}
-}
-}
-break;
-}
-default:
-break;
-}
-break;
-}
-case PNG_COLOR_TYPE_RGB:
-{
-if (row_info->bit_depth == 8)
 {
 #ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_table != NULL)
 {
 sp = row;
-for (i = 0; i < row_width; i++, sp += 3)
+shift = 4;
+for (i = 0; i < row_width; i++)
 {
-if (*sp == png_ptr->trans_color.red &&
+if ((png_uint_16)((*sp >> shift) & 0x0f)
-*(sp + 1) == png_ptr->trans_color.green &&
+== png_ptr->trans_color.gray)
-*(sp + 2) == png_ptr->trans_color.blue)
 {
-*sp = (png_byte)png_ptr->background.red;
+unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
-*(sp + 1) = (png_byte)png_ptr->background.green;
+tmp |=
-*(sp + 2) = (png_byte)png_ptr->background.blue;
+(unsigned int)(png_ptr->background.gray << shift);
+*sp = (png_byte)(tmp & 0xff);
 }
 else
 {
+unsigned int p = (*sp >> shift) & 0x0f;
+unsigned int g = (gamma_table[p | (p << 4)] >> 4) &
+0x0f;
+unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
+tmp |= (unsigned int)(g << shift);
+*sp = (png_byte)(tmp & 0xff);
+}
+if (shift == 0)
+{
+shift = 4;
+sp++;
+}
+else
+shift -= 4;
+}
+}
+else
+#endif
+{
+sp = row;
+shift = 4;
+for (i = 0; i < row_width; i++)
+{
+if ((png_uint_16)((*sp >> shift) & 0x0f)
+== png_ptr->trans_color.gray)
+{
+unsigned int tmp = *sp & (0x0f0f >> (4 - shift));
+tmp |=
+(unsigned int)(png_ptr->background.gray << shift);
+*sp = (png_byte)(tmp & 0xff);
+}
+if (shift == 0)
+{
+shift = 4;
+sp++;
+}
+else
+shift -= 4;
+}
+}
+break;
+}
+case 8:
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_table != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp++)
+{
+if (*sp == png_ptr->trans_color.gray)
+*sp = (png_byte)png_ptr->background.gray;
+else
 *sp = gamma_table[*sp];
-*(sp + 1) = gamma_table[*(sp + 1)];
-*(sp + 2) = gamma_table[*(sp + 2)];
-}
 }
 }
 else
 #endif
 {
 sp = row;
-for (i = 0; i < row_width; i++, sp += 3)
+for (i = 0; i < row_width; i++, sp++)
 {
-if (*sp == png_ptr->trans_color.red &&
+if (*sp == png_ptr->trans_color.gray)
-*(sp + 1) == png_ptr->trans_color.green &&
+*sp = (png_byte)png_ptr->background.gray;
-*(sp + 2) == png_ptr->trans_color.blue)
-{
-*sp = (png_byte)png_ptr->background.red;
-*(sp + 1) = (png_byte)png_ptr->background.green;
-*(sp + 2) = (png_byte)png_ptr->background.blue;
-}
 }
 }
-}
+break;
-else /* if (row_info->bit_depth == 16) */
+}
+case 16:
 {
 #ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_16 != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 6)
-{
-png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-+ *(sp + 3));
-png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-+ *(sp + 5));
-if (r == png_ptr->trans_color.red &&
-g == png_ptr->trans_color.green &&
-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);
-}
-else
-{
-png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(v & 0xff);
-v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
-*(sp + 2) = (png_byte)((v >> 8) & 0xff);
-*(sp + 3) = (png_byte)(v & 0xff);
-v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
-*(sp + 4) = (png_byte)((v >> 8) & 0xff);
-*(sp + 5) = (png_byte)(v & 0xff);
-}
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 6)
-{
-png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-+ *(sp + 3));
-png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-+ *(sp + 5));
-if (r == png_ptr->trans_color.red &&
-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);
-}
-}
-}
-}
-break;
-}
-case PNG_COLOR_TYPE_GRAY_ALPHA:
-{
-if (row_info->bit_depth == 8)
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
-gamma_table != NULL)
 {
 sp = row;
 for (i = 0; i < row_width; i++, sp += 2)
 {
-png_uint_16 a = *(sp + 1);
+png_uint_16 v;
-if (a == 0xff)
+v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-*sp = gamma_table[*sp];
+if (v == png_ptr->trans_color.gray)
-else if (a == 0)
 {
 /* Background is already in screen gamma */
-*sp = (png_byte)png_ptr->background.gray;
+*sp = (png_byte)((png_ptr->background.gray >> 8)
+& 0xff);
+*(sp + 1) = (png_byte)(png_ptr->background.gray
+& 0xff);
 }
 else
 {
-png_byte v, w;
-v = gamma_to_1[*sp];
-png_composite(w, v, a, png_ptr->background_1.gray);
-if (optimize == 0)
-w = gamma_from_1[w];
-*sp = w;
-}
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 2)
-{
-png_byte a = *(sp + 1);
-if (a == 0)
-*sp = (png_byte)png_ptr->background.gray;
-else if (a < 0xff)
-png_composite(*sp, *sp, a, png_ptr->background.gray);
-}
-}
-}
-else /* if (png_ptr->bit_depth == 16) */
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
-gamma_16_to_1 != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 4)
-{
-png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
-+ *(sp + 3));
-if (a == (png_uint_16)0xffff)
-{
-png_uint_16 v;
 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
 *sp = (png_byte)((v >> 8) & 0xff);
 *(sp + 1) = (png_byte)(v & 0xff);
 }
+}
-else if (a == 0)
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 2)
+{
+png_uint_16 v;
+v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+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 + 1) = (png_byte)(png_ptr->background.gray
-}
+& 0xff);
-else
-{
-png_uint_16 g, v, w;
-g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
-png_composite_16(v, g, a, png_ptr->background_1.gray);
-if (optimize != 0)
-w = v;
-else
-w = gamma_16_from_1[(v & 0xff) >>
-gamma_shift][v >> 8];
-*sp = (png_byte)((w >> 8) & 0xff);
-*(sp + 1) = (png_byte)(w & 0xff);
 }
 }
 }
-else
+break;
-#endif
+}
-{
-sp = row;
+default:
-for (i = 0; i < row_width; i++, sp += 4)
+break;
+}
+break;
+}
+case PNG_COLOR_TYPE_RGB:
+{
+if (row_info->bit_depth == 8)
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_table != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 3)
+{
+if (*sp == png_ptr->trans_color.red &&
+*(sp + 1) == png_ptr->trans_color.green &&
+*(sp + 2) == png_ptr->trans_color.blue)
 {
-png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
+*sp = (png_byte)png_ptr->background.red;
+*(sp + 1) = (png_byte)png_ptr->background.green;
+*(sp + 2) = (png_byte)png_ptr->background.blue;
+}
+else
+{
+*sp = gamma_table[*sp];
+*(sp + 1) = gamma_table[*(sp + 1)];
+*(sp + 2) = gamma_table[*(sp + 2)];
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 3)
+{
+if (*sp == png_ptr->trans_color.red &&
+*(sp + 1) == png_ptr->trans_color.green &&
+*(sp + 2) == png_ptr->trans_color.blue)
+{
+*sp = (png_byte)png_ptr->background.red;
+*(sp + 1) = (png_byte)png_ptr->background.green;
+*(sp + 2) = (png_byte)png_ptr->background.blue;
+}
+}
+}
+}
+else /* if (row_info->bit_depth == 16) */
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_16 != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 6)
+{
+png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
++ *(sp + 3));
+png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
++ *(sp + 5));
+if (r == png_ptr->trans_color.red &&
+g == png_ptr->trans_color.green &&
+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);
+}
+else
+{
+png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+*sp = (png_byte)((v >> 8) & 0xff);
+*(sp + 1) = (png_byte)(v & 0xff);
+v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+*(sp + 2) = (png_byte)((v >> 8) & 0xff);
+*(sp + 3) = (png_byte)(v & 0xff);
+v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+*(sp + 4) = (png_byte)((v >> 8) & 0xff);
+*(sp + 5) = (png_byte)(v & 0xff);
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 6)
+{
+png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
++ *(sp + 3));
+png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
++ *(sp + 5));
+if (r == png_ptr->trans_color.red &&
+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);
+}
+}
+}
+}
+break;
+}
+case PNG_COLOR_TYPE_GRAY_ALPHA:
+{
+if (row_info->bit_depth == 8)
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+gamma_table != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 2)
+{
+png_uint_16 a = *(sp + 1);
+if (a == 0xff)
+*sp = gamma_table[*sp];
+else if (a == 0)
+{
+/* Background is already in screen gamma */
+*sp = (png_byte)png_ptr->background.gray;
+}
+else
+{
+png_byte v, w;
+v = gamma_to_1[*sp];
+png_composite(w, v, a, png_ptr->background_1.gray);
+if (optimize == 0)
+w = gamma_from_1[w];
+*sp = w;
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 2)
+{
+png_byte a = *(sp + 1);
+if (a == 0)
+*sp = (png_byte)png_ptr->background.gray;
+else if (a < 0xff)
+png_composite(*sp, *sp, a, png_ptr->background.gray);
+}
+}
+}
+else /* if (png_ptr->bit_depth == 16) */
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+gamma_16_to_1 != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 4)
+{
+png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
++ *(sp + 3));
+if (a == (png_uint_16)0xffff)
+{
+png_uint_16 v;
+v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+*sp = (png_byte)((v >> 8) & 0xff);
+*(sp + 1) = (png_byte)(v & 0xff);
+}
+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);
+}
+else
+{
+png_uint_16 g, v, w;
+g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
+png_composite_16(v, g, a, png_ptr->background_1.gray);
+if (optimize != 0)
+w = v;
+else
+w = gamma_16_from_1[(v & 0xff) >>
+gamma_shift][v >> 8];
+*sp = (png_byte)((w >> 8) & 0xff);
+*(sp + 1) = (png_byte)(w & 0xff);
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 4)
+{
+png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8)
++ *(sp + 3));
+if (a == 0)
+{
+*sp = (png_byte)((png_ptr->background.gray >> 8)
+& 0xff);
+*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+}
+else if (a < 0xffff)
+{
+png_uint_16 g, v;
+g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+png_composite_16(v, g, a, png_ptr->background.gray);
+*sp = (png_byte)((v >> 8) & 0xff);
+*(sp + 1) = (png_byte)(v & 0xff);
+}
+}
+}
+}
+break;
+}
+case PNG_COLOR_TYPE_RGB_ALPHA:
+{
+if (row_info->bit_depth == 8)
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
+gamma_table != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 4)
+{
+png_byte a = *(sp + 3);
+if (a == 0xff)
+{
+*sp = gamma_table[*sp];
+*(sp + 1) = gamma_table[*(sp + 1)];
+*(sp + 2) = gamma_table[*(sp + 2)];
+}
+else if (a == 0)
+{
+/* Background is already in screen gamma */
+*sp = (png_byte)png_ptr->background.red;
+*(sp + 1) = (png_byte)png_ptr->background.green;
+*(sp + 2) = (png_byte)png_ptr->background.blue;
+}
+else
+{
+png_byte v, w;
+v = gamma_to_1[*sp];
+png_composite(w, v, a, png_ptr->background_1.red);
+if (optimize == 0) w = gamma_from_1[w];
+*sp = w;
+v = gamma_to_1[*(sp + 1)];
+png_composite(w, v, a, png_ptr->background_1.green);
+if (optimize == 0) w = gamma_from_1[w];
+*(sp + 1) = w;
+v = gamma_to_1[*(sp + 2)];
+png_composite(w, v, a, png_ptr->background_1.blue);
+if (optimize == 0) w = gamma_from_1[w];
+*(sp + 2) = w;
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 4)
+{
+png_byte a = *(sp + 3);
+if (a == 0)
+{
+*sp = (png_byte)png_ptr->background.red;
+*(sp + 1) = (png_byte)png_ptr->background.green;
+*(sp + 2) = (png_byte)png_ptr->background.blue;
+}
+else if (a < 0xff)
+{
+png_composite(*sp, *sp, a, png_ptr->background.red);
+png_composite(*(sp + 1), *(sp + 1), a,
+png_ptr->background.green);
+png_composite(*(sp + 2), *(sp + 2), a,
+png_ptr->background.blue);
+}
+}
+}
+}
+else /* if (row_info->bit_depth == 16) */
+{
+#ifdef PNG_READ_GAMMA_SUPPORTED
+if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
+gamma_16_to_1 != NULL)
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 8)
+{
+png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+<< 8) + (png_uint_16)(*(sp + 7)));
+if (a == (png_uint_16)0xffff)
+{
+png_uint_16 v;
+v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
+*sp = (png_byte)((v >> 8) & 0xff);
+*(sp + 1) = (png_byte)(v & 0xff);
+v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
+*(sp + 2) = (png_byte)((v >> 8) & 0xff);
+*(sp + 3) = (png_byte)(v & 0xff);
+v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
+*(sp + 4) = (png_byte)((v >> 8) & 0xff);
+*(sp + 5) = (png_byte)(v & 0xff);
+}
+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);
+}
+else
+{
+png_uint_16 v, w;
+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];
+*sp = (png_byte)((w >> 8) & 0xff);
+*(sp + 1) = (png_byte)(w & 0xff);
+v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
+png_composite_16(w, v, a, png_ptr->background_1.green);
+if (optimize == 0)
+w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
+8];
+*(sp + 2) = (png_byte)((w >> 8) & 0xff);
+*(sp + 3) = (png_byte)(w & 0xff);
+v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
+png_composite_16(w, v, a, png_ptr->background_1.blue);
+if (optimize == 0)
+w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
+8];
+*(sp + 4) = (png_byte)((w >> 8) & 0xff);
+*(sp + 5) = (png_byte)(w & 0xff);
+}
+}
+}
+else
+#endif
+{
+sp = row;
+for (i = 0; i < row_width; i++, sp += 8)
+{
+png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
+<< 8) + (png_uint_16)(*(sp + 7)));
+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);
+}
+else if (a < 0xffff)
+{
+png_uint_16 v;
+png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
 + *(sp + 3));
+png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-if (a == 0)
++ *(sp + 5));
-{
-*sp = (png_byte)((png_ptr->background.gray >> 8)
+png_composite_16(v, r, a, png_ptr->background.red);
-& 0xff);
+*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff);
+*(sp + 1) = (png_byte)(v & 0xff);
-}
+png_composite_16(v, g, a, png_ptr->background.green);
-else if (a < 0xffff)
+*(sp + 2) = (png_byte)((v >> 8) & 0xff);
-{
+*(sp + 3) = (png_byte)(v & 0xff);
-png_uint_16 g, v;
+png_composite_16(v, b, a, png_ptr->background.blue);
-g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
+*(sp + 4) = (png_byte)((v >> 8) & 0xff);
-png_composite_16(v, g, a, png_ptr->background.gray);
+*(sp + 5) = (png_byte)(v & 0xff);
-*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(v & 0xff);
-}
 }
 }
 }
-break;
+}
-}
+break;
+}
-case PNG_COLOR_TYPE_RGB_ALPHA:
-{
+default:
-if (row_info->bit_depth == 8)
+break;
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
-gamma_table != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 4)
-{
-png_byte a = *(sp + 3);
-if (a == 0xff)
-{
-*sp = gamma_table[*sp];
-*(sp + 1) = gamma_table[*(sp + 1)];
-*(sp + 2) = gamma_table[*(sp + 2)];
-}
-else if (a == 0)
-{
-/* Background is already in screen gamma */
-*sp = (png_byte)png_ptr->background.red;
-*(sp + 1) = (png_byte)png_ptr->background.green;
-*(sp + 2) = (png_byte)png_ptr->background.blue;
-}
-else
-{
-png_byte v, w;
-v = gamma_to_1[*sp];
-png_composite(w, v, a, png_ptr->background_1.red);
-if (optimize == 0) w = gamma_from_1[w];
-*sp = w;
-v = gamma_to_1[*(sp + 1)];
-png_composite(w, v, a, png_ptr->background_1.green);
-if (optimize == 0) w = gamma_from_1[w];
-*(sp + 1) = w;
-v = gamma_to_1[*(sp + 2)];
-png_composite(w, v, a, png_ptr->background_1.blue);
-if (optimize == 0) w = gamma_from_1[w];
-*(sp + 2) = w;
-}
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 4)
-{
-png_byte a = *(sp + 3);
-if (a == 0)
-{
-*sp = (png_byte)png_ptr->background.red;
-*(sp + 1) = (png_byte)png_ptr->background.green;
-*(sp + 2) = (png_byte)png_ptr->background.blue;
-}
-else if (a < 0xff)
-{
-png_composite(*sp, *sp, a, png_ptr->background.red);
-png_composite(*(sp + 1), *(sp + 1), a,
-png_ptr->background.green);
-png_composite(*(sp + 2), *(sp + 2), a,
-png_ptr->background.blue);
-}
-}
-}
-}
-else /* if (row_info->bit_depth == 16) */
-{
-#ifdef PNG_READ_GAMMA_SUPPORTED
-if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
-gamma_16_to_1 != NULL)
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 8)
-{
-png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
-<< 8) + (png_uint_16)(*(sp + 7)));
-if (a == (png_uint_16)0xffff)
-{
-png_uint_16 v;
-v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
-*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(v & 0xff);
-v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];
-*(sp + 2) = (png_byte)((v >> 8) & 0xff);
-*(sp + 3) = (png_byte)(v & 0xff);
-v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];
-*(sp + 4) = (png_byte)((v >> 8) & 0xff);
-*(sp + 5) = (png_byte)(v & 0xff);
-}
-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);
-}
-else
-{
-png_uint_16 v, w;
-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];
-*sp = (png_byte)((w >> 8) & 0xff);
-*(sp + 1) = (png_byte)(w & 0xff);
-v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];
-png_composite_16(w, v, a, png_ptr->background_1.green);
-if (optimize == 0)
-w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
-8];
-*(sp + 2) = (png_byte)((w >> 8) & 0xff);
-*(sp + 3) = (png_byte)(w & 0xff);
-v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];
-png_composite_16(w, v, a, png_ptr->background_1.blue);
-if (optimize == 0)
-w = gamma_16_from_1[((w & 0xff) >> gamma_shift)][w >>
-8];
-*(sp + 4) = (png_byte)((w >> 8) & 0xff);
-*(sp + 5) = (png_byte)(w & 0xff);
-}
-}
-}
-else
-#endif
-{
-sp = row;
-for (i = 0; i < row_width; i++, sp += 8)
-{
-png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))
-<< 8) + (png_uint_16)(*(sp + 7)));
-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);
-}
-else if (a < 0xffff)
-{
-png_uint_16 v;
-png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)
-+ *(sp + 3));
-png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)
-+ *(sp + 5));
-png_composite_16(v, r, a, png_ptr->background.red);
-*sp = (png_byte)((v >> 8) & 0xff);
-*(sp + 1) = (png_byte)(v & 0xff);
-png_composite_16(v, g, a, png_ptr->background.green);
-*(sp + 2) = (png_byte)((v >> 8) & 0xff);
-*(sp + 3) = (png_byte)(v & 0xff);
-png_composite_16(v, b, a, png_ptr->background.blue);
-*(sp + 4) = (png_byte)((v >> 8) & 0xff);
-*(sp + 5) = (png_byte)(v & 0xff);
-}
-}
-}
-}
-break;
-}
-default:
-break;
-}
 }
 }
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE */
 #ifdef PNG_READ_GAMMA_SUPPORTED
 {
 switch (row_info->bit_depth)
 {
 case 1:
 {
-sp = row + (png_size_t)((row_width - 1) >> 3);
+sp = row + (size_t)((row_width - 1) >> 3);
-dp = row + (png_size_t)row_width - 1;
+dp = row + (size_t)row_width - 1;
 shift = 7 - (int)((row_width + 7) & 0x07);
 for (i = 0; i < row_width; i++)
 {
 if ((*sp >> shift) & 0x01)
 *dp = 1;
 break;
 }
 case 2:
 {
-sp = row + (png_size_t)((row_width - 1) >> 2);
+sp = row + (size_t)((row_width - 1) >> 2);
-dp = row + (png_size_t)row_width - 1;
+dp = row + (size_t)row_width - 1;
 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
 for (i = 0; i < row_width; i++)
 {
 value = (*sp >> shift) & 0x03;
 *dp = (png_byte)value;
 break;
 }
 case 4:
 {
-sp = row + (png_size_t)((row_width - 1) >> 1);
+sp = row + (size_t)((row_width - 1) >> 1);
-dp = row + (png_size_t)row_width - 1;
+dp = row + (size_t)row_width - 1;
 shift = (int)((row_width & 0x01) << 2);
 for (i = 0; i < row_width; i++)
 {
 value = (*sp >> shift) & 0x0f;
 *dp = (png_byte)value;
 if (row_info->bit_depth == 8)
 {
 {
 if (num_trans > 0)
 {
-sp = row + (png_size_t)row_width - 1;
+sp = row + (size_t)row_width - 1;
-dp = row + ((png_size_t)row_width << 2) - 1;
+dp = row + ((size_t)row_width << 2) - 1;
 for (i = 0; i < row_width; i++)
 {
 if ((int)(*sp) >= num_trans)
 *dp-- = 0xff;
 row_info->channels = 4;
 }
 else
 {
-sp = row + (png_size_t)row_width - 1;
+sp = row + (size_t)row_width - 1;
-dp = row + (png_size_t)(row_width * 3) - 1;
+dp = row + (size_t)(row_width * 3) - 1;
 for (i = 0; i < row_width; i++)
 {
 *dp-- = palette[*sp].blue;
 *dp-- = palette[*sp].green;
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 png_debug(1, "in png_do_expand");
-{
+if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
-if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+{
-{
+unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
-unsigned int gray = trans_color != NULL ? trans_color->gray : 0;
+if (row_info->bit_depth < 8)
-if (row_info->bit_depth < 8)
+{
-{
+switch (row_info->bit_depth)
-switch (row_info->bit_depth)
+{
-{
+case 1:
-case 1:
+{
-{
+gray = (gray & 0x01) * 0xff;
-gray = (gray & 0x01) * 0xff;
+sp = row + (size_t)((row_width - 1) >> 3);
-sp = row + (png_size_t)((row_width - 1) >> 3);
+dp = row + (size_t)row_width - 1;
-dp = row + (png_size_t)row_width - 1;
+shift = 7 - (int)((row_width + 7) & 0x07);
-shift = 7 - (int)((row_width + 7) & 0x07);
+for (i = 0; i < row_width; i++)
-for (i = 0; i < row_width; i++)
+{
+if ((*sp >> shift) & 0x01)
+*dp = 0xff;
+else
+*dp = 0;
+if (shift == 7)
 {
-if ((*sp >> shift) & 0x01)
+shift = 0;
-*dp = 0xff;
+sp--;
-else
-*dp = 0;
-if (shift == 7)
-{
-shift = 0;
-sp--;
-}
-else
-shift++;
-dp--;
 }
-break;
-}
+else
+shift++;
-case 2:
-{
+dp--;
-gray = (gray & 0x03) * 0x55;
+}
-sp = row + (png_size_t)((row_width - 1) >> 2);
+break;
-dp = row + (png_size_t)row_width - 1;
+}
-shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
-for (i = 0; i < row_width; i++)
+case 2:
+{
+gray = (gray & 0x03) * 0x55;
+sp = row + (size_t)((row_width - 1) >> 2);
+dp = row + (size_t)row_width - 1;
+shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);
+for (i = 0; i < row_width; i++)
+{
+value = (*sp >> shift) & 0x03;
+*dp = (png_byte)(value | (value << 2) | (value << 4) |
+(value << 6));
+if (shift == 6)
 {
-value = (*sp >> shift) & 0x03;
+shift = 0;
-*dp = (png_byte)(value | (value << 2) | (value << 4) |
+sp--;
-(value << 6));
-if (shift == 6)
-{
-shift = 0;
-sp--;
-}
-else
-shift += 2;
-dp--;
 }
-break;
-}
+else
+shift += 2;
-case 4:
-{
+dp--;
-gray = (gray & 0x0f) * 0x11;
+}
-sp = row + (png_size_t)((row_width - 1) >> 1);
+break;
-dp = row + (png_size_t)row_width - 1;
+}
-shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
-for (i = 0; i < row_width; i++)
+case 4:
+{
+gray = (gray & 0x0f) * 0x11;
+sp = row + (size_t)((row_width - 1) >> 1);
+dp = row + (size_t)row_width - 1;
+shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);
+for (i = 0; i < row_width; i++)
+{
+value = (*sp >> shift) & 0x0f;
+*dp = (png_byte)(value | (value << 4));
+if (shift == 4)
 {
-value = (*sp >> shift) & 0x0f;
+shift = 0;
-*dp = (png_byte)(value | (value << 4));
+sp--;
-if (shift == 4)
-{
-shift = 0;
-sp--;
-}
-else
-shift = 4;
-dp--;
 }
-break;
-}
-default:
-break;
-}
-row_info->bit_depth = 8;
-row_info->pixel_depth = 8;
-row_info->rowbytes = row_width;
-}
-if (trans_color != NULL)
-{
-if (row_info->bit_depth == 8)
-{
-gray = gray & 0xff;
-sp = row + (png_size_t)row_width - 1;
-dp = row + ((png_size_t)row_width << 1) - 1;
-for (i = 0; i < row_width; i++)
-{
-if ((*sp & 0xffU) == gray)
-*dp-- = 0;
 else
-*dp-- = 0xff;
+shift = 4;
-*dp-- = *sp--;
+dp--;
 }
-}
+break;
+}
-else if (row_info->bit_depth == 16)
-{
+default:
-unsigned int gray_high = (gray >> 8) & 0xff;
+break;
-unsigned int gray_low = gray & 0xff;
+}
-sp = row + row_info->rowbytes - 1;
-dp = row + (row_info->rowbytes << 1) - 1;
+row_info->bit_depth = 8;
-for (i = 0; i < row_width; i++)
+row_info->pixel_depth = 8;
-{
+row_info->rowbytes = row_width;
-if ((*(sp - 1) & 0xffU) == gray_high &&
+}
-(*(sp) & 0xffU) == gray_low)
-{
+if (trans_color != NULL)
-*dp-- = 0;
-*dp-- = 0;
-}
-else
-{
-*dp-- = 0xff;
-*dp-- = 0xff;
-}
-*dp-- = *sp--;
-*dp-- = *sp--;
-}
-}
-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->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
-row_width);
-}
-}
-else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
-trans_color != NULL)
 {
 if (row_info->bit_depth == 8)
 {
-png_byte red = (png_byte)(trans_color->red & 0xff);
+gray = gray & 0xff;
-png_byte green = (png_byte)(trans_color->green & 0xff);
+sp = row + (size_t)row_width - 1;
-png_byte blue = (png_byte)(trans_color->blue & 0xff);
+dp = row + ((size_t)row_width << 1) - 1;
-sp = row + (png_size_t)row_info->rowbytes - 1;
-dp = row + ((png_size_t)row_width << 2) - 1;
 for (i = 0; i < row_width; i++)
 {
-if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
+if ((*sp & 0xffU) == gray)
 *dp-- = 0;
 else
 *dp-- = 0xff;
 *dp-- = *sp--;
+}
+}
+else if (row_info->bit_depth == 16)
+{
+unsigned int gray_high = (gray >> 8) & 0xff;
+unsigned int gray_low = gray & 0xff;
+sp = row + row_info->rowbytes - 1;
+dp = row + (row_info->rowbytes << 1) - 1;
+for (i = 0; i < row_width; i++)
+{
+if ((*(sp - 1) & 0xffU) == gray_high &&
+(*(sp) & 0xffU) == gray_low)
+{
+*dp-- = 0;
+*dp-- = 0;
+}
+else
+{
+*dp-- = 0xff;
+*dp-- = 0xff;
+}
 *dp-- = *sp--;
 *dp-- = *sp--;
 }
 }
-else if (row_info->bit_depth == 16)
-{
+row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
-png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff);
+row_info->channels = 2;
-png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff);
+row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
-png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff);
+row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
-png_byte red_low = (png_byte)(trans_color->red & 0xff);
+row_width);
-png_byte green_low = (png_byte)(trans_color->green & 0xff);
+}
-png_byte blue_low = (png_byte)(trans_color->blue & 0xff);
+}
-sp = row + row_info->rowbytes - 1;
+else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
-dp = row + ((png_size_t)row_width << 3) - 1;
+trans_color != NULL)
-for (i = 0; i < row_width; i++)
+{
-{
+if (row_info->bit_depth == 8)
-if (*(sp - 5) == red_high &&
+{
-*(sp - 4) == red_low &&
+png_byte red = (png_byte)(trans_color->red & 0xff);
-*(sp - 3) == green_high &&
+png_byte green = (png_byte)(trans_color->green & 0xff);
-*(sp - 2) == green_low &&
+png_byte blue = (png_byte)(trans_color->blue & 0xff);
-*(sp - 1) == blue_high &&
+sp = row + (size_t)row_info->rowbytes - 1;
-*(sp    ) == blue_low)
+dp = row + ((size_t)row_width << 2) - 1;
-{
+for (i = 0; i < row_width; i++)
-*dp-- = 0;
+{
-*dp-- = 0;
+if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)
-}
+*dp-- = 0;
 else
-{
+*dp-- = 0xff;
-*dp-- = 0xff;
-*dp-- = 0xff;
+*dp-- = *sp--;
-}
+*dp-- = *sp--;
+*dp-- = *sp--;
-*dp-- = *sp--;
+}
-*dp-- = *sp--;
+}
-*dp-- = *sp--;
+else if (row_info->bit_depth == 16)
-*dp-- = *sp--;
+{
-*dp-- = *sp--;
+png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff);
-*dp-- = *sp--;
+png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff);
-}
+png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff);
-}
+png_byte red_low = (png_byte)(trans_color->red & 0xff);
-row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+png_byte green_low = (png_byte)(trans_color->green & 0xff);
-row_info->channels = 4;
+png_byte blue_low = (png_byte)(trans_color->blue & 0xff);
-row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);
+sp = row + row_info->rowbytes - 1;
-row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
+dp = row + ((size_t)row_width << 3) - 1;
-}
+for (i = 0; i < row_width; i++)
+{
+if (*(sp - 5) == red_high &&
+*(sp - 4) == red_low &&
+*(sp - 3) == green_high &&
+*(sp - 2) == green_low &&
+*(sp - 1) == blue_high &&
+*(sp    ) == blue_low)
+{
+*dp-- = 0;
+*dp-- = 0;
+}
+else
+{
+*dp-- = 0xff;
+*dp-- = 0xff;
+}
+*dp-- = *sp--;
+*dp-- = *sp--;
+*dp-- = *sp--;
+*dp-- = *sp--;
+*dp-- = *sp--;
+*dp-- = *sp--;
+}
+}
+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->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
 }
 }
 #endif
 #ifdef PNG_READ_EXPAND_16_SUPPORTED
 (png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
 png_do_expand(row_info, png_ptr->row_buf + 1,
 &(png_ptr->trans_color));
 else
-png_do_expand(row_info, png_ptr->row_buf + 1,
+png_do_expand(row_info, png_ptr->row_buf + 1, NULL);
-NULL);
 }
 }
 #endif
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 if (png_ptr->read_user_transform_fn != NULL)
 (*(png_ptr->read_user_transform_fn)) /* User read transform function */
 (png_ptr,     /* png_ptr */
 row_info,     /* row_info: */
 /*  png_uint_32 width;       width of row */
-/*  png_size_t rowbytes;     number of bytes in row */
+/*  size_t rowbytes;         number of bytes in row */
 /*  png_byte color_type;     color type of pixels */
 /*  png_byte bit_depth;      bit depth of samples */
 /*  png_byte channels;       number of channels (1-4) */
 /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
 png_ptr->row_buf + 1);    /* start of pixel data for row */

changeset 51304	66d9993dd4ad
parent 48280	791d551bcdb8
child 57618	53154e45385a