FCL/sf/mw/qt: comparison src/3rdparty/libpng/pngrtran.c

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 /* pngrtran.c - transforms the data in a row for PNG readers
 *
-* Last changed in libpng 1.2.38 [July 16, 2009]
+* Last changed in libpng 1.4.0 [January 3, 2010]
-* Copyright (c) 1998-2009 Glenn Randers-Pehrson
+* Copyright (c) 1998-2010 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
 * in order to tell libpng how to handle data when reading a PNG.
 * Transformations that are used in both reading and writing are
 * in pngtrans.c.
 */
-#define PNG_INTERNAL
+#define PNG_NO_PEDANTIC_WARNINGS
 #include "png.h"
-#if defined(PNG_READ_SUPPORTED)
+#ifdef PNG_READ_SUPPORTED
+#include "pngpriv.h"
 /* Set the action on getting a CRC error for an ancillary or critical chunk. */
 void PNGAPI
 png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
 {
 png_debug(1, "in png_set_crc_action");
-/* Tell libpng how we react to CRC errors in critical chunks */
 if (png_ptr == NULL)
 return;
+/* Tell libpng how we react to CRC errors in critical chunks */
 switch (crit_action)
 {
 case PNG_CRC_NO_CHANGE:                        /* Leave setting as is */
 break;
 PNG_FLAG_CRC_CRITICAL_IGNORE;
 break;
 case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */
 png_warning(png_ptr,
-"Can't discard critical data on CRC error.");
+"Can't discard critical data on CRC error");
 case PNG_CRC_ERROR_QUIT:                                /* Error/quit */
 case PNG_CRC_DEFAULT:
 default:
 png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
 break;
 }
