replaced T() makro with wxT() due to namespace probs, _T() exists, too

[wxWidgets.git] / src / png / pngrutil.c

diff --git a/src/png/pngrutil.c b/src/png/pngrutil.c
index 1c379069391ec763fbfb214db0dd90125004564c..9320a7107c76a375cfced7c35742afb9795a43b1 100644 (file)
--- a/src/png/pngrutil.c
+++ b/src/png/pngrutil.c
@@ -1,14 +1,13 @@
 
 /* pngrutil.c - utilities to read a PNG file
  *
 
 /* pngrutil.c - utilities to read a PNG file
  *

- * libpng 1.0.1
+ * libpng 1.0.3 - January 14, 1999

  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger
  * For conditions of distribution and use, see copyright notice in png.h
  * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  * Copyright (c) 1996, 1997 Andreas Dilger

- * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 15, 1998
+ * Copyright (c) 1998, 1999 Glenn Randers-Pehrson

  *
  *

- * This file contains routines which are only called from within
+ * This file contains routines that are only called from within

  * libpng itself during the course of reading an image.
  */
 
  * libpng itself during the course of reading an image.
  */
 


@@ -16,13 +15,11 @@
 #include "png.h"
 
 #ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
 #include "png.h"
 
 #ifndef PNG_READ_BIG_ENDIAN_SUPPORTED

-/* Grab an unsigned 32-bit integer from a buffer in big endian format. */
+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */

 png_uint_32
 png_get_uint_32(png_bytep buf)
 {
 png_uint_32
 png_get_uint_32(png_bytep buf)
 {

-   png_uint_32 i;
-
-   i = ((png_uint_32)(*buf) << 24) +
+   png_uint_32 i = ((png_uint_32)(*buf) << 24) +

       ((png_uint_32)(*(buf + 1)) << 16) +
       ((png_uint_32)(*(buf + 2)) << 8) +
       (png_uint_32)(*(buf + 3));
       ((png_uint_32)(*(buf + 1)) << 16) +
       ((png_uint_32)(*(buf + 2)) << 8) +
       (png_uint_32)(*(buf + 3));


@@ -31,15 +28,13 @@ png_get_uint_32(png_bytep buf)
 }
 
 #if defined(PNG_READ_pCAL_SUPPORTED)
 }
 
 #if defined(PNG_READ_pCAL_SUPPORTED)

-/* Grab a signed 32-bit integer from a buffer in big endian format.  The
+/* Grab a signed 32-bit integer from a buffer in big-endian format.  The

  * data is stored in the PNG file in two's complement format, and it is
  * assumed that the machine format for signed integers is the same. */
 png_int_32
 png_get_int_32(png_bytep buf)
 {
  * data is stored in the PNG file in two's complement format, and it is
  * assumed that the machine format for signed integers is the same. */
 png_int_32
 png_get_int_32(png_bytep buf)
 {

-   png_int_32 i;
-
-   i = ((png_int_32)(*buf) << 24) +
+   png_int_32 i = ((png_int_32)(*buf) << 24) +

       ((png_int_32)(*(buf + 1)) << 16) +
       ((png_int_32)(*(buf + 2)) << 8) +
       (png_int_32)(*(buf + 3));
       ((png_int_32)(*(buf + 1)) << 16) +
       ((png_int_32)(*(buf + 2)) << 8) +
       (png_int_32)(*(buf + 3));


@@ -48,13 +43,11 @@ png_get_int_32(png_bytep buf)
 }
 #endif /* PNG_READ_pCAL_SUPPORTED */
 
 }
 #endif /* PNG_READ_pCAL_SUPPORTED */
 

-/* Grab an unsigned 16-bit integer from a buffer in big endian format. */
+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */

 png_uint_16
 png_get_uint_16(png_bytep buf)
 {
 png_uint_16
 png_get_uint_16(png_bytep buf)
 {

-   png_uint_16 i;
-
-   i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
+   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +

       (png_uint_16)(*(buf + 1)));
 
    return (i);
       (png_uint_16)(*(buf + 1)));
 
    return (i);


