From: glennrp <glennrp@git.imagemagick.org>
Date: Tue, 30 Mar 2010 03:22:02 +0000 (+0000)
Subject: reverted recent png.c changes; they fail to read a 1-bit paletted image correctly.
X-Git-Tag: 7.0.1-0~9728
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=ed7a94dc79753d6da1fb0157eaeaa5d2580e2257;p=imagemagick

reverted recent png.c changes; they fail to read a 1-bit paletted image correctly.
---

diff --git a/ChangeLog b/ChangeLog
index e362c11e2..dec469431 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2010-03-24  6.6.1-0 Glenn Randers-Pehrson <glennrp@image...>
+  * Temporarily reverted recent changes to coders/png.c; they fail to
+    read a 1-bit paletted image properly.
+
 2010-03-21  6.6.0-10 Cristy  <quetzlzacatenango@image...>
   * Respect the -density option when rendering a Postscript or PDF image.
   * Distort barrel no longer complains when 3 arguments are given (reference
diff --git a/coders/png.c b/coders/png.c
index 66415ff4f..a91c184f5 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -83,14 +83,14 @@
 
 /* Suppress libpng pedantic warnings that were added in
  * libpng-1.2.41 and libpng-1.4.0.  If you are working on
- * migration to libpng-1.5, remove these defines and then
+ * migration to libpng-2.0, remove these defines and then
  * fix any code that generates warnings.
  */
 /* #define PNG_DEPRECATED   Use of this function is deprecated */
-/* #define PNG_USE_RESULT   The result of this function must be checked */
-/* #define PNG_NORETURN     This function does not return */
-/* #define PNG_ALLOCATED    The result of the function is new memory */
-/* #define PNG_DEPSTRUCT    Access to this struct member is deprecated */
+#define PNG_USE_RESULT  /* The result of this function must be checked */
+#define PNG_NORETURN    /* This function does not return */
+#define PNG_ALLOCATED   /* The result of the function is new memory */
+#define PNG_DEPSTRUCT   /* Access to this struct member is deprecated */
 
 #include "png.h"
 #include "zlib.h"
@@ -98,6 +98,21 @@
 /* ImageMagick differences */
 #define first_scene scene
 
+#if PNG_LIBPNG_VER < 10400
+#    define trans_color  trans_values   /* Changed at libpng-1.4.0beta35 */
+#    define trans_alpha  trans          /* Changed at libpng-1.4.0beta74 */
+#else
+   /* We could parse PNG_LIBPNG_VER_STRING here but it's too much bother..
+    * Just don't use libpng-1.4.0beta32-34 or beta67-73
+    */
+#  ifndef  PNG_USER_CHUNK_CACHE_MAX     /* Added at libpng-1.4.0beta32 */
+#    define trans_color  trans_values   /* Changed at libpng-1.4.0beta35 */
+#  endif
+#  ifndef  PNG_TRANSFORM_GRAY_TO_RGB    /* Added at libpng-1.4.0beta67 */
+#    define trans_alpha  trans          /* Changed at libpng-1.4.0beta74 */
+#  endif
+#endif
+
 #if PNG_LIBPNG_VER > 10011
 /*
   Optional declarations. Define or undefine them as you like.
@@ -1435,11 +1450,7 @@ static void PNGErrorHandler(png_struct *ping,png_const_charp message)
       "  libpng-%s error: %s", PNG_LIBPNG_VER_STRING,message);
   (void) ThrowMagickException(&image->exception,GetMagickModule(),CoderError,
     message,"`%s'",image->filename);
-#if PNG_LIBPNG_VER < 10500
   longjmp(ping->jmpbuf,1);
-#else
-  png_longjmp(ping,1);
-#endif
 }
 
 static void PNGWarningHandler(png_struct *ping,png_const_charp message)
@@ -1662,13 +1673,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     logging,
     num_text,
     num_passes,
-    pass,
-    ping_bit_depth,
-    ping_color_type,
-    ping_interlace_method,
-    ping_compression_method,
-    ping_filter_method,
-    ping_num_trans;
+    pass;
 
   MagickBooleanType
     status;
@@ -1676,13 +1681,6 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   PixelPacket
     transparent_color;
 
-  png_bytep
-     ping_trans_alpha;
-
-  png_color_16p
-     ping_background,
-     ping_trans_color;
-
   png_info
     *end_info,
     *ping_info;
@@ -1693,11 +1691,6 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   png_textp
     text;
 
-  png_uint_32
-    ping_height,
-    ping_width,
-    ping_rowbytes;
-
   QuantumInfo
     *quantum_info;
 
@@ -1792,7 +1785,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
     }
   png_pixels=(unsigned char *) NULL;
-  if (setjmp(png_jmpbuf(ping)))
+  if (setjmp(ping->jmpbuf))
     {
       /*
         PNG image is corrupt.
@@ -1814,7 +1807,6 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   /*
     Prepare PNG for reading.
   */
-
   mng_info->image_found++;
   png_set_sig_bytes(ping,8);
   if (LocaleCompare(image_info->magick,"MNG") == 0)
@@ -1868,43 +1860,32 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #endif
 
   png_read_info(ping,ping_info);
-
-  png_get_IHDR(ping,ping_info,&ping_width,&ping_height,
-               &ping_bit_depth,&ping_color_type,
-               &ping_interlace_method,&ping_compression_method,
-               &ping_filter_method);
-
-  (void) png_get_tRNS(ping, ping_info, &ping_trans_alpha, &ping_num_trans,
-                      &ping_trans_color);
-
-  (void) png_get_bKGD(ping, ping_info, &ping_background);
-
-  if (ping_bit_depth < 8)
+  if (ping_info->bit_depth < 8)
     {
-      if (((int) ping_color_type == PNG_COLOR_TYPE_PALETTE))
+      if (((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE))
         png_set_packing(ping);
     }
-  image->depth=ping_bit_depth;
+  image->depth=ping_info->bit_depth;
   image->depth=GetImageQuantumDepth(image,MagickFalse);
-  image->interlace=ping_interlace_method != 0 ? PNGInterlace : NoInterlace;
+  image->interlace=ping_info->interlace_type != 0 ? PNGInterlace : NoInterlace;
   if (logging != MagickFalse)
     {
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG width: %lu, height: %lu",
-        ping_width, ping_height);
+        ping_info->width, ping_info->height);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG color_type: %d, bit_depth: %d",
-        ping_color_type, ping_bit_depth);
+        ping_info->color_type, ping_info->bit_depth);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG compression_method: %d",
-        ping_compression_method);
+        ping_info->compression_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG interlace_method: %d, filter_method: %d",
-        ping_interlace_method,ping_filter_method);
+        ping_info->interlace_type,ping_info->filter_type);
     }
 
-#ifdef PNG_READ_iCCP_SUPPORTED
-  if (png_get_valid(ping,ping_info,PNG_INFO_iCCP))
+#if defined(PNG_READ_iCCP_SUPPORTED)
+  if (ping_info->valid & PNG_INFO_iCCP)
     {
       int
         compression;
@@ -1954,9 +1935,8 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
      double
         file_gamma;
 
-     if (!png_get_gAMA(ping,ping_info,&file_gamma))
-       if (mng_info->have_global_gama)
-         png_set_gAMA(ping,ping_info,mng_info->global_gamma);
+     if (mng_info->have_global_gama)
+       image->gamma=mng_info->global_gamma;
      if (png_get_gAMA(ping,ping_info,&file_gamma))
        {
          image->gamma=(float) file_gamma;
@@ -1965,22 +1945,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
              "    Reading PNG gAMA chunk: gamma: %f",file_gamma);
        }
   }