+/* Tell libpng how we react to CRC errors in ancillary chunks */
 switch (ancil_action)
 {
 case PNG_CRC_NO_CHANGE:                       /* Leave setting as is */
 break;
 png_set_background(png_structp png_ptr,
 png_color_16p background_color, int background_gamma_code,
 int need_expand, double background_gamma)
 {
 png_debug(1, "in png_set_background");
 if (png_ptr == NULL)
 return;
 if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
 {
 png_warning(png_ptr, "Application must supply a known background gamma");
 png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
 png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);
 }
 #endif
-#if defined(PNG_READ_16_TO_8_SUPPORTED)
+#ifdef PNG_READ_16_TO_8_SUPPORTED
 /* Strip 16 bit depth files to 8 bit depth */
 void PNGAPI
 png_set_strip_16(png_structp png_ptr)
 {
 png_debug(1, "in png_set_strip_16");
 if (png_ptr == NULL)
 return;
 png_ptr->transformations |= PNG_16_TO_8;
 }
 #endif
-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 void PNGAPI
 png_set_strip_alpha(png_structp png_ptr)
 {
 png_debug(1, "in png_set_strip_alpha");
 if (png_ptr == NULL)
 return;
 png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
 }
 #endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
+#ifdef PNG_READ_DITHER_SUPPORTED
 /* Dither file to 8 bit.  Supply a palette, the current number
 * of elements in the palette, the maximum number of elements
 * allowed, and a histogram if possible.  If the current number
 * of colors is greater then the maximum number, the palette will be
 * modified to fit in the maximum number.  "full_dither" indicates
 png_set_dither(png_structp png_ptr, png_colorp palette,
 int num_palette, int maximum_colors, png_uint_16p histogram,
 int full_dither)
 {
 png_debug(1, "in png_set_dither");
 if (png_ptr == NULL)
 return;
 png_ptr->transformations |= PNG_DITHER;
 if (!full_dither)
 {
 png_ptr->index_to_palette[i] = (png_byte)i;
 png_ptr->palette_to_index[i] = (png_byte)i;
 }
-hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
+hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
 png_sizeof(png_dsortp)));
-png_memset(hash, 0, 769 * png_sizeof(png_dsortp));
 num_new_palette = num_palette;
 /* Initial wild guess at how far apart the farthest pixel
 * pair we will be eliminating will be.  Larger
 PNG_DITHER_BLUE_BITS;
 int num_red = (1 << PNG_DITHER_RED_BITS);
 int num_green = (1 << PNG_DITHER_GREEN_BITS);
 int num_blue = (1 << PNG_DITHER_BLUE_BITS);
 png_size_t num_entries = ((png_size_t)1 << total_bits);
-png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
+png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,
 (png_uint_32)(num_entries * png_sizeof(png_byte)));
-png_memset(png_ptr->palette_lookup, 0, num_entries *
-png_sizeof(png_byte));
 distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
 png_sizeof(png_byte)));
 png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));
 for (i = 0; i < num_palette; i++)
 {
 int ir, ig, ib;
 */
 void PNGAPI
 png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
 {
 png_debug(1, "in png_set_gamma");
 if (png_ptr == NULL)
 return;
 if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
 (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
 png_ptr->transformations |= PNG_GAMMA;
 png_ptr->gamma = (float)file_gamma;
 png_ptr->screen_gamma = (float)scrn_gamma;
 }
 #endif
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 /* Expand paletted images to RGB, expand grayscale images of
 * less than 8-bit depth to 8-bit depth, and expand tRNS chunks
 * to alpha channels.
 */
 void PNGAPI
 png_set_expand(png_structp png_ptr)
 {
 png_debug(1, "in png_set_expand");
 if (png_ptr == NULL)
 return;
 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
 }
 /* GRR 19990627:  the following three functions currently are identical
 *  functions.
 *
 *  More to the point, these functions make it obvious what libpng will be
 *  doing, whereas "expand" can (and does) mean any number of things.
 *
-*  GRP 20060307: In libpng-1.4.0, png_set_gray_1_2_4_to_8() was modified
+*  GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified
-*  to expand only the sample depth but not to expand the tRNS to alpha.
+*  to expand only the sample depth but not to expand the tRNS to alpha
+*  and its name was changed to png_set_expand_gray_1_2_4_to_8().
 */
 /* Expand paletted images to RGB. */
 void PNGAPI
 png_set_palette_to_rgb(png_structp png_ptr)
 {
 png_debug(1, "in png_set_palette_to_rgb");
 if (png_ptr == NULL)
 return;
 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
 }
-#if !defined(PNG_1_0_X)
 /* Expand grayscale images of less than 8-bit depth to 8 bits. */
 void PNGAPI
 png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
 {
 png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
 if (png_ptr == NULL)
 return;
 png_ptr->transformations |= PNG_EXPAND;
 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
 }
-#endif
-#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
-/* Expand grayscale images of less than 8-bit depth to 8 bits. */
-/* Deprecated as of libpng-1.2.9 */
-void PNGAPI
-png_set_gray_1_2_4_to_8(png_structp png_ptr)
-{
-png_debug(1, "in png_set_gray_1_2_4_to_8");
-if (png_ptr == NULL)
-return;
-png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
-}
-#endif
 /* Expand tRNS chunks to alpha channels. */
 void PNGAPI
 png_set_tRNS_to_alpha(png_structp png_ptr)
 {
 png_debug(1, "in png_set_tRNS_to_alpha");
 png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
 }
 #endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 void PNGAPI
 png_set_gray_to_rgb(png_structp png_ptr)
 {
 png_debug(1, "in png_set_gray_to_rgb");
 png_ptr->transformations |= PNG_GRAY_TO_RGB;
 png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
 }
 #endif
-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
-#if defined(PNG_FLOATING_POINT_SUPPORTED)
+#ifdef PNG_FLOATING_POINT_SUPPORTED
 /* Convert a RGB image to a grayscale of the same width.  This allows us,
 * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
 */
 void PNGAPI
 void PNGAPI
 png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
 png_fixed_point red, png_fixed_point green)
 {
 png_debug(1, "in png_set_rgb_to_gray");
 if (png_ptr == NULL)
 return;
 switch(error_action)
 {
 case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;
 break;
 break;
 case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
 }
 if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 png_ptr->transformations |= PNG_EXPAND;
 #else
 {
 png_warning(png_ptr,
-"Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");
+"Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
 png_ptr->transformations &= ~PNG_RGB_TO_GRAY;
 }
 #endif
 {
 png_uint_16 red_int, green_int;
 }
 }
 #endif
 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
-defined(PNG_LEGACY_SUPPORTED) || \
 defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 void PNGAPI
 png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
 read_user_transform_fn)
 {
 png_debug(1, "in png_set_read_user_transform_fn");
 if (png_ptr == NULL)
 return;
-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 png_ptr->transformations |= PNG_USER_TRANSFORM;
 png_ptr->read_user_transform_fn = read_user_transform_fn;
-#endif
-#ifdef PNG_LEGACY_SUPPORTED
-if (read_user_transform_fn)
-png_warning(png_ptr,
-"This version of libpng does not support user transforms");
 #endif
 }
 #endif
 /* Initialize everything needed for the read.  This includes modifying
 */
 void /* PRIVATE */
 png_init_read_transformations(png_structp png_ptr)
 {
 png_debug(1, "in png_init_read_transformations");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (png_ptr != NULL)
-#endif
 {
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \
 || defined(PNG_READ_GAMMA_SUPPORTED)
 int color_type = png_ptr->color_type;
 #endif
 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 /* Detect gray background and attempt to enable optimization
 * for gray --> RGB case
 *
 * Note:  if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
 * RGB_ALPHA (in which case need_expand is superfluous anyway), the
 png_ptr->background.gray *= (png_uint_16)0xff;
 png_ptr->background.red = png_ptr->background.green
 =  png_ptr->background.blue = png_ptr->background.gray;
 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
 {
-png_ptr->trans_values.gray *= (png_uint_16)0xff;
+png_ptr->trans_color.gray *= (png_uint_16)0xff;
-png_ptr->trans_values.red = png_ptr->trans_values.green
+png_ptr->trans_color.red = png_ptr->trans_color.green
-= png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
 }
 break;
 case 2:
 png_ptr->background.gray *= (png_uint_16)0x55;
 png_ptr->background.red = png_ptr->background.green
 = png_ptr->background.blue = png_ptr->background.gray;
 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
 {
-png_ptr->trans_values.gray *= (png_uint_16)0x55;
+png_ptr->trans_color.gray *= (png_uint_16)0x55;
-png_ptr->trans_values.red = png_ptr->trans_values.green
+png_ptr->trans_color.red = png_ptr->trans_color.green
-= png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
 }
 break;
 case 4:
 png_ptr->background.gray *= (png_uint_16)0x11;
 png_ptr->background.red = png_ptr->background.green
 = png_ptr->background.blue = png_ptr->background.gray;
 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
 {
-png_ptr->trans_values.gray *= (png_uint_16)0x11;
+png_ptr->trans_color.gray *= (png_uint_16)0x11;
-png_ptr->trans_values.red = png_ptr->trans_values.green
+png_ptr->trans_color.red = png_ptr->trans_color.green
-= png_ptr->trans_values.blue = png_ptr->trans_values.gray;
+= png_ptr->trans_color.blue = png_ptr->trans_color.gray;
 }
 break;
 case 8:
 png_ptr->background.green =
 png_ptr->palette[png_ptr->background.index].green;
 png_ptr->background.blue  =
 png_ptr->palette[png_ptr->background.index].blue;
-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 if (png_ptr->transformations & PNG_INVERT_ALPHA)
 {
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 if (!(png_ptr->transformations & PNG_EXPAND_tRNS))
 #endif
 {
 /* Invert the alpha channel (in tRNS) unless the pixels are
 * going to be expanded, in which case leave it for later
 */
 int i, istop;
 istop=(int)png_ptr->num_trans;
 for (i=0; i<istop; i++)
-png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);
+png_ptr->trans_alpha[i] = (png_byte)(255 - png_ptr->trans_alpha[i]);
 }
 }
 #endif
 }
 {
 int i, k;
 k=0;
 for (i=0; i<png_ptr->num_trans; i++)
 {
-if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)
+if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[i] != 0xff)
 k=1; /* Partial transparency is present */
 }
 if (k == 0)
 png_ptr->transformations &= ~PNG_GAMMA;
 }
 if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&
 png_ptr->gamma != 0.0)
 {
-png_build_gamma_table(png_ptr);
+png_build_gamma_table(png_ptr, png_ptr->bit_depth);
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 if (png_ptr->transformations & PNG_BACKGROUND)
 {
 if (color_type == PNG_COLOR_TYPE_PALETTE)
 {
 /* Could skip if no transparency */
 back.blue  = (png_byte)png_ptr->background.blue;
 }
 else
 {
 back.red = (png_byte)(pow(
-(double)png_ptr->background.red/255, gs) * 255.0 + .5);
+(double)png_ptr->background.red/255.0, gs) * 255.0 + .5);
 back.green = (png_byte)(pow(
-(double)png_ptr->background.green/255, gs) * 255.0 + .5);
+(double)png_ptr->background.green/255.0, gs) * 255.0 + .5);
 back.blue = (png_byte)(pow(
-(double)png_ptr->background.blue/255, gs) * 255.0 + .5);
+(double)png_ptr->background.blue/255.0, gs) * 255.0 + .5);
 }
 back_1.red = (png_byte)(pow(
-(double)png_ptr->background.red/255, g) * 255.0 + .5);
+(double)png_ptr->background.red/255.0, g) * 255.0 + .5);
 back_1.green = (png_byte)(pow(
-(double)png_ptr->background.green/255, g) * 255.0 + .5);
+(double)png_ptr->background.green/255.0, g) * 255.0 + .5);
 back_1.blue = (png_byte)(pow(
-(double)png_ptr->background.blue/255, g) * 255.0 + .5);
+(double)png_ptr->background.blue/255.0, g) * 255.0 + .5);
 }
 for (i = 0; i < num_palette; i++)
 {
-if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)
+if (i < (int)png_ptr->num_trans && png_ptr->trans_alpha[i] != 0xff)
 {
-if (png_ptr->trans[i] == 0)
+if (png_ptr->trans_alpha[i] == 0)
 {
 palette[i] = back;
 }
-else /* if (png_ptr->trans[i] != 0xff) */
+else /* if (png_ptr->trans_alpha[i] != 0xff) */
 {
 png_byte v, w;
 v = png_ptr->gamma_to_1[palette[i].red];
-png_composite(w, v, png_ptr->trans[i], back_1.red);
+png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
 palette[i].red = png_ptr->gamma_from_1[w];
 v = png_ptr->gamma_to_1[palette[i].green];
-png_composite(w, v, png_ptr->trans[i], back_1.green);
+png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
 palette[i].green = png_ptr->gamma_from_1[w];
 v = png_ptr->gamma_to_1[palette[i].blue];
-png_composite(w, v, png_ptr->trans[i], back_1.blue);
+png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
 palette[i].blue = png_ptr->gamma_from_1[w];
 }
 }
 else
 {
 palette[i].red = png_ptr->gamma_table[palette[i].red];
 palette[i].green = png_ptr->gamma_table[palette[i].green];
 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
 }
 }
-	    /* Prevent the transformations being done again, and make sure
+/* Prevent the transformations being done again, and make sure
-	     * that the now spurious alpha channel is stripped - the code
+* that the now spurious alpha channel is stripped - the code
-	     * has just reduced background composition and gamma correction
+* has just reduced background composition and gamma correction
-	     * to a simple alpha channel strip.
+* to a simple alpha channel strip.
-	     */
+*/
-	    png_ptr->transformations &= ~PNG_BACKGROUND;
+png_ptr->transformations &= ~PNG_BACKGROUND;
-	    png_ptr->transformations &= ~PNG_GAMMA;
+png_ptr->transformations &= ~PNG_GAMMA;
-	    png_ptr->transformations |= PNG_STRIP_ALPHA;
+png_ptr->transformations |= PNG_STRIP_ALPHA;
 }
 /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
 else
 /* color_type != PNG_COLOR_TYPE_PALETTE */
 {
 palette[i].red = png_ptr->gamma_table[palette[i].red];
 palette[i].green = png_ptr->gamma_table[palette[i].green];
 palette[i].blue = png_ptr->gamma_table[palette[i].blue];
 }
-	 /* Done the gamma correction. */
+/* Done the gamma correction. */
-	 png_ptr->transformations &= ~PNG_GAMMA;
+png_ptr->transformations &= ~PNG_GAMMA;
 }
 }
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 else
 #endif
 #endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 /* No GAMMA transformation */
 if ((png_ptr->transformations & PNG_BACKGROUND) &&
 (color_type == PNG_COLOR_TYPE_PALETTE))
 {
 int i;
 back.green = (png_byte)png_ptr->background.green;
 back.blue  = (png_byte)png_ptr->background.blue;
 for (i = 0; i < istop; i++)
 {
-if (png_ptr->trans[i] == 0)
+if (png_ptr->trans_alpha[i] == 0)
 {
 palette[i] = back;
 }
-else if (png_ptr->trans[i] != 0xff)
+else if (png_ptr->trans_alpha[i] != 0xff)
 {
 /* The png_composite() macro is defined in png.h */
 png_composite(palette[i].red, palette[i].red,
-png_ptr->trans[i], back.red);
+png_ptr->trans_alpha[i], back.red);
 png_composite(palette[i].green, palette[i].green,
-png_ptr->trans[i], back.green);
+png_ptr->trans_alpha[i], back.green);
 png_composite(palette[i].blue, palette[i].blue,
-png_ptr->trans[i], back.blue);
+png_ptr->trans_alpha[i], back.blue);
 }
 }
 /* Handled alpha, still need to strip the channel. */
 png_ptr->transformations &= ~PNG_BACKGROUND;
 png_ptr->transformations |= PNG_STRIP_ALPHA;
 }
 #endif /* PNG_READ_BACKGROUND_SUPPORTED */
-#if defined(PNG_READ_SHIFT_SUPPORTED)
+#ifdef PNG_READ_SHIFT_SUPPORTED
 if ((png_ptr->transformations & PNG_SHIFT) &&
 (color_type == PNG_COLOR_TYPE_PALETTE))
 {
 png_uint_16 i;
 png_uint_16 istop = png_ptr->num_palette;
 */
 void /* PRIVATE */
 png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
 {
 png_debug(1, "in png_read_transform_info");
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 if (png_ptr->transformations & PNG_EXPAND)
 {
 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 {
 if (png_ptr->num_trans &&
 info_ptr->num_trans = 0;
 }
 }
 #endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 if (png_ptr->transformations & PNG_BACKGROUND)
 {
 info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
 info_ptr->num_trans = 0;
 info_ptr->background = png_ptr->background;
 }
 #endif
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (png_ptr->transformations & PNG_GAMMA)
 {
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 info_ptr->gamma = png_ptr->gamma;
 #endif
 info_ptr->int_gamma = png_ptr->int_gamma;
 #endif
 }
 #endif
-#if defined(PNG_READ_16_TO_8_SUPPORTED)
+#ifdef PNG_READ_16_TO_8_SUPPORTED
 if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))
 info_ptr->bit_depth = 8;
 #endif
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 if (png_ptr->transformations & PNG_GRAY_TO_RGB)
 info_ptr->color_type |= PNG_COLOR_MASK_COLOR;
 #endif
-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 if (png_ptr->transformations & PNG_RGB_TO_GRAY)
 info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
 #endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
+#ifdef PNG_READ_DITHER_SUPPORTED
 if (png_ptr->transformations & PNG_DITHER)
 {
 if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
 (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
 png_ptr->palette_lookup && info_ptr->bit_depth == 8)
 info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
 }
 }
 #endif
-#if defined(PNG_READ_PACK_SUPPORTED)
+#ifdef PNG_READ_PACK_SUPPORTED
 if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))
 info_ptr->bit_depth = 8;
 #endif
 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
 info_ptr->channels = 3;
 else
 info_ptr->channels = 1;
-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
 info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;
 #endif
 if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
 info_ptr->channels++;
-#if defined(PNG_READ_FILLER_SUPPORTED)
+#ifdef PNG_READ_FILLER_SUPPORTED
 /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
 if ((png_ptr->transformations & PNG_FILLER) &&
 ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
 (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))
 {
 info_ptr->channels++;
 /* If adding a true alpha channel not just filler */
-#if !defined(PNG_1_0_X)
 if (png_ptr->transformations & PNG_ADD_ALPHA)
 info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
-#endif
 }
 #endif
 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
 info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
 info_ptr->bit_depth);
 info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
-#if !defined(PNG_READ_EXPAND_SUPPORTED)
+#ifndef PNG_READ_EXPAND_SUPPORTED
 if (png_ptr)
 return;
 #endif
 }
 */
 void /* PRIVATE */
 png_do_read_transformations(png_structp png_ptr)
 {
 png_debug(1, "in png_do_read_transformations");
 if (png_ptr->row_buf == NULL)
 {
-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
+#ifdef PNG_STDIO_SUPPORTED
 char msg[50];
 png_snprintf2(msg, 50,
 "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,
 png_ptr->pass);
 #else
 png_warning(png_ptr, "Uninitialized row");
 #endif
 #endif
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 if (png_ptr->transformations & PNG_EXPAND)
 {
 if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)
 {
 png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,
-png_ptr->palette, png_ptr->trans, png_ptr->num_trans);
+png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
 }
 else
 {
 if (png_ptr->num_trans &&
 (png_ptr->transformations & PNG_EXPAND_tRNS))
 png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
-&(png_ptr->trans_values));
+&(png_ptr->trans_color));
 else
 png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,
 NULL);
 }
 }
 #endif
-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
+#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)
 png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
 PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));
 #endif
-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 if (png_ptr->transformations & PNG_RGB_TO_GRAY)
 {
 int rgb_error =
 png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);
 if (rgb_error)
 *  performance, as this increases the per-pixel operations.  If we would check
 *  in advance if the background was gray or RGB, and position the gray-to-RGB
 *  transform appropriately, then it would save a lot of work/time.
 */
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 /* If gray -> RGB, do so now only if background is non-gray; else do later
 * for performance reasons
 */
 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
 !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
 png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 if ((png_ptr->transformations & PNG_BACKGROUND) &&
 ((png_ptr->num_trans != 0 ) ||
 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))
 png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,
-&(png_ptr->trans_values), &(png_ptr->background)
+&(png_ptr->trans_color), &(png_ptr->background)
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 , &(png_ptr->background_1),
 png_ptr->gamma_table, png_ptr->gamma_from_1,
 png_ptr->gamma_to_1, png_ptr->gamma_16_table,
 png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,
 png_ptr->gamma_shift
 #endif
 );
 #endif
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if ((png_ptr->transformations & PNG_GAMMA) &&
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
 !((png_ptr->transformations & PNG_BACKGROUND) &&
 ((png_ptr->num_trans != 0) ||
 (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&
 #endif
 (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
 png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,
 png_ptr->gamma_table, png_ptr->gamma_16_table,
 png_ptr->gamma_shift);
 #endif
-#if defined(PNG_READ_16_TO_8_SUPPORTED)
+#ifdef PNG_READ_16_TO_8_SUPPORTED
 if (png_ptr->transformations & PNG_16_TO_8)
 png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
+#ifdef PNG_READ_DITHER_SUPPORTED
 if (png_ptr->transformations & PNG_DITHER)
 {
 png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
 png_ptr->palette_lookup, png_ptr->dither_index);
 if (png_ptr->row_info.rowbytes == (png_uint_32)0)
 png_error(png_ptr, "png_do_dither returned rowbytes=0");
 }
 #endif
-#if defined(PNG_READ_INVERT_SUPPORTED)
+#ifdef PNG_READ_INVERT_SUPPORTED
 if (png_ptr->transformations & PNG_INVERT_MONO)
 png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_SHIFT_SUPPORTED)
+#ifdef PNG_READ_SHIFT_SUPPORTED
 if (png_ptr->transformations & PNG_SHIFT)
 png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,
 &(png_ptr->shift));
 #endif
-#if defined(PNG_READ_PACK_SUPPORTED)
+#ifdef PNG_READ_PACK_SUPPORTED
 if (png_ptr->transformations & PNG_PACK)
 png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_BGR_SUPPORTED)
+#ifdef PNG_READ_BGR_SUPPORTED
 if (png_ptr->transformations & PNG_BGR)
 png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_PACKSWAP_SUPPORTED)
+#ifdef PNG_READ_PACKSWAP_SUPPORTED
 if (png_ptr->transformations & PNG_PACKSWAP)
 png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 /* If gray -> RGB, do so now only if we did not do so above */
 if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&
 (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))
 png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_FILLER_SUPPORTED)
+#ifdef PNG_READ_FILLER_SUPPORTED
 if (png_ptr->transformations & PNG_FILLER)
 png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,
 (png_uint_32)png_ptr->filler, png_ptr->flags);
 #endif
-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 if (png_ptr->transformations & PNG_INVERT_ALPHA)
 png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
 if (png_ptr->transformations & PNG_SWAP_ALPHA)
 png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_SWAP_SUPPORTED)
+#ifdef PNG_READ_SWAP_SUPPORTED
 if (png_ptr->transformations & PNG_SWAP_BYTES)
 png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);
 #endif
-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 if (png_ptr->transformations & PNG_USER_TRANSFORM)
 {
 if (png_ptr->read_user_transform_fn != NULL)
 (*(png_ptr->read_user_transform_fn)) /* User read transform function */
 (png_ptr,                    /* png_ptr */
 /*  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 */
-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 if (png_ptr->user_transform_depth)
 png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;
 if (png_ptr->user_transform_channels)
 png_ptr->row_info.channels = png_ptr->user_transform_channels;
 #endif
 }
 #endif
 }
-#if defined(PNG_READ_PACK_SUPPORTED)
+#ifdef PNG_READ_PACK_SUPPORTED
 /* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,
 * without changing the actual values.  Thus, if you had a row with
 * a bit depth of 1, you would end up with bytes that only contained
 * the numbers 0 or 1.  If you would rather they contain 0 and 255, use
 * png_do_shift() after this.
 */
 void /* PRIVATE */
 png_do_unpack(png_row_infop row_info, png_bytep row)
 {
 png_debug(1, "in png_do_unpack");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
-#else
 if (row_info->bit_depth < 8)
-#endif
 {
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 switch (row_info->bit_depth)
 row_info->rowbytes = row_width * row_info->channels;
 }
 }
 #endif
-#if defined(PNG_READ_SHIFT_SUPPORTED)
+#ifdef PNG_READ_SHIFT_SUPPORTED
 /* Reverse the effects of png_do_shift.  This routine merely shifts the
 * pixels back to their significant bits values.  Thus, if you have
 * a row of bit depth 8, but only 5 are significant, this will shift
 * the values back to 0 through 31.
 */
 void /* PRIVATE */
 png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
 {
 png_debug(1, "in png_do_unshift");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL && sig_bits != NULL &&
-#endif
 row_info->color_type != PNG_COLOR_TYPE_PALETTE)
 {
 int shift[4];
 int channels = 0;
 int c;
 }
 }
 }
 #endif
-#if defined(PNG_READ_16_TO_8_SUPPORTED)
+#ifdef PNG_READ_16_TO_8_SUPPORTED
 /* Chop rows of bit depth 16 down to 8 */
 void /* PRIVATE */
 png_do_chop(png_row_infop row_info, png_bytep row)
 {
 png_debug(1, "in png_do_chop");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
-#else
 if (row_info->bit_depth == 16)
-#endif
 {
 png_bytep sp = row;
 png_bytep dp = row;
 png_uint_32 i;
 png_uint_32 istop = row_info->width * row_info->channels;
 for (i = 0; i<istop; i++, sp += 2, dp++)
 {
-#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)
+#ifdef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
 /* This does a more accurate scaling of the 16-bit color
 * value, rather than a simple low-byte truncation.
 *
 * What the ideal calculation should be:
 *   *dp = (((((png_uint_32)(*sp) << 8) |
 row_info->rowbytes = row_info->width * row_info->channels;
 }
 }
 #endif
-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
+#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
 void /* PRIVATE */
 png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
 {
 png_debug(1, "in png_do_read_swap_alpha");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL)
-#endif
 {
 png_uint_32 row_width = row_info->width;
 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 {
 /* This converts from RGBA to ARGB */
 }
 }
 }
 #endif
-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
+#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
 void /* PRIVATE */
 png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
 {
 png_debug(1, "in png_do_read_invert_alpha");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL)
-#endif
 {
 png_uint_32 row_width = row_info->width;
 if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 {
 /* This inverts the alpha channel in RGBA */
 }
 }
 }
 #endif
-#if defined(PNG_READ_FILLER_SUPPORTED)
+#ifdef PNG_READ_FILLER_SUPPORTED
 /* Add filler channel if we have RGB color */
 void /* PRIVATE */
 png_do_read_filler(png_row_infop row_info, png_bytep row,
 png_uint_32 filler, png_uint_32 flags)
 {
 png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
 png_byte lo_filler = (png_byte)(filler & 0xff);
 png_debug(1, "in png_do_read_filler");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL  && row_info != NULL &&
-#endif
 row_info->color_type == PNG_COLOR_TYPE_GRAY)
 {
 if (row_info->bit_depth == 8)
 {
 /* This changes the data from G to GX */
 }
 } /* COLOR_TYPE == RGB */
 }
 #endif
-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
+#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 /* Expand grayscale files to RGB, with or without alpha */
 void /* PRIVATE */
 png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
 {
 png_uint_32 i;
 png_uint_32 row_width = row_info->width;
 png_debug(1, "in png_do_gray_to_rgb");
 if (row_info->bit_depth >= 8 &&
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 !(row_info->color_type & PNG_COLOR_MASK_COLOR))
 {
 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
 {
 if (row_info->bit_depth == 8)
 row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
 }
 }
 #endif
-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 /* Reduce RGB files to grayscale, with or without alpha
 * using the equation given in Poynton's ColorFAQ at
 * <http://www.inforamp.net/~poynton/>  (THIS LINK IS DEAD June 2008)
 * New link:
 * <http://www.poynton.com/notes/colour_and_gamma/>
 png_uint_32 row_width = row_info->width;
 int rgb_error = 0;
 png_debug(1, "in png_do_rgb_to_gray");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 (row_info->color_type & PNG_COLOR_MASK_COLOR))
 {
 png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;
 png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;
 png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;
 int color_inc;
 int i;
 int v;
 png_debug(1, "in png_do_build_grayscale_palette");
 if (palette == NULL)
 return;
 switch (bit_depth)
 {
 palette[i].green = (png_byte)v;
 palette[i].blue = (png_byte)v;
 }
 }
-/* This function is currently unused.  Do we really need it? */
-#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
+#ifdef PNG_READ_BACKGROUND_SUPPORTED
-void /* PRIVATE */
-png_correct_palette(png_structp png_ptr, png_colorp palette,
-int num_palette)
-{
-png_debug(1, "in png_correct_palette");
-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
-defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
-if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
-{
-png_color back, back_1;
-if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
-{
-back.red = png_ptr->gamma_table[png_ptr->background.red];
-back.green = png_ptr->gamma_table[png_ptr->background.green];
-back.blue = png_ptr->gamma_table[png_ptr->background.blue];
-back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
-back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
-back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
-}
-else
-{
-double g;
-g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);
-if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||
-fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)
-{
-back.red = png_ptr->background.red;
-back.green = png_ptr->background.green;
-back.blue = png_ptr->background.blue;
-}
-else
-{
-back.red =
-(png_byte)(pow((double)png_ptr->background.red/255, g) *
-255.0 + 0.5);
-back.green =
-(png_byte)(pow((double)png_ptr->background.green/255, g) *
-255.0 + 0.5);
-back.blue =
-(png_byte)(pow((double)png_ptr->background.blue/255, g) *
-255.0 + 0.5);
-}
-g = 1.0 / png_ptr->background_gamma;
-back_1.red =
-(png_byte)(pow((double)png_ptr->background.red/255, g) *
-255.0 + 0.5);
-back_1.green =
-(png_byte)(pow((double)png_ptr->background.green/255, g) *
-255.0 + 0.5);
-back_1.blue =
-(png_byte)(pow((double)png_ptr->background.blue/255, g) *
-255.0 + 0.5);
-}
-if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-{
-png_uint_32 i;
-for (i = 0; i < (png_uint_32)num_palette; i++)
-{
-if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)
-{
-palette[i] = back;
-}
-else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)
-{
-png_byte v, w;
-v = png_ptr->gamma_to_1[png_ptr->palette[i].red];
-png_composite(w, v, png_ptr->trans[i], back_1.red);
-palette[i].red = png_ptr->gamma_from_1[w];
-v = png_ptr->gamma_to_1[png_ptr->palette[i].green];
-png_composite(w, v, png_ptr->trans[i], back_1.green);
-palette[i].green = png_ptr->gamma_from_1[w];
-v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];
-png_composite(w, v, png_ptr->trans[i], back_1.blue);
-palette[i].blue = png_ptr->gamma_from_1[w];
-}
-else
-{
-palette[i].red = png_ptr->gamma_table[palette[i].red];
-palette[i].green = png_ptr->gamma_table[palette[i].green];
-palette[i].blue = png_ptr->gamma_table[palette[i].blue];
-}
-}
-}
-else
-{
-int i;
-for (i = 0; i < num_palette; i++)
-{
-if (palette[i].red == (png_byte)png_ptr->trans_values.gray)
-{
-palette[i] = back;
-}
-else
-{
-palette[i].red = png_ptr->gamma_table[palette[i].red];
-palette[i].green = png_ptr->gamma_table[palette[i].green];
-palette[i].blue = png_ptr->gamma_table[palette[i].blue];
-}
-}
-}
-}
-else
-#endif
-#if defined(PNG_READ_GAMMA_SUPPORTED)
-if (png_ptr->transformations & PNG_GAMMA)
-{
-int i;
-for (i = 0; i < num_palette; i++)
-{
-palette[i].red = png_ptr->gamma_table[palette[i].red];
-palette[i].green = png_ptr->gamma_table[palette[i].green];
-palette[i].blue = png_ptr->gamma_table[palette[i].blue];
-}
-}
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-else
-#endif
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
-if (png_ptr->transformations & PNG_BACKGROUND)
-{
-if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-{
-png_color back;
-back.red   = (png_byte)png_ptr->background.red;
-back.green = (png_byte)png_ptr->background.green;
-back.blue  = (png_byte)png_ptr->background.blue;
-for (i = 0; i < (int)png_ptr->num_trans; i++)
-{
-if (png_ptr->trans[i] == 0)
-{
-palette[i].red = back.red;
-palette[i].green = back.green;
-palette[i].blue = back.blue;
-}
-else if (png_ptr->trans[i] != 0xff)
-{
-png_composite(palette[i].red, png_ptr->palette[i].red,
-png_ptr->trans[i], back.red);
-png_composite(palette[i].green, png_ptr->palette[i].green,
-png_ptr->trans[i], back.green);
-png_composite(palette[i].blue, png_ptr->palette[i].blue,
-png_ptr->trans[i], back.blue);
-}
-}
-}
-else /* Assume grayscale palette (what else could it be?) */
-{
-int i;
-for (i = 0; i < num_palette; i++)
-{
-if (i == (png_byte)png_ptr->trans_values.gray)
-{
-palette[i].red = (png_byte)png_ptr->background.red;
-palette[i].green = (png_byte)png_ptr->background.green;
-palette[i].blue = (png_byte)png_ptr->background.blue;
-}
-}
-}
-}
-#endif
-}
-#endif
-#if defined(PNG_READ_BACKGROUND_SUPPORTED)
 /* Replace any alpha or transparency with the supplied background color.
 * "background" is already in the screen gamma, while "background_1" is
 * at a gamma of 1.0.  Paletted files have already been taken care of.
 */
 void /* PRIVATE */
 png_do_background(png_row_infop row_info, png_bytep row,
-png_color_16p trans_values, png_color_16p background
+png_color_16p trans_color, png_color_16p background
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 , png_color_16p background_1,
 png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,
 png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,
 png_uint_16pp gamma_16_to_1, int gamma_shift
 #endif
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 int shift;
 png_debug(1, "in png_do_background");
 if (background != NULL &&
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||
-(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))
+(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color)))
 {
 switch (row_info->color_type)
 {
 case PNG_COLOR_TYPE_GRAY:
 {
 sp = row;
 shift = 7;
 for (i = 0; i < row_width; i++)
 {
 if ((png_uint_16)((*sp >> shift) & 0x01)
-== trans_values->gray)
+== trans_color->gray)
 {
 *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
 *sp |= (png_byte)(background->gray << shift);
 }
 if (!shift)
 break;
 }
 case 2:
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_table != NULL)
 {
 sp = row;
 shift = 6;
 for (i = 0; i < row_width; i++)
 {
 if ((png_uint_16)((*sp >> shift) & 0x03)
-== trans_values->gray)
+== trans_color->gray)
 {
 *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
 *sp |= (png_byte)(background->gray << shift);
 }
 else
 sp = row;
 shift = 6;
 for (i = 0; i < row_width; i++)
 {
 if ((png_uint_16)((*sp >> shift) & 0x03)
-== trans_values->gray)
+== trans_color->gray)
 {
 *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
 *sp |= (png_byte)(background->gray << shift);
 }
 if (!shift)
 break;
 }
 case 4:
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#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)
-== trans_values->gray)
+== trans_color->gray)
 {
 *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
 *sp |= (png_byte)(background->gray << shift);
 }
 else
 sp = row;
 shift = 4;
 for (i = 0; i < row_width; i++)
 {
 if ((png_uint_16)((*sp >> shift) & 0x0f)
-== trans_values->gray)
+== trans_color->gray)
 {
 *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
 *sp |= (png_byte)(background->gray << shift);
 }
 if (!shift)
 break;
 }
 case 8:
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_table != NULL)
 {
 sp = row;
 for (i = 0; i < row_width; i++, sp++)
 {
-if (*sp == trans_values->gray)
+if (*sp == trans_color->gray)
 {
 *sp = (png_byte)background->gray;
 }
 else
 {
 #endif
 {
 sp = row;
 for (i = 0; i < row_width; i++, sp++)
 {
-if (*sp == trans_values->gray)
+if (*sp == trans_color->gray)
 {
 *sp = (png_byte)background->gray;
 }
 }
 }
 break;
 }
 case 16:
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#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 == trans_values->gray)
+if (v == trans_color->gray)
 {
 /* Background is already in screen gamma */
 *sp = (png_byte)((background->gray >> 8) & 0xff);
 *(sp + 1) = (png_byte)(background->gray & 0xff);
 }
 for (i = 0; i < row_width; i++, sp += 2)
 {
 png_uint_16 v;
 v = (png_uint_16)(((*sp) << 8) + *(sp + 1));
-if (v == trans_values->gray)
+if (v == trans_color->gray)
 {
 *sp = (png_byte)((background->gray >> 8) & 0xff);
 *(sp + 1) = (png_byte)(background->gray & 0xff);
 }
 }
 case PNG_COLOR_TYPE_RGB:
 {
 if (row_info->bit_depth == 8)
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_table != NULL)
 {
 sp = row;
 for (i = 0; i < row_width; i++, sp += 3)
 {
-if (*sp == trans_values->red &&
+if (*sp == trans_color->red &&
-*(sp + 1) == trans_values->green &&
+*(sp + 1) == trans_color->green &&
-*(sp + 2) == trans_values->blue)
+*(sp + 2) == trans_color->blue)
 {
 *sp = (png_byte)background->red;
 *(sp + 1) = (png_byte)background->green;
 *(sp + 2) = (png_byte)background->blue;
 }
 #endif
 {
 sp = row;
 for (i = 0; i < row_width; i++, sp += 3)
 {
-if (*sp == trans_values->red &&
+if (*sp == trans_color->red &&
-*(sp + 1) == trans_values->green &&
+*(sp + 1) == trans_color->green &&
-*(sp + 2) == trans_values->blue)
+*(sp + 2) == trans_color->blue)
 {
 *sp = (png_byte)background->red;
 *(sp + 1) = (png_byte)background->green;
 *(sp + 2) = (png_byte)background->blue;
 }
 }
 }
 }
 else /* if (row_info->bit_depth == 16) */
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#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 == trans_values->red && g == trans_values->green &&
+if (r == trans_color->red && g == trans_color->green &&
-b == trans_values->blue)
+b == trans_color->blue)
 {
 /* Background is already in screen gamma */
 *sp = (png_byte)((background->red >> 8) & 0xff);
 *(sp + 1) = (png_byte)(background->red & 0xff);
 *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
 {
 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 == trans_values->red && g == trans_values->green &&
+if (r == trans_color->red && g == trans_color->green &&
-b == trans_values->blue)
+b == trans_color->blue)
 {
 *sp = (png_byte)((background->red >> 8) & 0xff);
 *(sp + 1) = (png_byte)(background->red & 0xff);
 *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);
 *(sp + 3) = (png_byte)(background->green & 0xff);
 case PNG_COLOR_TYPE_GRAY_ALPHA:
 {
 if (row_info->bit_depth == 8)
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
 gamma_table != NULL)
 {
 sp = row;
 dp = row;
 if (a == 0xff)
 {
 *dp = *sp;
 }
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 else if (a == 0)
 {
 *dp = (png_byte)background->gray;
 }
 else
 }
 }
 }
 else /* if (png_ptr->bit_depth == 16) */
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
 gamma_16_to_1 != NULL)
 {
 sp = row;
 dp = row;
 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];
 *dp = (png_byte)((v >> 8) & 0xff);
 *(dp + 1) = (png_byte)(v & 0xff);
 }
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 else if (a == 0)
 #else
 else
 #endif
 {
 /* Background is already in screen gamma */
 *dp = (png_byte)((background->gray >> 8) & 0xff);
 *(dp + 1) = (png_byte)(background->gray & 0xff);
 }
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 else
 {
 png_uint_16 g, v, w;
 g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];
 png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));
 if (a == (png_uint_16)0xffff)
 {
 png_memcpy(dp, sp, 2);
 }
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 else if (a == 0)
 #else
 else
 #endif
 {
 *dp = (png_byte)((background->gray >> 8) & 0xff);
 *(dp + 1) = (png_byte)(background->gray & 0xff);
 }
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 else
 {
 png_uint_16 g, v;
 g = (png_uint_16)(((*sp) << 8) + *(sp + 1));
 case PNG_COLOR_TYPE_RGB_ALPHA:
 {
 if (row_info->bit_depth == 8)
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_to_1 != NULL && gamma_from_1 != NULL &&
 gamma_table != NULL)
 {
 sp = row;
 dp = row;
 }
 }
 }
 else /* if (row_info->bit_depth == 16) */
 {
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 if (gamma_16 != NULL && gamma_16_from_1 != NULL &&
 gamma_16_to_1 != NULL)
 {
 sp = row;
 dp = row;
 }
 }
 }
 #endif
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 /* Gamma correct the image, avoiding the alpha channel.  Make sure
 * you do this after you deal with the transparency issue on grayscale
 * or RGB images. If your bit depth is 8, use gamma_table, if it
 * is 16, use gamma_16_table and gamma_shift.  Build these with
 * build_gamma_table().
 png_bytep sp;
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 png_debug(1, "in png_do_gamma");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 ((row_info->bit_depth <= 8 && gamma_table != NULL) ||
 (row_info->bit_depth == 16 && gamma_16_table != NULL)))
 {
 switch (row_info->color_type)
 {
 }
 }
 }
 #endif
-#if defined(PNG_READ_EXPAND_SUPPORTED)
+#ifdef PNG_READ_EXPAND_SUPPORTED
 /* Expands a palette row to an RGB or RGBA row depending
 * upon whether you supply trans and num_trans.
 */
 void /* PRIVATE */
 png_do_expand_palette(png_row_infop row_info, png_bytep row,
-png_colorp palette, png_bytep trans, int num_trans)
+png_colorp palette, png_bytep trans_alpha, int num_trans)
 {
 int shift, value;
 png_bytep sp, dp;
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 png_debug(1, "in png_do_expand_palette");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 row_info->color_type == PNG_COLOR_TYPE_PALETTE)
 {
 if (row_info->bit_depth < 8)
 {
 switch (row_info->bit_depth)
 }
 switch (row_info->bit_depth)
 {
 case 8:
 {
-if (trans != NULL)
+if (trans_alpha != NULL)
 {
 sp = row + (png_size_t)row_width - 1;
 dp = row + (png_size_t)(row_width << 2) - 1;
 for (i = 0; i < row_width; i++)
 {
 if ((int)(*sp) >= num_trans)
 *dp-- = 0xff;
 else
-*dp-- = trans[*sp];
+*dp-- = trans_alpha[*sp];
 *dp-- = palette[*sp].blue;
 *dp-- = palette[*sp].green;
 *dp-- = palette[*sp].red;
 sp--;
 }
 png_bytep sp, dp;
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 png_debug(1, "in png_do_expand");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL)
-#endif
 {
 if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
 {
 png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);
 }
 }
 }
 #endif
-#if defined(PNG_READ_DITHER_SUPPORTED)
+#ifdef PNG_READ_DITHER_SUPPORTED
 void /* PRIVATE */
 png_do_dither(png_row_infop row_info, png_bytep row,
 png_bytep palette_lookup, png_bytep dither_lookup)
 {
 png_bytep sp, dp;
 png_uint_32 i;
 png_uint_32 row_width=row_info->width;
 png_debug(1, "in png_do_dither");
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-if (row != NULL && row_info != NULL)
-#endif
 {
 if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
 palette_lookup && row_info->bit_depth == 8)
 {
 int r, g, b, p;
 }
 }
 #endif
 #ifdef PNG_FLOATING_POINT_SUPPORTED
-#if defined(PNG_READ_GAMMA_SUPPORTED)
+#ifdef PNG_READ_GAMMA_SUPPORTED
 static PNG_CONST int png_gamma_shift[] =
 {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};
 /* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit
 * tables, we don't make a full table if we are reducing to 8-bit in
 * the future.  Note also how the gamma_16 tables are segmented so that
 * we don't need to allocate > 64K chunks for a full 16-bit table.
+*
+* See the PNG extensions document for an integer algorithm for creating
+* the gamma tables.  Maybe we will implement that here someday.
+*
+* We should only reach this point if
+*
+*      the file_gamma is known (i.e., the gAMA or sRGB chunk is present,
+*      or the application has provided a file_gamma)
+*
+*   AND
+*      {
+*         the screen_gamma is known
+*
+*      OR
+*
+*         RGB_to_gray transformation is being performed
+*      }
+*
+*   AND
+*      {
+*         the screen_gamma is different from the reciprocal of the
+*         file_gamma by more than the specified threshold
+*
+*      OR
+*
+*         a background color has been specified and the file_gamma
+*         and screen_gamma are not 1.0, within the specified threshold.
+*      }
 */
 void /* PRIVATE */
-png_build_gamma_table(png_structp png_ptr)
+png_build_gamma_table(png_structp png_ptr, png_byte bit_depth)
 {
 png_debug(1, "in png_build_gamma_table");
-if (png_ptr->bit_depth <= 8)
+if (bit_depth <= 8)
 {
 int i;
 double g;
 if (png_ptr->screen_gamma > .000001)
 if (png_ptr->screen_gamma > .000001)
 g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);
 else
 g = 1.0;
-png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
+png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr,
 (png_uint_32)(num * png_sizeof(png_uint_16p)));
-png_memset(png_ptr->gamma_16_table, 0, num * png_sizeof(png_uint_16p));
 if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
 {
 double fin, fout;
 png_uint_32 last, max;
 if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))
 {
 g = 1.0 / (png_ptr->gamma);
-png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
+png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr,
 (png_uint_32)(num * png_sizeof(png_uint_16p )));
-png_memset(png_ptr->gamma_16_to_1, 0, num * png_sizeof(png_uint_16p));
 for (i = 0; i < num; i++)
 {
 png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
 (png_uint_32)(256 * png_sizeof(png_uint_16)));
 g = 1.0 / png_ptr->screen_gamma;
 else
 g = png_ptr->gamma;   /* Probably doing rgb_to_gray */
-png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
+png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr,
 (png_uint_32)(num * png_sizeof(png_uint_16p)));
-png_memset(png_ptr->gamma_16_from_1, 0,
-num * png_sizeof(png_uint_16p));
 for (i = 0; i < num; i++)
 {
 png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
 (png_uint_32)(256 * png_sizeof(png_uint_16)));
 }
 #endif
 /* To do: install integer version of png_build_gamma_table here */
 #endif
-#if defined(PNG_MNG_FEATURES_SUPPORTED)
+#ifdef PNG_MNG_FEATURES_SUPPORTED
 /* Undoes intrapixel differencing  */
 void /* PRIVATE */
 png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
 {
 png_debug(1, "in png_do_read_intrapixel");
 if (
-#if defined(PNG_USELESS_TESTS_SUPPORTED)
-row != NULL && row_info != NULL &&
-#endif
 (row_info->color_type & PNG_COLOR_MASK_COLOR))
 {
 int bytes_per_pixel;
 png_uint_32 row_width = row_info->width;
 if (row_info->bit_depth == 8)

changeset 30	5dc02b23752f
parent 0	1918ee327afb