@@ -76,15 +69,16 @@ png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
 int
 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
 {
 int
 png_crc_finish(png_structp png_ptr, png_uint_32 skip)
 {

-   png_uint_32 i;
+   png_size_t i;
+   png_size_t istop = png_ptr->zbuf_size;

 
 

-   for (i = skip; i > (png_uint_32)png_ptr->zbuf_size; i -= png_ptr->zbuf_size)
+   for (i = (png_size_t)skip; i > istop; i -= istop)

    {
       png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
    }
    if (i)
    {
    {
       png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
    }
    if (i)
    {

-      png_crc_read(png_ptr, png_ptr->zbuf, (png_size_t)i);
+      png_crc_read(png_ptr, png_ptr->zbuf, i);

    }
 
    if (png_crc_error(png_ptr))
    }
 
    if (png_crc_error(png_ptr))


@@ -258,20 +252,6 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
    png_ptr->mode |= PNG_HAVE_PLTE;
 
 
    png_ptr->mode |= PNG_HAVE_PLTE;
 

-#if defined (PNG_READ_tRNS_SUPPORTED)
-   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-   {
-      if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
-      {
-         if (png_ptr->num_trans > png_ptr->num_palette)
-         {
-            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
-            png_ptr->num_trans = png_ptr->num_palette;
-         }
-      }
-   }
-#endif
-

 #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
    if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
    {
 #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
    if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
    {


@@ -349,6 +329,21 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
    png_ptr->palette = palette;
    png_ptr->num_palette = (png_uint_16)num;
    png_set_PLTE(png_ptr, info_ptr, palette, num);
    png_ptr->palette = palette;
    png_ptr->num_palette = (png_uint_16)num;
    png_set_PLTE(png_ptr, info_ptr, palette, num);

+
+#if defined (PNG_READ_tRNS_SUPPORTED)
+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
+   {
+      if (info_ptr != NULL && info_ptr->valid & PNG_INFO_tRNS)
+      {
+         if (png_ptr->num_trans > png_ptr->num_palette)
+         {
+            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");
+            png_ptr->num_trans = png_ptr->num_palette;
+         }
+      }
+   }
+#endif
+

 }
 
 void
 }
 
 void


@@ -429,7 +424,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
       {
          png_warning(png_ptr,
            "Ignoring incorrect gAMA value when sRGB is also present");
       {
          png_warning(png_ptr,
            "Ignoring incorrect gAMA value when sRGB is also present");

-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_CONSOLE_IO

          fprintf(stderr, "igamma = %lu\n", igamma);
 #endif
          return;
          fprintf(stderr, "igamma = %lu\n", igamma);
 #endif
          return;


@@ -501,6 +496,9 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
    else
    {
       png_ptr->sig_bit.gray = buf[0];
    else
    {
       png_ptr->sig_bit.gray = buf[0];

+      png_ptr->sig_bit.red = buf[0];
+      png_ptr->sig_bit.green = buf[0];
+      png_ptr->sig_bit.blue = buf[0];

       png_ptr->sig_bit.alpha = buf[1];
    }
    png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
       png_ptr->sig_bit.alpha = buf[1];
    }
    png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));


@@ -629,7 +627,7 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 
             png_warning(png_ptr,
               "Ignoring incorrect cHRM value when sRGB is also present");
 
             png_warning(png_ptr,
               "Ignoring incorrect cHRM value when sRGB is also present");

-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_CONSOLE_IO

             fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n",
                white_x, white_y, red_x, red_y);
             fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n",
             fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n",
                white_x, white_y, red_x, red_y);
             fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n",


@@ -698,7 +696,7 @@ png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
       {
          png_warning(png_ptr,
            "Ignoring incorrect gAMA value when sRGB is also present");
       {
          png_warning(png_ptr,
            "Ignoring incorrect gAMA value when sRGB is also present");

-#ifndef PNG_NO_STDIO
+#ifndef PNG_NO_CONSOLE_IO

            fprintf(stderr,"gamma=%f\n",png_ptr->gamma);
 #endif
       }
            fprintf(stderr,"gamma=%f\n",png_ptr->gamma);
 #endif
       }


@@ -758,6 +756,12 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
          png_crc_finish(png_ptr, length);
          return;
       }
          png_crc_finish(png_ptr, length);
          return;
       }

+      if (length == 0)
+      {
+         png_warning(png_ptr, "Zero length tRNS chunk");
+         png_crc_finish(png_ptr, length);
+         return;
+      }

 
       png_ptr->trans = (png_bytep)png_malloc(png_ptr, length);
       png_ptr->flags |= PNG_FLAG_FREE_TRANS;
 
       png_ptr->trans = (png_bytep)png_malloc(png_ptr, length);
       png_ptr->flags |= PNG_FLAG_FREE_TRANS;


@@ -1075,7 +1079,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
    purpose[slength] = 0x00; /* null terminate the last string */
 
    png_debug(3, "Finding end of pCAL purpose string\n");
    purpose[slength] = 0x00; /* null terminate the last string */
 
    png_debug(3, "Finding end of pCAL purpose string\n");

-   for (buf = purpose; *buf != '\0'; buf++)
+   for (buf = purpose; *buf; buf++)

       /* empty loop */ ;
 
    endptr = purpose + slength;
       /* empty loop */ ;
 
    endptr = purpose + slength;


@@ -1113,7 +1117,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
       png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
    }
 
       png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
    }
 

-   for (buf = units; *buf != 0x00; buf++)
+   for (buf = units; *buf; buf++)

       /* Empty loop to move past the units string. */ ;
 
    png_debug(3, "Allocating pCAL parameters array\n");
       /* Empty loop to move past the units string. */ ;
 
    png_debug(3, "Allocating pCAL parameters array\n");


@@ -1465,13 +1469,13 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
    }
 }
 
    }
 }
 

-/* Combines the row recently read in with the previous row.
-   This routine takes care of alpha and transparency if requested.
+/* Combines the row recently read in with the existing pixels in the
+   row.  This routine takes care of alpha and transparency if requested.

    This routine also handles the two methods of progressive display
    of interlaced images, depending on the mask value.
    The mask value describes which pixels are to be combined with
    the row.  The pattern always repeats every 8 pixels, so just 8
    This routine also handles the two methods of progressive display
    of interlaced images, depending on the mask value.
    The mask value describes which pixels are to be combined with
    the row.  The pattern always repeats every 8 pixels, so just 8

-   bits are needed.  A one indicates the pixels is to be combined,
+   bits are needed.  A one indicates the pixel is to be combined,

    a zero indicates the pixel is to be skipped.  This is in addition
    to any alpha or transparency value associated with the pixel.  If
    you want all pixels to be combined, pass 0xff (255) in mask.  */
    a zero indicates the pixel is to be skipped.  This is in addition
    to any alpha or transparency value associated with the pixel.  If
    you want all pixels to be combined, pass 0xff (255) in mask.  */


@@ -1492,16 +1496,14 @@ png_combine_row(png_structp png_ptr, png_bytep row,
       {
          case 1:
          {
       {
          case 1:
          {

-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;

             int s_inc, s_start, s_end;
             int s_inc, s_start, s_end;

-            int m;
+            int m = 0x80;

             int shift;
             png_uint_32 i;
             int shift;
             png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

 
 

-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {


@@ -1519,7 +1521,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
 
             shift = s_start;
 
 
             shift = s_start;
 

-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)

             {
                if (m & mask)
                {
             {
                if (m & mask)
                {


@@ -1548,17 +1550,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          case 2:
          {
          }
          case 2:
          {

-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;

             int s_start, s_end, s_inc;
             int s_start, s_end, s_inc;

-            int m;
+            int m = 0x80;

             int shift;
             png_uint_32 i;
             int shift;
             png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

             int value;
 
             int value;
 

-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {


@@ -1576,7 +1576,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
 
             shift = s_start;
 
 
             shift = s_start;
 

-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)

             {
                if (m & mask)
                {
             {
                if (m & mask)
                {


@@ -1602,17 +1602,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          case 4:
          {
          }
          case 4:
          {

-            png_bytep sp;
-            png_bytep dp;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;

             int s_start, s_end, s_inc;
             int s_start, s_end, s_inc;

-            int m;
+            int m = 0x80;

             int shift;
             png_uint_32 i;
             int shift;
             png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

             int value;
 
             int value;
 

-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (png_ptr->transformations & PNG_PACKSWAP)
             {


@@ -1629,7 +1627,7 @@ png_combine_row(png_structp png_ptr, png_bytep row,
             }
             shift = s_start;
 
             }
             shift = s_start;
 

-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)

             {
                if (m & mask)
                {
             {
                if (m & mask)
                {


@@ -1655,18 +1653,15 @@ png_combine_row(png_structp png_ptr, png_bytep row,
          }
          default:
          {
          }
          default:
          {

-            png_bytep sp;
-            png_bytep dp;
-            png_size_t pixel_bytes;
+            png_bytep sp = png_ptr->row_buf + 1;
+            png_bytep dp = row;
+            png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

             png_uint_32 i;
             png_uint_32 i;

-            png_byte m;
+            png_uint_32 row_width = png_ptr->width;
+            png_byte m = 0x80;

 
 

-            pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

 
 

-            sp = png_ptr->row_buf + 1;
-            dp = row;
-            m = 0x80;
-            for (i = 0; i < png_ptr->width; i++)
+            for (i = 0; i < row_width; i++)

             {
                if (m & mask)
                {
             {
                if (m & mask)
                {


@@ -1703,15 +1698,15 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
       {
          case 1:
          {
       {
          case 1:
          {

-            png_bytep sp, dp;
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);

             int sshift, dshift;
             int s_start, s_end, s_inc;
             int sshift, dshift;
             int s_start, s_end, s_inc;

+            int jstop = png_pass_inc[pass];

             png_byte v;
             png_uint_32 i;
             int j;
 
             png_byte v;
             png_uint_32 i;
             int j;
 

-            sp = row + (png_size_t)((row_info->width - 1) >> 3);
-            dp = row + (png_size_t)((final_width - 1) >> 3);

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {


@@ -1731,10 +1726,10 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                 s_inc = 1;
             }
 
                 s_inc = 1;
             }
 

-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)

             {
                v = (png_byte)((*sp >> sshift) & 0x1);
             {
                v = (png_byte)((*sp >> sshift) & 0x1);

-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)

                {
                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
                {
                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);


@@ -1758,13 +1753,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          case 2:
          {
          }
          case 2:
          {

-            png_bytep sp, dp;
+            png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);
+            png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);

             int sshift, dshift;
             int s_start, s_end, s_inc;
             int sshift, dshift;
             int s_start, s_end, s_inc;

+            int jstop = png_pass_inc[pass];

             png_uint_32 i;
 
             png_uint_32 i;
 

-            sp = row + (png_uint_32)((row_info->width - 1) >> 2);
-            dp = row + (png_uint_32)((final_width - 1) >> 2);

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {


@@ -1784,13 +1779,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                s_inc = 2;
             }
 
                s_inc = 2;
             }
 

-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)

             {
                png_byte v;
                int j;
 
                v = (png_byte)((*sp >> sshift) & 0x3);
             {
                png_byte v;
                int j;
 
                v = (png_byte)((*sp >> sshift) & 0x3);

-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)

                {
                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
                {
                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);


@@ -1814,13 +1809,13 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          case 4:
          {
          }
          case 4:
          {

-            png_bytep sp, dp;
+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);

             int sshift, dshift;
             int s_start, s_end, s_inc;
             png_uint_32 i;
             int sshift, dshift;
             int s_start, s_end, s_inc;
             png_uint_32 i;

+            int jstop = png_pass_inc[pass];

 
 

-            sp = row + (png_size_t)((row_info->width - 1) >> 1);
-            dp = row + (png_size_t)((final_width - 1) >> 1);

 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
             if (transformations & PNG_PACKSWAP)
             {


@@ -1840,13 +1835,12 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
                s_inc = 4;
             }
 
                s_inc = 4;
             }
 

-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)

             {
             {

-               png_byte v;
+               png_byte v = (png_byte)((*sp >> sshift) & 0xf);

                int j;
 
                int j;
 

-               v = (png_byte)((*sp >> sshift) & 0xf);
-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)

                {
                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);
                {
                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
                   *dp |= (png_byte)(v << dshift);


@@ -1870,21 +1864,19 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
          }
          default:
          {
          }
          default:
          {

-            png_bytep sp, dp;
+            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
+            png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
+            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
+            int jstop = png_pass_inc[pass];

             png_uint_32 i;
             png_uint_32 i;

-            png_size_t pixel_bytes;

 
 

-            pixel_bytes = (row_info->pixel_depth >> 3);
-
-            sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;
-            dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
-            for (i = row_info->width; i; i--)
+            for (i = 0; i < row_info->width; i++)

             {
                png_byte v[8];
                int j;
 
                png_memcpy(v, sp, pixel_bytes);
             {
                png_byte v[8];
                int j;
 
                png_memcpy(v, sp, pixel_bytes);

-               for (j = 0; j < png_pass_inc[pass]; j++)
+               for (j = 0; j < jstop; j++)

                {
                   png_memcpy(dp, v, pixel_bytes);
                   dp -= pixel_bytes;
                {
                   png_memcpy(dp, v, pixel_bytes);
                   dp -= pixel_bytes;


@@ -1916,97 +1908,112 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
       case PNG_FILTER_VALUE_SUB:
       {
          png_uint_32 i;
       case PNG_FILTER_VALUE_SUB:
       {
          png_uint_32 i;

-         int bpp;
-         png_bytep rp;
-         png_bytep lp;
+         png_uint_32 istop = row_info->rowbytes;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_bytep rp = row + bpp;
+         png_bytep lp = row;

 
 

-         bpp = (row_info->pixel_depth + 7) / 8;
-         for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
-            i < row_info->rowbytes; i++, rp++, lp++)
+         for (i = bpp; i < istop; i++)

          {
          {

-            *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
+            *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
+            rp++;

          }
          break;
       }
       case PNG_FILTER_VALUE_UP:
       {
          png_uint_32 i;
          }
          break;
       }
       case PNG_FILTER_VALUE_UP:
       {
          png_uint_32 i;

-         png_bytep rp;
-         png_bytep pp;
+         png_uint_32 istop = row_info->rowbytes;
+         png_bytep rp = row;
+         png_bytep pp = prev_row;

 
 

-         for (i = 0, rp = row, pp = prev_row;
-            i < row_info->rowbytes; i++, rp++, pp++)
+         for (i = 0; i < istop; i++)

          {
          {

-            *rp = (png_byte)(((int)(*rp) + (int)(*pp)) & 0xff);
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;

          }
          break;
       }
       case PNG_FILTER_VALUE_AVG:
       {
          png_uint_32 i;
          }
          break;
       }
       case PNG_FILTER_VALUE_AVG:
       {
          png_uint_32 i;

-         int bpp;
-         png_bytep rp;
-         png_bytep pp;
-         png_bytep lp;
-
-         bpp = (row_info->pixel_depth + 7) / 8;
-         for (i = 0, rp = row, pp = prev_row;
-            i < (png_uint_32)bpp; i++, rp++, pp++)
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_uint_32 istop = row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)

          {
             *rp = (png_byte)(((int)(*rp) +
          {
             *rp = (png_byte)(((int)(*rp) +

-               ((int)(*pp) / 2)) & 0xff);
+               ((int)(*pp++) / 2)) & 0xff);
+            rp++;

          }
          }

-         for (lp = row; i < row_info->rowbytes; i++, rp++, lp++, pp++)
+
+         for (i = 0; i < istop; i++)

          {
             *rp = (png_byte)(((int)(*rp) +
          {
             *rp = (png_byte)(((int)(*rp) +

-               (int)(*pp + *lp) / 2) & 0xff);
+               (int)(*pp++ + *lp++) / 2) & 0xff);
+            rp++;

          }
          break;
       }
       case PNG_FILTER_VALUE_PAETH:
       {
          }
          break;
       }
       case PNG_FILTER_VALUE_PAETH:
       {

-         int bpp;

          png_uint_32 i;
          png_uint_32 i;

-         png_bytep rp;
-         png_bytep pp;
-         png_bytep lp;
-         png_bytep cp;
-
-         bpp = (row_info->pixel_depth + 7) / 8;
-         for (i = 0, rp = row, pp = prev_row,
-            lp = row - bpp, cp = prev_row - bpp;
-            i < row_info->rowbytes; i++, rp++, pp++, lp++, cp++)
+         png_bytep rp = row;
+         png_bytep pp = prev_row;
+         png_bytep lp = row;
+         png_bytep cp = prev_row;
+         png_uint_32 bpp = (row_info->pixel_depth + 7) / 8;
+         png_uint_32 istop=row_info->rowbytes - bpp;
+
+         for (i = 0; i < bpp; i++)
+         {
+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
+            rp++;
+         }
+
+         for (i = 0; i < istop; i++)   /* use leftover rp,pp */

          {
             int a, b, c, pa, pb, pc, p;
 
          {
             int a, b, c, pa, pb, pc, p;
 

-            b = *pp;
-            if (i >= (png_uint_32)bpp)
-            {
-               c = *cp;
-               a = *lp;
-            }
-            else
-            {
-               a = c = 0;
-            }
-            p = a + b - c;
-            pa = abs(p - a);
-            pb = abs(p - b);
-            pc = abs(p - c);
-
-            if (pa <= pb && pa <= pc)
-               p = a;
-            else if (pb <= pc)
-               p = b;
-            else
-               p = c;
+            a = *lp++;
+            b = *pp++;
+            c = *cp++;
+
+            p = b - c;
+            pc = a - c;
+
+#ifdef PNG_USE_ABS
+            pa = abs(p);
+            pb = abs(pc);
+            pc = abs(p + pc);
+#else
+            pa = p < 0 ? -p : p;
+            pb = pc < 0 ? -pc : pc;
+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+#endif
+
+            /*
+               if (pa <= pb && pa <= pc)
+                  p = a;
+               else if (pb <= pc)
+                  p = b;
+               else
+                  p = c;
+             */
+
+            p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

 
             *rp = (png_byte)(((int)(*rp) + p) & 0xff);
 
             *rp = (png_byte)(((int)(*rp) + p) & 0xff);

+            rp++;

          }
          break;
       }
       default:
          }
          break;
       }
       default:

-         png_error(png_ptr, "Bad adaptive filter type");
+         png_warning(png_ptr, "Ignoring bad adaptive filter type");
+         *row=0;

          break;
    }
 }
          break;
    }
 }


@@ -2044,7 +2051,7 @@ png_read_finish_row(png_structp png_ptr)
             if (!(png_ptr->num_rows))
                continue;
          }
             if (!(png_ptr->num_rows))
                continue;
          }

-         if (png_ptr->transformations & PNG_INTERLACE)
+         else  /* if (png_ptr->transformations & PNG_INTERLACE) */

             break;
       } while (png_ptr->iwidth == 0);
 
             break;
       } while (png_ptr->iwidth == 0);
 


@@ -2118,7 +2125,7 @@ void
 png_read_start_row(png_structp png_ptr)
 {
    int max_pixel_depth;
 png_read_start_row(png_structp png_ptr)
 {
    int max_pixel_depth;

-   png_uint_32 rowbytes;
+   png_uint_32 row_bytes;

 
    png_debug(1, "in png_read_start_row\n");
    png_ptr->zstream.avail_in = 0;
 
    png_debug(1, "in png_read_start_row\n");
    png_ptr->zstream.avail_in = 0;


@@ -2136,10 +2143,10 @@ png_read_start_row(png_structp png_ptr)
          png_pass_start[png_ptr->pass]) /
          png_pass_inc[png_ptr->pass];
 
          png_pass_start[png_ptr->pass]) /
          png_pass_inc[png_ptr->pass];
 

-         rowbytes = ((png_ptr->iwidth *
+         row_bytes = ((png_ptr->iwidth *

             (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1;
             (png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1;

-         png_ptr->irowbytes = (png_size_t)rowbytes;
-         if((png_uint_32)png_ptr->irowbytes != rowbytes)
+         png_ptr->irowbytes = (png_size_t)row_bytes;
+         if((png_uint_32)png_ptr->irowbytes != row_bytes)

             png_error(png_ptr, "Rowbytes overflow in png_read_start_row");
    }
    else
             png_error(png_ptr, "Rowbytes overflow in png_read_start_row");
    }
    else


@@ -2186,27 +2193,47 @@ png_read_start_row(png_structp png_ptr)
 #if defined(PNG_READ_FILLER_SUPPORTED)
    if (png_ptr->transformations & (PNG_FILLER))
    {
 #if defined(PNG_READ_FILLER_SUPPORTED)
    if (png_ptr->transformations & (PNG_FILLER))
    {

-      if (max_pixel_depth < 32)
+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

          max_pixel_depth = 32;
          max_pixel_depth = 32;

+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         if (max_pixel_depth <= 8)
+            max_pixel_depth = 16;
+         else
+            max_pixel_depth = 32;
+      }
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
+      {
+         if (max_pixel_depth <= 32)
+            max_pixel_depth = 32;
+         else
+            max_pixel_depth = 64;
+      }

    }
 #endif
 
 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
    {
    }
 #endif
 
 #if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
    if (png_ptr->transformations & PNG_GRAY_TO_RGB)
    {

-      if ((png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
-         png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      if (
+#if defined(PNG_READ_EXPAND_SUPPORTED)
+        (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||
+#endif
+#if defined(PNG_READ_FILLER_SUPPORTED)
+        (png_ptr->transformations & (PNG_FILLER)) ||
+#endif
+        png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

       {
          if (max_pixel_depth <= 16)
             max_pixel_depth = 32;
       {
          if (max_pixel_depth <= 16)
             max_pixel_depth = 32;

-         else if (max_pixel_depth <= 32)
+         else

             max_pixel_depth = 64;
       }
       else
       {
          if (max_pixel_depth <= 8)
             max_pixel_depth = 24;
             max_pixel_depth = 64;
       }
       else
       {
          if (max_pixel_depth <= 8)
             max_pixel_depth = 24;

-         else if (max_pixel_depth <= 16)
+         else

             max_pixel_depth = 48;
       }
    }
             max_pixel_depth = 48;
       }
    }


@@ -2214,16 +2241,16 @@ png_read_start_row(png_structp png_ptr)
 
    /* align the width on the next larger 8 pixels.  Mainly used
       for interlacing */
 
    /* align the width on the next larger 8 pixels.  Mainly used
       for interlacing */

-   rowbytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
+   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));

    /* calculate the maximum bytes needed, adding a byte and a pixel
    /* calculate the maximum bytes needed, adding a byte and a pixel

-      for safety sake */
-   rowbytes = ((rowbytes * (png_uint_32)max_pixel_depth + 7) >> 3) +
+      for safety's sake */
+   row_bytes = ((row_bytes * (png_uint_32)max_pixel_depth + 7) >> 3) +

       1 + ((max_pixel_depth + 7) >> 3);
 #ifdef PNG_MAX_MALLOC_64K
       1 + ((max_pixel_depth + 7) >> 3);
 #ifdef PNG_MAX_MALLOC_64K

-   if (rowbytes > (png_uint_32)65536L)
+   if (row_bytes > (png_uint_32)65536L)

       png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
       png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif

-   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, rowbytes);
+   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, row_bytes);

 
 #ifdef PNG_MAX_MALLOC_64K
    if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)
 
 #ifdef PNG_MAX_MALLOC_64K
    if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)