-  if (!png_get_valid(ping,ping_info,PNG_INFO_cHRM))
-    {
-      if (mng_info->have_global_chrm != MagickFalse)
-        {
-          (void) png_set_cHRM(ping,ping_info,
-            mng_info->global_chrm.white_point.x,
-            mng_info->global_chrm.white_point.y,
-            mng_info->global_chrm.red_primary.x,
-            mng_info->global_chrm.red_primary.y,
-            mng_info->global_chrm.green_primary.x,
-            mng_info->global_chrm.green_primary.y,
-            mng_info->global_chrm.blue_primary.x,
-            mng_info->global_chrm.blue_primary.y);
-        }
-    }
-  if (png_get_valid(ping,ping_info,PNG_INFO_cHRM))
+  if (mng_info->have_global_chrm != MagickFalse)
+    image->chromaticity=mng_info->global_chrm;
+  if (ping_info->valid & PNG_INFO_cHRM)
     {
       (void) png_get_cHRM(ping,ping_info,
         &image->chromaticity.white_point.x,
@@ -1997,14 +1964,22 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     }
   if (image->rendering_intent)
     {
-      png_set_sRGB(ping,ping_info,image->rendering_intent-1);
-      png_set_gAMA(ping,ping_info,0.45455f);
-      png_set_cHRM(ping,ping_info,
-                  0.6400f, 0.3300f, 0.3000f, 0.6000f,
-                  0.1500f, 0.0600f, 0.3127f, 0.3290f);
+      image->gamma=0.45455f;
+      image->chromaticity.red_primary.x=0.6400f;
+      image->chromaticity.red_primary.y=0.3300f;
+      image->chromaticity.green_primary.x=0.3000f;
+      image->chromaticity.green_primary.y=0.6000f;
+      image->chromaticity.blue_primary.x=0.1500f;
+      image->chromaticity.blue_primary.y=0.0600f;
+      image->chromaticity.white_point.x=0.3127f;
+      image->chromaticity.white_point.y=0.3290f;
     }
+  if ((mng_info->have_global_gama != MagickFalse) || image->rendering_intent)
+    ping_info->valid|=PNG_INFO_gAMA;
+  if ((mng_info->have_global_chrm != MagickFalse) || image->rendering_intent)
+    ping_info->valid|=PNG_INFO_cHRM;
 #if defined(PNG_oFFs_SUPPORTED)
-  if (png_get_valid(ping,ping_info,PNG_INFO_oFFs))
+  if (ping_info->valid & PNG_INFO_oFFs)
     {
       image->page.x=png_get_x_offset_pixels(ping, ping_info);
       image->page.y=png_get_y_offset_pixels(ping, ping_info);
@@ -2016,18 +1991,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     }
 #endif
 #if defined(PNG_pHYs_SUPPORTED)
-  if (!png_get_valid(ping,ping_info,PNG_INFO_pHYs))
-    {
-      if (mng_info->have_global_phys)
-        {
-          png_set_pHYs(ping,ping_info,
-                       mng_info->global_x_pixels_per_unit,
-                       mng_info->global_y_pixels_per_unit,
-                       mng_info->global_phys_unit_type);
-        }
-    }
-
-  if (png_get_valid(ping,ping_info,PNG_INFO_pHYs))
+  if (ping_info->valid & PNG_INFO_pHYs)
     {
       int
         unit_type;
@@ -2054,8 +2018,25 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           "    Reading PNG pHYs chunk: xres: %lu, yres: %lu, units: %d.",
           x_resolution, y_resolution, unit_type);
     }
+  else
+    {
+      if (mng_info->have_global_phys)
+        {
+          image->x_resolution=(float) mng_info->global_x_pixels_per_unit;
+          image->y_resolution=(float) mng_info->global_y_pixels_per_unit;
+          if (mng_info->global_phys_unit_type == PNG_RESOLUTION_METER)
+            {
+              image->units=PixelsPerCentimeterResolution;
+              image->x_resolution=(double)
+                mng_info->global_x_pixels_per_unit/100.0;
+              image->y_resolution=(double)
+                mng_info->global_y_pixels_per_unit/100.0;
+            }
+          ping_info->valid|=PNG_INFO_pHYs;
+        }
+    }
 #endif
-  if (png_get_valid(ping,ping_info,PNG_INFO_PLTE))
+  if (ping_info->valid & PNG_INFO_PLTE)
     {
       int
         number_colors;
@@ -2065,13 +2046,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
       (void) png_get_PLTE(ping,ping_info,&palette,&number_colors);
       if ((number_colors == 0) &&
-          ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE))
+          ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE))
         {
           if (mng_info->global_plte_length)
             {
               png_set_PLTE(ping,ping_info,mng_info->global_plte,
                 (int) mng_info->global_plte_length);
-              if (!png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+              if ((ping_info->valid & PNG_INFO_tRNS) == 0)
                 if (mng_info->global_trns_length)
                   {
                     if (mng_info->global_trns_length >
@@ -2088,7 +2069,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #ifndef PNG_READ_EMPTY_PLTE_SUPPORTED
                    mng_info->have_saved_bkgd_index ||
 #endif
-                   png_get_valid(ping,ping_info,PNG_INFO_bKGD))
+                   ping_info->valid & PNG_INFO_bKGD)
                     {
                       png_color_16
                          background;
@@ -2096,9 +2077,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #ifndef PNG_READ_EMPTY_PLTE_SUPPORTED
                       if (mng_info->have_saved_bkgd_index)
                         background.index=mng_info->saved_bkgd_index;
+                      else
 #endif
-                      if (png_get_valid(ping, ping_info, PNG_INFO_bKGD))
-                        background.index=ping_background->index;
+                        background.index=ping_info->background.index;
                       background.red=(png_uint_16)
                         mng_info->global_plte[background.index].red;
                       background.green=(png_uint_16)
@@ -2117,10 +2098,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         }
 
 #if defined(PNG_READ_bKGD_SUPPORTED)
-  if (mng_info->have_global_bkgd &&
-          (!png_get_valid(ping,ping_info,PNG_INFO_bKGD)))
+  if (mng_info->have_global_bkgd && !(ping_info->valid & PNG_INFO_bKGD))
       image->background_color=mng_info->mng_global_bkgd;
-  if (png_get_valid(ping,ping_info,PNG_INFO_bKGD))
+  if (ping_info->valid & PNG_INFO_bKGD)
     {
       /*
         Set image background color.
@@ -2128,20 +2108,20 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       if (logging != MagickFalse)
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Reading PNG bKGD chunk.");
-      if (ping_bit_depth <= MAGICKCORE_QUANTUM_DEPTH)
+      if (ping_info->bit_depth <= MAGICKCORE_QUANTUM_DEPTH)
         {
-          image->background_color.red=ping_background->red;
-          image->background_color.green=ping_background->green;
-          image->background_color.blue=ping_background->blue;
+          image->background_color.red=ping_info->background.red;
+          image->background_color.green=ping_info->background.green;
+          image->background_color.blue=ping_info->background.blue;
         }
       else
         {
           image->background_color.red=
-            ScaleShortToQuantum(ping_background->red);
+            ScaleShortToQuantum(ping_info->background.red);
           image->background_color.green=
-            ScaleShortToQuantum(ping_background->green);
+            ScaleShortToQuantum(ping_info->background.green);
           image->background_color.blue=
-            ScaleShortToQuantum(ping_background->blue);
+            ScaleShortToQuantum(ping_info->background.blue);
         }
     }
 #endif
@@ -2149,7 +2129,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   transparent_color.green=0;
   transparent_color.blue=0;
   transparent_color.opacity=0;
-  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+  if (ping_info->valid & PNG_INFO_tRNS)
     {
       /*
         Image has a transparent background.
@@ -2161,14 +2141,14 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Reading PNG tRNS chunk.");
 
-      max_sample = (1 << ping_bit_depth) - 1;
+      max_sample = (1 << ping_info->bit_depth) - 1;
 
-      if ((ping_color_type == PNG_COLOR_TYPE_GRAY &&
-          (int)ping_trans_color->gray > max_sample) ||
-          (ping_color_type == PNG_COLOR_TYPE_RGB &&
-          ((int)ping_trans_color->red > max_sample ||
-          (int)ping_trans_color->green > max_sample ||
-          (int)ping_trans_color->blue > max_sample)))
+      if ((ping_info->color_type == PNG_COLOR_TYPE_GRAY &&
+          (int)ping_info->trans_color.gray > max_sample) ||
+          (ping_info->color_type == PNG_COLOR_TYPE_RGB &&
+          ((int)ping_info->trans_color.red > max_sample ||
+          (int)ping_info->trans_color.green > max_sample ||
+          (int)ping_info->trans_color.blue > max_sample)))
         {
           if (logging != MagickFalse)
             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -2178,16 +2158,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         }
       else
         {
-          transparent_color.red= (Quantum)(ping_trans_color->red);
-          transparent_color.green= (Quantum) (ping_trans_color->green);
-          transparent_color.blue= (Quantum) (ping_trans_color->blue);
-          transparent_color.opacity= (Quantum) (ping_trans_color->gray);
-          if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+          transparent_color.red= (Quantum)(ping_info->trans_color.red);
+          transparent_color.green= (Quantum) (ping_info->trans_color.green);
+          transparent_color.blue= (Quantum) (ping_info->trans_color.blue);
+          transparent_color.opacity= (Quantum) (ping_info->trans_color.gray);
+          if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
             {
-              if (ping_bit_depth < 8)
+              if (ping_info->bit_depth < 8)
                 {
                   transparent_color.opacity=(Quantum) (((
-                    ping_trans_color->gray)*255)/max_sample);
+                    ping_info->trans_color.gray)*255)/max_sample);
                 }
               transparent_color.red=transparent_color.opacity;
               transparent_color.green=transparent_color.opacity;
@@ -2198,27 +2178,23 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #if defined(PNG_READ_sBIT_SUPPORTED)
   if (mng_info->have_global_sbit)
     {
-      if (!png_get_valid(ping,ping_info,PNG_INFO_sBIT))
+      if (!(ping_info->valid & PNG_INFO_sBIT))
         png_set_sBIT(ping,ping_info,&mng_info->global_sbit);
     }
 #endif
   num_passes=png_set_interlace_handling(ping);
-
   png_read_update_info(ping,ping_info);
-
-  ping_rowbytes=png_get_rowbytes(ping,ping_info);
-
   /*
     Initialize image structure.
   */
   mng_info->image_box.left=0;
-  mng_info->image_box.right=(long) ping_width;
+  mng_info->image_box.right=(long) ping_info->width;
   mng_info->image_box.top=0;
-  mng_info->image_box.bottom=(long) ping_height;
+  mng_info->image_box.bottom=(long) ping_info->height;
   if (mng_info->mng_type == 0)
     {
-      mng_info->mng_width=ping_width;
-      mng_info->mng_height=ping_height;
+      mng_info->mng_width=ping_info->width;
+      mng_info->mng_height=ping_info->height;
       mng_info->frame=mng_info->image_box;
       mng_info->clip=mng_info->image_box;
     }
@@ -2227,14 +2203,14 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       image->page.y=mng_info->y_off[mng_info->object_id];
     }
   image->compression=ZipCompression;
-  image->columns=ping_width;
-  image->rows=ping_height;
-  if (((int) ping_color_type == PNG_COLOR_TYPE_PALETTE) ||
-      ((int) ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
-      ((int) ping_color_type == PNG_COLOR_TYPE_GRAY))
+  image->columns=ping_info->width;
+  image->rows=ping_info->height;
+  if (((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE) ||
+      ((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
+      ((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY))
     {
       image->storage_class=PseudoClass;
-      image->colors=1UL << ping_bit_depth;
+      image->colors=1UL << ping_info->bit_depth;
 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
       if (image->colors > 256)
         image->colors=256;
@@ -2242,7 +2218,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       if (image->colors > 65536L)
         image->colors=65536L;
 #endif
-      if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2265,7 +2241,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       */
       if (AcquireImageColormap(image,image->colors) == MagickFalse)
         ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
-      if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2286,7 +2262,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           unsigned long
             scale;
 
-          scale=(QuantumRange/((1UL << ping_bit_depth)-1));
+          scale=(QuantumRange/((1UL << ping_info->bit_depth)-1));
           if (scale < 1)
              scale=1;
           for (i=0; i < (long) image->colors; i++)
@@ -2323,9 +2299,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       "    Reading PNG IDAT chunk(s)");
   if (num_passes > 1)
     png_pixels=(unsigned char *) AcquireQuantumMemory(image->rows,
-      ping_rowbytes*sizeof(*png_pixels));
+      ping_info->rowbytes*sizeof(*png_pixels));
   else
-    png_pixels=(unsigned char *) AcquireQuantumMemory(ping_rowbytes,
+    png_pixels=(unsigned char *) AcquireQuantumMemory(ping_info->rowbytes,
       sizeof(*png_pixels));
   if (png_pixels == (unsigned char *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
@@ -2335,7 +2311,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   /*
     Convert PNG pixels to pixel packets.
   */
-  if (setjmp(png_jmpbuf(ping)))
+  if (setjmp(ping->jmpbuf))
     {
       /*
         PNG image is corrupt.
@@ -2371,17 +2347,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       int
         depth;
 
-      depth=(long) ping_bit_depth;
+      depth=(long) ping_info->bit_depth;
 #endif
-      image->matte=(((int) ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA) ||
-          ((int) ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
-          (png_get_valid(ping,ping_info,PNG_INFO_tRNS))) ?
-          MagickTrue : MagickFalse;
+      image->matte=(((int) ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ||
+          ((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
+          (ping_info->valid & PNG_INFO_tRNS)) ? MagickTrue : MagickFalse;
 
       for (y=0; y < (long) image->rows; y++)
       {
         if (num_passes > 1)
-          row_offset=ping_rowbytes*y;
+          row_offset=ping_info->rowbytes*y;
         else
           row_offset=0;
         png_read_row(ping,png_pixels+row_offset,NULL);
@@ -2397,13 +2372,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
             r=png_pixels+row_offset;
             p=r;
-            if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+            if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
               {
                 for (x=(long) image->columns-1; x >= 0; x--)
                 {
                   *r++=*p++;
                   p++;
-                  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS)) &&
+                  if ((ping_info->valid & PNG_INFO_tRNS) &&
                      (((*(p-2) << 8)|*(p-1)) == transparent_color.opacity))
                     {
                        /* Cheap transparency */
@@ -2413,9 +2388,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                        *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_color_type == PNG_COLOR_TYPE_RGB)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_RGB)
               {
-              if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+              if (ping_info->valid & PNG_INFO_tRNS)
                 for (x=(long) image->columns-1; x >= 0; x--)
                 {
                   *r++=*p++;
@@ -2446,53 +2421,53 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                   *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
               for (x=(long) (4*image->columns); x != 0; x--)
               {
                 *r++=*p++;
                 p++;
               }
-            else if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
               for (x=(long) (2*image->columns); x != 0; x--)
               {
                 *r++=*p++;
                 p++;
               }
           }
-        if (depth == 8 && ping_color_type == PNG_COLOR_TYPE_GRAY)
+        if (depth == 8 && ping_info->color_type == PNG_COLOR_TYPE_GRAY)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             GrayQuantum,png_pixels+row_offset);
-        if (ping_color_type == PNG_COLOR_TYPE_GRAY ||
-            ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        if (ping_info->color_type == PNG_COLOR_TYPE_GRAY ||
+            ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
           {
             quantum_info->depth=8;
             (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
               GrayAlphaQuantum,png_pixels+row_offset);
           }
-        else if (depth == 8 && ping_color_type == PNG_COLOR_TYPE_RGB)
+        else if (depth == 8 && ping_info->color_type == PNG_COLOR_TYPE_RGB)
            (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
              RGBQuantum,png_pixels+row_offset);
-        else if (ping_color_type == PNG_COLOR_TYPE_RGB ||
-              ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+        else if (ping_info->color_type == PNG_COLOR_TYPE_RGB ||
+              ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
           {
             quantum_info->depth=8;
             (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
               RGBAQuantum,png_pixels+row_offset);
           }
-        else if (ping_color_type == PNG_COLOR_TYPE_PALETTE)
+        else if (ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
             (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
               IndexQuantum,png_pixels+row_offset);
 #else /* (MAGICKCORE_QUANTUM_DEPTH != 8) */
-        if ((int) ping_color_type == PNG_COLOR_TYPE_GRAY)
+        if ((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             GrayQuantum,png_pixels+row_offset,exception);
-        else if ((int) ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        else if ((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             GrayAlphaQuantum,png_pixels+row_offset,exception);
-        else if ((int) ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+        else if ((int) ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             RGBAQuantum,png_pixels+row_offset,exception);
-        else if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+        else if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             IndexQuantum,png_pixels+row_offset,exception);
         else
@@ -2527,7 +2502,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       /*
         Convert grayscale image to PseudoClass pixel packets.
       */
-      image->matte=ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA ?
+      image->matte=ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ?
         MagickTrue : MagickFalse;
       quantum_scanline=(Quantum *) AcquireQuantumMemory(image->columns,
         (image->matte ?  2 : 1)*sizeof(*quantum_scanline));
@@ -2536,7 +2511,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       for (y=0; y < (long) image->rows; y++)
       {
         if (num_passes > 1)
-          row_offset=ping_rowbytes*y;
+          row_offset=ping_info->rowbytes*y;
         else
           row_offset=0;
         png_read_row(ping,png_pixels+row_offset,NULL);
@@ -2546,7 +2521,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         indices=GetAuthenticIndexQueue(image);
         p=png_pixels+row_offset;
         r=quantum_scanline;
-        switch (ping_bit_depth)
+        switch (ping_info->bit_depth)
         {
           case 1:
           {
@@ -2595,7 +2570,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           }
           case 8:
           {
-            if (ping_color_type == 4)
+            if (ping_info->color_type == 4)
               for (x=(long) image->columns-1; x >= 0; x--)
               {
                 *r++=*p++;
@@ -2628,7 +2603,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=(Quantum) quantum;
               r++;
-              if (ping_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   quantum=((*p++) << 8);
                   quantum|=(*p++);
@@ -2648,7 +2623,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=quantum;
               r++;
-              if (ping_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   q->opacity=(*p << 8) | *(p+1);
                   q->opacity*=65537L;
@@ -2659,7 +2634,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #else /* MAGICKCORE_QUANTUM_DEPTH == 8 */
               *r++=(*p++);
               p++; /* strip low byte */
-              if (ping_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   q->opacity=(Quantum) (QuantumRange-(*p++));
                   p++;
@@ -2717,7 +2692,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           "  exit ReadOnePNGImage() early.");
       return(image);
     }
-  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+  if (ping_info->valid & PNG_INFO_tRNS)
     {
       ClassType
         storage_class;
@@ -2733,16 +2708,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
     if (storage_class == PseudoClass)
    {
-      if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
       {
-         for (x=0; x < ping_num_trans; x++)
+         for (x=0; x < ping_info->num_trans; x++)
          {
-            image->colormap[x].opacity = ScaleCharToQuantum((unsigned char)(255-ping_trans_alpha[x]));
+            image->colormap[x].opacity = ScaleCharToQuantum((unsigned char)(255-ping_info->trans_alpha[x]));
          }
       }
-      else if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+      else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
       {
-         for (x=0; x < (int) image->colors; x++)
+         for (x=0; x < image->colors; x++)
          {
             if (image->colormap[x].red == transparent_color.opacity)
             {
@@ -2793,18 +2768,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             IndexPacket
               indexpacket;
 
-            if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+            if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
               for (x=0; x < (long) image->columns; x++)
               {
                 indexpacket=indices[x];
-                if (indexpacket < ping_num_trans)
+                if (indexpacket < ping_info->num_trans)
                   q->opacity=ScaleCharToQuantum((unsigned char)
-                    (255-ping_trans_alpha[(long) indexpacket]));
+                    (255-ping_info->trans_alpha[(long) indexpacket]));
                 else
                   SetOpacityPixelComponent(q,OpaqueOpacity);
                 q++;
               }
-            else if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
               for (x=0; x < (long) image->columns; x++)
               {
                 indexpacket=indices[x];
@@ -2906,6 +2881,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         }
       else
         {
+          png_uint_32
+            width,
+            height;
+
+          int
+            bit_depth,
+            color_type,
+            interlace_method,
+            compression_method,
+            filter_method;
 
           if (mng_info->ob[object_id]->image != (Image *) NULL)
             mng_info->ob[object_id]->image=DestroyImage
@@ -2918,17 +2903,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             (void) ThrowMagickException(&image->exception,GetMagickModule(),
               ResourceLimitError,"Cloning image for object buffer failed",
               "`%s'",image->filename);
-          if (ping_width > 250000L || ping_height > 250000L)
+          png_get_IHDR(ping,ping_info,&width,&height,&bit_depth,&color_type,
+            &interlace_method,&compression_method,&filter_method);
+          if (width > 250000L || height > 250000L)
              png_error(ping,"PNG Image dimensions are too large.");
-          mng_info->ob[object_id]->width=ping_width;
-          mng_info->ob[object_id]->height=ping_height;
-          mng_info->ob[object_id]->color_type=ping_color_type;
-          mng_info->ob[object_id]->sample_depth=ping_bit_depth;
-          mng_info->ob[object_id]->interlace_method=ping_interlace_method;
-          mng_info->ob[object_id]->compression_method=
-             ping_compression_method;
-          mng_info->ob[object_id]->filter_method=ping_filter_method;
-          if (png_get_valid(ping,ping_info,PNG_INFO_PLTE))
+          mng_info->ob[object_id]->width=width;
+          mng_info->ob[object_id]->height=height;
+          mng_info->ob[object_id]->color_type=color_type;
+          mng_info->ob[object_id]->sample_depth=bit_depth;
+          mng_info->ob[object_id]->interlace_method=interlace_method;
+          mng_info->ob[object_id]->compression_method=compression_method;
+          mng_info->ob[object_id]->filter_method=filter_method;
+          if (ping_info->valid & PNG_INFO_PLTE)
             {
               int
                 number_colors;
@@ -6316,26 +6302,15 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     num_passes,
     pass;
 
-  png_bytep
-     ping_trans_alpha;
-
   png_colorp
      palette;
 
-  png_color_16
-    ping_background,
-    ping_trans_color;
-
   png_info
     *ping_info;
 
   png_struct
     *ping;
 
-  png_uint_32
-    ping_height,
-    ping_width;
-
   long
     y;
 
@@ -6359,20 +6334,12 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     logging,
     matte;
 
-  volatile int
-    ping_bit_depth, 
-    ping_color_type,
-    ping_interlace_method,
-    ping_compression_method,
-    ping_filter_method,
-    ping_num_trans;
-
   volatile unsigned long
     image_colors,
-    image_depth,
-    old_bit_depth;
+    image_depth;
 
   unsigned long
+    old_bit_depth,
     quality,
     rowbytes,
     save_image_depth;
@@ -6384,27 +6351,6 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   LockSemaphoreInfo(png_semaphore);
 #endif
 
-  /* Initialize some stuff */
-  ping_bit_depth=0, 
-  ping_color_type=0,
-  ping_interlace_method=0,
-  ping_compression_method=0,
-  ping_filter_method=0,
-  ping_num_trans = 0;
-
-  ping_background.red = 0;
-  ping_background.green = 0;
-  ping_background.blue = 0;
-  ping_background.gray = 0;
-  ping_background.index = 0;
-
-  ping_trans_color.red=0;
-  ping_trans_color.green=0;
-  ping_trans_color.blue=0;
-  ping_trans_color.gray=0;
-
-  ping_trans_alpha = NULL;
-
   quantum_info = (QuantumInfo *) NULL;
   image_colors=image->colors;
   image_depth=image->depth;
@@ -6438,7 +6384,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   png_set_write_fn(ping,image,png_put_data,png_flush_data);
   png_pixels=(unsigned char *) NULL;
 
-  if (setjmp(png_jmpbuf(ping)))
+  if (setjmp(ping->jmpbuf))
     {
       /*
         PNG write failed.
@@ -6466,8 +6412,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 # endif
 #endif
   x=0;
-  ping_width=image->columns;
-  ping_height=image->rows;
+  ping_info->width=image->columns;
+  ping_info->height=image->rows;
   if (mng_info->write_png8 || mng_info->write_png24 || mng_info->write_png32)
      image_depth=8;
   if (mng_info->write_png_depth != 0)
@@ -6482,9 +6428,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   if (logging != MagickFalse)
     {
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    width=%lu",ping_width);
+        "    width=%lu",ping_info->width);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    height=%lu",ping_height);
+        "    height=%lu",ping_info->height);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    image_matte=%u",image->matte);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6493,7 +6439,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         "    requested PNG image_depth=%lu",image->depth);
     }
   save_image_depth=image_depth;
-  ping_bit_depth=(png_byte) save_image_depth;
+  ping_info->bit_depth=(png_byte) save_image_depth;
 #if defined(PNG_pHYs_SUPPORTED)
   if ((image->x_resolution != 0) && (image->y_resolution != 0) &&
       (!mng_info->write_mng || !mng_info->equal_physs))
@@ -6580,9 +6526,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   old_bit_depth=0;
   if (mng_info->write_png8)
     {
-      ping_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
-      ping_bit_depth=8;
-      image_depth=ping_bit_depth;
+      ping_info->color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+      ping_info->bit_depth=8;
+      image_depth=ping_info->bit_depth;
         {
           /* TO DO: make this a function cause it's used twice, except
              for reducing the sample depth from 8. */
@@ -6610,11 +6556,12 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   "    Colors quantized to %ld",number_colors);
             }
           if (matte)
-            png_set_invalid(ping,ping_info,PNG_INFO_tRNS);
+            ping_info->valid|=PNG_INFO_tRNS;
           /*
             Set image palette.
           */
-          ping_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+          ping_info->color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+          ping_info->valid|=PNG_INFO_PLTE;
 #if defined(PNG_SORT_PALETTE)
           save_number_colors=image_colors;
           if (CompressColormapTransFirst(image) == MagickFalse)
@@ -6654,22 +6601,24 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             }
           png_set_PLTE(ping,ping_info,palette,(int) number_colors);
           palette=(png_colorp) RelinquishMagickMemory(palette);
-            image_depth=ping_bit_depth;
-            ping_num_trans=0;
+            image_depth=ping_info->bit_depth;
+            ping_info->num_trans=0;
             if (matte)
             {
               ExceptionInfo
                 *exception;
 
-              int
-                trans_alpha[256];
-
               /*
                 Identify which colormap entry is transparent.
               */
+              ping_info->trans_alpha=(unsigned char *) AcquireQuantumMemory(
+                number_colors,sizeof(*ping_info->trans_alpha));
+              if (ping_info->trans_alpha == (unsigned char *) NULL)
+                ThrowWriterException(ResourceLimitError,
+                  "MemoryAllocationFailed");
               assert(number_colors <= 256);
               for (i=0; i < (long) number_colors; i++)
-                 trans_alpha[i]=255;
+                 ping_info->trans_alpha[i]=255;
               exception=(&image->exception);
               for (y=0; y < (long) image->rows; y++)
               {
@@ -6685,7 +6634,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   if (p->opacity != OpaqueOpacity)
                     {
                       indices[x]=(IndexPacket) (number_colors-1);
-                      trans_alpha[(long) indices[x]]=(png_byte) (255-
+                      ping_info->trans_alpha[(long) indices[x]]=(png_byte) (255-
                         ScaleQuantumToChar(GetOpacityPixelComponent(p)));
                     }
                   p++;
@@ -6694,31 +6643,23 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   break;
               }
               for (i=0; i < (long) number_colors; i++)
-                if (trans_alpha[i] != 255)
-                  ping_num_trans=(unsigned short) (i+1);
-
-              if (ping_num_trans == 0)
-                 png_set_invalid(ping, ping_info, PNG_INFO_tRNS);
-              if (!png_get_valid(ping, ping_info, PNG_INFO_tRNS))
-                ping_num_trans=0;
-              if (ping_num_trans != 0)
-                {
-                  for (i=0; i<256; i++)
-                     ping_trans_alpha[i]=(png_byte) trans_alpha[i];
-                }
-
-              (void) png_set_tRNS(ping, ping_info,
-                                  ping_trans_alpha,
-                                  ping_num_trans,
-                                  &ping_trans_color);
+                if (ping_info->trans_alpha[i] != 255)
+                  ping_info->num_trans=(unsigned short) (i+1);
+              if (ping_info->num_trans == 0)
+                ping_info->valid&=(~PNG_INFO_tRNS);
+              if (!(ping_info->valid & PNG_INFO_tRNS))
+                ping_info->num_trans=0;
+              if (ping_info->num_trans == 0)
+                ping_info->trans_alpha=(unsigned char *)
+                  RelinquishMagickMemory(ping_info->trans_alpha);
             }
           /*
             Identify which colormap entry is the background color.
           */
           for (i=0; i < (long) MagickMax(1L*number_colors-1L,1L); i++)
-            if (IsPNGColorEqual(ping_background,image->colormap[i]))
+            if (IsPNGColorEqual(ping_info->background,image->colormap[i]))
               break;
-          ping_background.index=(png_byte) i;
+          ping_info->background.index=(png_byte) i;
         }
       if (image_matte != MagickFalse)
         {
@@ -6728,21 +6669,21 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   else if (mng_info->write_png24)
     {
       image_matte=MagickFalse;
-      ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB;
+      ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB;
     }
   else if (mng_info->write_png32)
     {
       image_matte=MagickTrue;
-      ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+      ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
     }
   else
     {
-      image_depth=ping_bit_depth;
+      image_depth=ping_info->bit_depth;
       if (mng_info->write_png_colortype)
         {
-          ping_color_type=(png_byte) mng_info->write_png_colortype-1;
-          if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
-              ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+          ping_info->color_type=(png_byte) mng_info->write_png_colortype-1;
+          if (ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+              ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
             image_matte=MagickTrue;
         }
       else
@@ -6750,16 +6691,16 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           if (logging != MagickFalse)
              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
              "Selecting PNG colortype");
-          ping_color_type=(png_byte) ((matte == MagickTrue)?
+          ping_info->color_type=(png_byte) ((matte == MagickTrue)?
           PNG_COLOR_TYPE_RGB_ALPHA:PNG_COLOR_TYPE_RGB);
           if(image_info->type == TrueColorType)
             {
-              ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB;
               image_matte=MagickFalse;
             }
           if(image_info->type == TrueColorMatteType)
             {
-              ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
               image_matte=MagickTrue;
             }
           if ((image_info->type == UndefinedType || 
@@ -6767,7 +6708,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              image_info->type == GrayscaleType) &&
              image_matte == MagickFalse && ImageIsGray(image))
             {
-              ping_color_type=(png_byte) PNG_COLOR_TYPE_GRAY;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_GRAY;
               image_matte=MagickFalse;
             }
           if ((image_info->type == UndefinedType ||
@@ -6775,56 +6716,56 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               image_info->type == GrayscaleMatteType) &&
               image_matte == MagickTrue && ImageIsGray(image))
             {
-              ping_color_type=(png_byte) PNG_COLOR_TYPE_GRAY_ALPHA;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_GRAY_ALPHA;
               image_matte=MagickTrue;
             } 
         }
       if (logging != MagickFalse)
          (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-         "Selected PNG colortype=%d",ping_color_type);
+         "Selected PNG colortype=%d",ping_info->color_type);
 
-      if (ping_bit_depth < 8)
+      if (ping_info->bit_depth < 8)
        {
-         if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
-             ping_color_type == PNG_COLOR_TYPE_RGB ||
-             ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-           ping_bit_depth=8;
+         if (ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
+             ping_info->color_type == PNG_COLOR_TYPE_RGB ||
+             ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+           ping_info->bit_depth=8;
        }
 
-      if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+      if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
         {
           if (image->matte == MagickFalse && image->colors < 256)
             {
               if (ImageIsMonochrome(image))
                 {
-                  ping_bit_depth=1;
-                  if (ping_bit_depth < (int)mng_info->write_png_depth)
-                    ping_bit_depth = mng_info->write_png_depth;
+                  ping_info->bit_depth=1;
+                  if (ping_info->bit_depth < mng_info->write_png_depth)
+                    ping_info->bit_depth = mng_info->write_png_depth;
                 }
             }
         }
-      if (ping_color_type == PNG_COLOR_TYPE_PALETTE)
+      if (ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
-           ping_bit_depth=1;
-           while ((int) (1 << ping_bit_depth) < (long) image_colors)
-             ping_bit_depth <<= 1;
+           ping_info->bit_depth=1;
+           while ((int) (1 << ping_info->bit_depth) < (long) image_colors)
+             ping_info->bit_depth <<= 1;
 
            if (logging != MagickFalse)
              {
                (void) LogMagickEvent(CoderEvent,GetMagickModule(),
                 "    Number of colors: %lu",image_colors);
                (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-                "    Tentative PNG bit depth: %d",ping_bit_depth);
+                "    Tentative PNG bit depth: %d",ping_info->bit_depth);
              }
            if (mng_info->write_png_depth)
              {
-               old_bit_depth=ping_bit_depth;
-               if (ping_bit_depth < (int)mng_info->write_png_depth)
+               old_bit_depth=ping_info->bit_depth;
+               if (ping_info->bit_depth < mng_info->write_png_depth)
                  {
-                   ping_bit_depth = mng_info->write_png_depth;
-                   if (ping_bit_depth > 8)
-                      ping_bit_depth = 8;
-                   if (ping_bit_depth != (int) old_bit_depth)
+                   ping_info->bit_depth = mng_info->write_png_depth;
+                   if (ping_info->bit_depth > 8)
+                      ping_info->bit_depth = 8;
+                   if (ping_info->bit_depth != old_bit_depth)
                      {
                        if (logging != MagickFalse)
                          (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6834,17 +6775,17 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              }
         }
     }
-  image_depth=ping_bit_depth;
+  image_depth=ping_info->bit_depth;
   if (logging != MagickFalse)
     {
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Tentative PNG color type: %d",ping_color_type);
+        "    Tentative PNG color type: %d",ping_info->color_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    image_info->type: %d",image_info->type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    image_depth: %lu",image_depth);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    ping_bit_depth: %d",ping_bit_depth);
+        "    ping_info->bit_depth: %d",ping_info->bit_depth);
     }
 
   if (matte && (mng_info->optimize || mng_info->IsPalette))
@@ -6853,7 +6794,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         *p;
 
       p=GetVirtualPixels(image,0,0,image->columns,1,&image->exception);
-      ping_color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
+      ping_info->color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
       for (y=0; y < (long) image->rows; y++)
       {
         p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
@@ -6863,7 +6804,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         {
           if (IsGray(p) == MagickFalse)
             {
-              ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
               break;
             }
           p++;
@@ -6889,10 +6830,11 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if ((y == (long) image->rows) && (x == (long) image->columns))
         {
           /*
-            No transparent pixels are present.  Change 4 or 6 to 0 or 2.
+            No transparent pixels are present.  Change 4 or 6 to 0 or 2,
+            and do not set the PNG_INFO_tRNS flag in ping_info->valid.
           */
           image_matte=MagickFalse;
-          ping_color_type&=0x03;
+          ping_info->color_type&=0x03;
         }
       else
         {
@@ -6900,28 +6842,27 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             mask;
 
           mask=0xffff;
-          if (ping_bit_depth == 8)
+          if (ping_info->bit_depth == 8)
              mask=0x00ff;
-          if (ping_bit_depth == 4)
+          if (ping_info->bit_depth == 4)
              mask=0x000f;
-          if (ping_bit_depth == 2)
+          if (ping_info->bit_depth == 2)
              mask=0x0003;
-          if (ping_bit_depth == 1)
+          if (ping_info->bit_depth == 1)
              mask=0x0001;
-          ping_trans_color.red=(png_uint_16)
+          ping_info->valid|=PNG_INFO_tRNS;
+          ping_info->trans_color.red=(png_uint_16)
             (ScaleQuantumToShort(GetRedPixelComponent(p)) & mask);
-          ping_trans_color.green=(png_uint_16)
+          ping_info->trans_color.green=(png_uint_16)
             (ScaleQuantumToShort(GetGreenPixelComponent(p)) & mask);
-          ping_trans_color.blue=(png_uint_16)
+          ping_info->trans_color.blue=(png_uint_16)
             (ScaleQuantumToShort(GetBluePixelComponent(p)) & mask);
-          ping_trans_color.gray=(png_uint_16)
+          ping_info->trans_color.gray=(png_uint_16)
             (ScaleQuantumToShort(PixelIntensityToQuantum(p)) & mask);
-          ping_trans_color.index=(png_byte)
+          ping_info->trans_color.index=(png_byte)
             (ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p))));
-          (void) png_set_tRNS(ping, ping_info, NULL, 0,
-             &ping_trans_color);
         }
-      if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+      if (ping_info->valid & PNG_INFO_tRNS)
         {
           /*
             Determine if there is one and only one transparent color
@@ -6938,7 +6879,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             {
               if (p->opacity != OpaqueOpacity)
                 {
-                  if (IsPNGColorEqual(ping_trans_color,*p) == 0)
+                  if (IsPNGColorEqual(ping_info->trans_color,*p) == 0)
                   {
                      break;  /* Can't use RGB + tRNS for multiple
                                 transparent colors.  */
@@ -6951,7 +6892,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                 }
                else
                 {
-                  if (IsPNGColorEqual(ping_trans_color,*p))
+                  if (IsPNGColorEqual(ping_info->trans_color,*p))
                       break; /* Can't use RGB + tRNS when another pixel
                                 having the same RGB samples is
                                 transparent. */
@@ -6962,55 +6903,55 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                break;
           }
           if (x != 0)
-            png_set_invalid(ping,ping_info,PNG_INFO_tRNS);
+            ping_info->valid&=(~PNG_INFO_tRNS);
         }
-      if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+      if (ping_info->valid & PNG_INFO_tRNS)
         {
-          ping_color_type &= 0x03;  /* changes 4 or 6 to 0 or 2 */
+          ping_info->color_type &= 0x03;  /* changes 4 or 6 to 0 or 2 */
           if (image_depth == 8)
             {
-              ping_trans_color.red&=0xff;
-              ping_trans_color.green&=0xff;
-              ping_trans_color.blue&=0xff;
-              ping_trans_color.gray&=0xff;
+              ping_info->trans_color.red&=0xff;
+              ping_info->trans_color.green&=0xff;
+              ping_info->trans_color.blue&=0xff;
+              ping_info->trans_color.gray&=0xff;
             }
         }
     }
     matte=image_matte;
-    if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+    if (ping_info->valid & PNG_INFO_tRNS)
       image_matte=MagickFalse;
     if ((mng_info->optimize || mng_info->IsPalette) &&
         mng_info->write_png_colortype-1 != PNG_COLOR_TYPE_PALETTE &&
         ImageIsGray(image) && (!image_matte || image_depth >= 8))
       {
         if (image_matte != MagickFalse)
-            ping_color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
+            ping_info->color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
         else
           {
-            ping_color_type=PNG_COLOR_TYPE_GRAY;
+            ping_info->color_type=PNG_COLOR_TYPE_GRAY;
             if (save_image_depth == 16 && image_depth == 8)
-              ping_trans_color.gray*=0x0101;
+              ping_info->trans_color.gray*=0x0101;
           }
         if (image_depth > MAGICKCORE_QUANTUM_DEPTH)
           image_depth=MAGICKCORE_QUANTUM_DEPTH;
         if (image_colors == 0 || image_colors-1 > MaxColormapSize)
           image_colors=1 << image_depth;
         if (image_depth > 8)
-          ping_bit_depth=16;
+          ping_info->bit_depth=16;
         else
           {
-            ping_bit_depth=8;
-            if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
+            ping_info->bit_depth=8;
+            if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
               {
                 if(!mng_info->write_png_depth)
                   {
-                    ping_bit_depth=1;
-                    while ((int) (1 << ping_bit_depth)
+                    ping_info->bit_depth=1;
+                    while ((int) (1 << ping_info->bit_depth)
                         < (long) image_colors)
-                      ping_bit_depth <<= 1;
+                      ping_info->bit_depth <<= 1;
                   }
               }
-            else if (mng_info->optimize && ping_color_type ==
+            else if (mng_info->optimize && ping_info->color_type ==
                 PNG_COLOR_TYPE_GRAY && image_colors < 17 && 
                 mng_info->IsPalette)
               {
@@ -7036,14 +6977,14 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                      depth_1_ok=MagickFalse;
                 }
                 if (depth_1_ok && mng_info->write_png_depth <= 1)
-                   ping_bit_depth=1;
+                   ping_info->bit_depth=1;
                 else if (depth_2_ok && mng_info->write_png_depth <= 2)
-                   ping_bit_depth=2;
+                   ping_info->bit_depth=2;
                 else if (depth_4_ok && mng_info->write_png_depth <= 4)
-                   ping_bit_depth=4;
+                   ping_info->bit_depth=4;
               }
           }
-          image_depth=ping_bit_depth;
+          image_depth=ping_info->bit_depth;
       }
     else
       if (mng_info->IsPalette)
@@ -7054,10 +6995,13 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                number_colors;
 
             number_colors=image_colors;
+            if (matte)
+               ping_info->valid|=PNG_INFO_tRNS;
             /*
               Set image palette.
             */
-            ping_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+            ping_info->color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+            ping_info->valid|=PNG_INFO_PLTE;
             if (mng_info->have_write_global_plte && !matte)
               {
                  png_set_PLTE(ping,ping_info,NULL,0);
@@ -7102,11 +7046,11 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             /* color_type is PNG_COLOR_TYPE_PALETTE */
             if (!mng_info->write_png_depth)
               {
-                ping_bit_depth=1;
-                while ((1UL << ping_bit_depth) < number_colors)
-                  ping_bit_depth <<= 1;
+                ping_info->bit_depth=1;
+                while ((1UL << ping_info->bit_depth) < number_colors)
+                  ping_info->bit_depth <<= 1;
               }
-            ping_num_trans=0;
+            ping_info->num_trans=0;
             if (matte)
             {
               ExceptionInfo
@@ -7148,7 +7092,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                           if (trans[(long) packet_index] != (png_byte) (255-
                              ScaleQuantumToChar(GetOpacityPixelComponent(p))))
                             {
-                              ping_color_type=(png_byte)
+                              ping_info->color_type=(png_byte)
                                 PNG_COLOR_TYPE_RGB_ALPHA;
                               break;
                             }
@@ -7158,11 +7102,11 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                     }
                   p++;
                 }
-                if ((int) ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+                if ((int) ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                 {
-                  ping_num_trans=0;
-                  png_set_invalid(ping,ping_info,PNG_INFO_tRNS);
-                  png_set_invalid(ping,ping_info,PNG_INFO_PLTE);
+                  ping_info->num_trans=0;
+                  ping_info->valid&=(~PNG_INFO_tRNS);
+                  ping_info->valid&=(~PNG_INFO_PLTE);
                   mng_info->IsPalette=MagickFalse;
                   (void) SyncImage(image);
                   if (logging)
@@ -7171,29 +7115,29 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   break;
                 }
               }
-              if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
+              if ((ping_info->valid & PNG_INFO_tRNS))
               {
                 for (i=0; i < (long) number_colors; i++)
                 {
                   if (trans[i] == 256)
                     trans[i]=255;
                   if (trans[i] != 255)
-                    ping_num_trans=(unsigned short) (i+1);
+                    ping_info->num_trans=(unsigned short) (i+1);
                 }
               }
-              if (ping_num_trans == 0)
-                png_set_invalid(ping,ping_info,PNG_INFO_tRNS);
-              if (!png_get_valid(ping,ping_info,PNG_INFO_tRNS))
-                ping_num_trans=0;
-              if (ping_num_trans != 0)
+              if (ping_info->num_trans == 0)
+                ping_info->valid&=(~PNG_INFO_tRNS);
+              if (!(ping_info->valid & PNG_INFO_tRNS))
+                ping_info->num_trans=0;
+              if (ping_info->num_trans != 0)
               {
-                ping_trans_alpha=(unsigned char *) AcquireQuantumMemory(
-                  number_colors,sizeof(*ping_trans_alpha));
-                if (ping_trans_alpha == (unsigned char *) NULL)
+                ping_info->trans_alpha=(unsigned char *) AcquireQuantumMemory(
+                  number_colors,sizeof(*ping_info->trans_alpha));
+                if (ping_info->trans_alpha == (unsigned char *) NULL)
                   ThrowWriterException(ResourceLimitError,
                      "MemoryAllocationFailed");
                 for (i=0; i < (long) number_colors; i++)
-                    ping_trans_alpha[i]=(png_byte) trans[i];
+                    ping_info->trans_alpha[i]=(png_byte) trans[i];
               }
             }
 
@@ -7201,9 +7145,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               Identify which colormap entry is the background color.
             */
             for (i=0; i < (long) MagickMax(1L*number_colors-1L,1L); i++)
-              if (IsPNGColorEqual(ping_background,image->colormap[i]))
+              if (IsPNGColorEqual(ping_info->background,image->colormap[i]))
                 break;
-            ping_background.index=(png_byte) i;
+            ping_info->background.index=(png_byte) i;
           }
       }
     else
@@ -7212,17 +7156,17 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           image_depth=8;
         if ((save_image_depth == 16) && (image_depth == 8))
           {
-            ping_trans_color.red*=0x0101;
-            ping_trans_color.green*=0x0101;
-            ping_trans_color.blue*=0x0101;
-            ping_trans_color.gray*=0x0101;
+            ping_info->trans_color.red*=0x0101;
+            ping_info->trans_color.green*=0x0101;
+            ping_info->trans_color.blue*=0x0101;
+            ping_info->trans_color.gray*=0x0101;
           }
       }
 
     /*
       Adjust background and transparency samples in sub-8-bit grayscale files.
     */
-    if (ping_bit_depth < 8 && ping_color_type ==
+    if (ping_info->bit_depth < 8 && ping_info->color_type ==
         PNG_COLOR_TYPE_GRAY)
       {
          png_uint_16
@@ -7231,7 +7175,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
          png_color_16
            background;
 
-         maxval=(png_uint_16) ((1 << ping_bit_depth)-1);
+         maxval=(png_uint_16) ((1 << ping_info->bit_depth)-1);
 
 
          background.gray=(png_uint_16)
@@ -7242,12 +7186,12 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              "  Setting up bKGD chunk");
          png_set_bKGD(ping,ping_info,&background);
 
-         ping_trans_color.gray=(png_uint_16) (QuantumScale*(maxval*
-           ping_trans_color.gray));
+         ping_info->trans_color.gray=(png_uint_16) (QuantumScale*(maxval*
+           ping_info->trans_color.gray));
       }
   if (logging != MagickFalse)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-      "    PNG color type: %d",ping_color_type);
+      "    PNG color type: %d",ping_info->color_type);
   /*
     Initialize compression level and filtering.
   */
@@ -7293,7 +7237,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if (logging != MagickFalse)
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Filter_type: PNG_INTRAPIXEL_DIFFERENCING");
-      ping_filter_method=PNG_INTRAPIXEL_DIFFERENCING;
+      ping_info->filter_type=PNG_INTRAPIXEL_DIFFERENCING;
     }
   else
     if (logging != MagickFalse)
@@ -7310,8 +7254,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if ((quality % 10) != 5)
         base_filter=(int) quality % 10;
       else
-        if (((int) ping_color_type == PNG_COLOR_TYPE_GRAY) ||
-            ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE) ||
+        if (((int) ping_info->color_type == PNG_COLOR_TYPE_GRAY) ||
+            ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE) ||
             (quality < 50))
           base_filter=PNG_NO_FILTERS;
         else
@@ -7334,7 +7278,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     profile=GetImageProfile(image,name);
     if (profile != (StringInfo *) NULL)
       {
-#ifdef PNG_WRITE_iCCP_SUPPORTED
+#if defined(PNG_WRITE_iCCP_SUPPORTED)
         if ((LocaleCompare(name,"ICC") == 0) ||
             (LocaleCompare(name,"ICM") == 0))
           png_set_iCCP(ping,ping_info,(const png_charp) name,0,(png_charp)
@@ -7366,7 +7310,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       (void) png_set_sRGB(ping,ping_info,(int) (image->rendering_intent-1));
       png_set_gAMA(ping,ping_info,0.45455);
     }
-  if ((!mng_info->write_mng) || (!png_get_valid(ping,ping_info,PNG_INFO_sRGB)))
+  if ((!mng_info->write_mng) || !(ping_info->valid & PNG_INFO_sRGB))
 #endif
     {
       if ((mng_info->have_write_global_gama == 0) && (image->gamma != 0.0))
@@ -7405,7 +7349,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                bp.x,bp.y);
        }
     }
-  ping_interlace_method=image_info->interlace != NoInterlace;
+  ping_info->interlace_type=image_info->interlace != NoInterlace;
 
   if (mng_info->write_mng)
     png_set_sig_bytes(ping,8);
@@ -7417,22 +7361,22 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
      if (mng_info->write_png_colortype-1 == PNG_COLOR_TYPE_GRAY)
        if (ImageIsGray(image) == MagickFalse)
          {
-           ping_color_type = PNG_COLOR_TYPE_RGB;
-           if (ping_bit_depth < 8)
-             ping_bit_depth=8;
+           ping_info->color_type = PNG_COLOR_TYPE_RGB;
+           if (ping_info->bit_depth < 8)
+             ping_info->bit_depth=8;
          }
          
      if (mng_info->write_png_colortype-1 == PNG_COLOR_TYPE_GRAY_ALPHA)
        if (ImageIsGray(image) == MagickFalse)
-         ping_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+         ping_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
     }
 
   if ((mng_info->write_png_depth &&
-     (int) mng_info->write_png_depth != ping_bit_depth) ||
+      mng_info->write_png_depth != ping_info->bit_depth) ||
      (mng_info->write_png_colortype &&
-     ((int) mng_info->write_png_colortype-1 != ping_color_type &&
+     (mng_info->write_png_colortype-1 != ping_info->color_type &&
       mng_info->write_png_colortype != 7 &&
-      !(mng_info->write_png_colortype == 5 && ping_color_type == 0))))
+      !(mng_info->write_png_colortype == 5 && ping_info->color_type == 0))))
     {
       if (logging != MagickFalse)
         {
@@ -7441,14 +7385,14 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               (void) LogMagickEvent(CoderEvent,GetMagickModule(),
                   "  Defined PNG:bit-depth=%u, Computed depth=%u",
                   mng_info->write_png_depth,
-                  ping_bit_depth);
+                  ping_info->bit_depth);
             }
           if (mng_info->write_png_colortype)
             {
               (void) LogMagickEvent(CoderEvent,GetMagickModule(),
                   "  Defined PNG:color-type=%u, Computed color type=%u",
                   mng_info->write_png_colortype-1,
-                  ping_color_type);
+                  ping_info->color_type);
             }
         }
       png_error(ping,
@@ -7466,11 +7410,6 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
       "  Writing PNG header chunks");
 
-  png_set_IHDR(ping,ping_info,ping_width,ping_height,
-               ping_bit_depth,ping_color_type,
-               ping_interlace_method,ping_compression_method,
-               ping_filter_method);
-
   png_write_info_before_PLTE(ping, ping_info);
   /* write any png-chunk-b profiles */
   (void) png_write_chunk_from_profile(image,"PNG-chunk-b",(int) logging);
@@ -7542,7 +7481,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   /*
     Initialize image scanlines.
   */
-  if (setjmp(png_jmpbuf(ping)))
+  if (setjmp(ping->jmpbuf))
     {
       /*
         PNG write failed.
@@ -7629,7 +7568,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if ((!mng_info->write_png8 && !mng_info->write_png24 && 
          !mng_info->write_png32) &&
          (image_matte ||
-         (ping_bit_depth >= MAGICKCORE_QUANTUM_DEPTH)) &&
+         (ping_info->bit_depth >= MAGICKCORE_QUANTUM_DEPTH)) &&
          (mng_info->optimize || mng_info->IsPalette) && ImageIsGray(image))
       {
         for (y=0; y < (long) image->rows; y++)
@@ -7637,7 +7576,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+          if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
             {
               if (mng_info->IsPalette)
                 (void) ExportQuantumPixels(image,(const CacheView *) NULL,
@@ -7671,7 +7610,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
             if (p == (const PixelPacket *) NULL)
               break;
-            if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+            if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
               {
                 if (image->storage_class == DirectClass)
                   (void) ExportQuantumPixels(image,(const CacheView *) NULL,
@@ -7680,7 +7619,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                     quantum_info,GrayQuantum,png_pixels,&image->exception);
               }
-            else if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
               (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                 quantum_info,GrayAlphaQuantum,png_pixels,&image->exception);
             else if (image_matte != MagickFalse)
@@ -7696,8 +7635,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             mng_info->write_png32 ||
             (!mng_info->write_png8 && !mng_info->IsPalette))) */
         {
-          if ((ping_color_type != PNG_COLOR_TYPE_GRAY) &&
-              (ping_color_type != PNG_COLOR_TYPE_GRAY_ALPHA))
+          if ((ping_info->color_type != PNG_COLOR_TYPE_GRAY) &&
+              (ping_info->color_type != PNG_COLOR_TYPE_GRAY_ALPHA))
             {
               if (logging)
                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -7713,10 +7652,10 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
             if (p == (const PixelPacket *) NULL)
               break;
-            if (ping_color_type == PNG_COLOR_TYPE_GRAY)
+            if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
               (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                 quantum_info,GrayQuantum,png_pixels,&image->exception);
-            else if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+            else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
               (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                 quantum_info,GrayAlphaQuantum,png_pixels,&image->exception);
             else
@@ -7741,25 +7680,25 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "  Writing PNG image data");
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Width: %lu",ping_width);
+        "    Width: %lu",ping_info->width);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Height: %lu",ping_height);
+        "    Height: %lu",ping_info->height);
       if (mng_info->write_png_depth)
         {
           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
             "    Defined PNG:bit-depth: %d",mng_info->write_png_depth);
         }
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    PNG bit-depth written: %d",ping_bit_depth);
+        "    PNG bit-depth written: %d",ping_info->bit_depth);
       if (mng_info->write_png_colortype)
         {
           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
             "    Defined PNG:color-type: %d",mng_info->write_png_colortype-1);
         }
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    PNG color-type written: %d",ping_color_type);
+        "    PNG color-type written: %d",ping_info->color_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    PNG Interlace method: %d",ping_interlace_method);
+        "    PNG Interlace method: %d",ping_info->interlace_type);
     }
   /*
     Generate text chunks.
@@ -7804,8 +7743,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   if (mng_info->need_fram && (int) image->dispose == BackgroundDispose)
     {
       if (mng_info->page.x || mng_info->page.y ||
-          (ping_width != mng_info->page.width) ||
-          (ping_height != mng_info->page.height))
+          (ping_info->width != mng_info->page.width) ||
+          (ping_info->height != mng_info->page.height))
         {
           unsigned char
             chunk[32];
@@ -7826,10 +7765,10 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           chunk[14]=0; /* clipping boundaries delta type */
           PNGLong(chunk+15,(png_uint_32) (mng_info->page.x)); /* left cb */
           PNGLong(chunk+19,
-             (png_uint_32) (mng_info->page.x + ping_width));
+             (png_uint_32) (mng_info->page.x + ping_info->width));
           PNGLong(chunk+23,(png_uint_32) (mng_info->page.y)); /* top cb */
           PNGLong(chunk+27,
-             (png_uint_32) (mng_info->page.y + ping_height));
+             (png_uint_32) (mng_info->page.y + ping_info->height));
           (void) WriteBlob(image,31,chunk);
           (void) WriteBlobMSBULong(image,crc32(0,chunk,31));
           mng_info->old_framing_mode=4;
@@ -7847,7 +7786,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 
   /* Save depth actually written */
 
-  s[0]=(char) ping_bit_depth;
+  s[0]=(char) ping_info->bit_depth;
   s[1]='\0';
 
   (void) SetImageProperty(image,"png:bit-depth-written",s);
@@ -7855,7 +7794,6 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   /*
     Free PNG resources.
   */
-
   png_destroy_write_struct(&ping,&ping_info);
 
   png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels);