From: glennrp <glennrp@git.imagemagick.org>
Date: Tue, 23 Mar 2010 13:35:11 +0000 (+0000)
Subject: Reverted recent changes to png.c; they cause a segfault reading certain pngs.
X-Git-Tag: 7.0.1-0~9753
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=8ab7ab8ae6afd575b9653db9dfe1206eafcbf82f;p=imagemagick

Reverted recent changes to png.c; they cause a segfault reading certain pngs.
---

diff --git a/ChangeLog b/ChangeLog
index 14eb653b6..0948653b4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,8 @@
-2010-01-22  6.6.0-9 Glenn Randers-Pehrson <glennrp@image...>
+2010-03-23  6.6.0-9 Glenn Randers-Pehrson <glennrp@image...>
+  * coders/png.c: Reverted recent changes; they cause a segfault while
+  reading certain images.
+
+2010-03-22  6.6.0-9 Glenn Randers-Pehrson <glennrp@image...>
   * coders/png.c: Eliminated support of libpng versions older than 1.0.12.
 
 2010-03-21  6.6.0-9 Cristy  <quetzlzacatenango@image...>
diff --git a/coders/png.c b/coders/png.c
index af7dd6138..d57494295 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -98,7 +98,22 @@
 /* ImageMagick differences */
 #define first_scene scene
 
-#if PNG_LIBPNG_VER > 10011
+#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 > 95
 /*
   Optional declarations. Define or undefine them as you like.
 */
@@ -161,6 +176,10 @@ static SemaphoreInfo
   PNG_MNG_FEATURES_SUPPORTED is disabled by default in libpng-1.0.9 and
   will be enabled by default in libpng-1.2.0.
 */
+#if (PNG_LIBPNG_VER == 10009)  /* work around libpng-1.0.9 bug */
+#  undef PNG_READ_EMPTY_PLTE_SUPPORTED
+#  undef PNG_WRITE_EMPTY_PLTE_SUPPORTED
+#endif
 #ifdef PNG_MNG_FEATURES_SUPPORTED
 #  ifndef PNG_READ_EMPTY_PLTE_SUPPORTED
 #    define PNG_READ_EMPTY_PLTE_SUPPORTED
@@ -478,7 +497,7 @@ static inline long MagickMin(const long x,const long y)
   return(y);
 }
 
-#if PNG_LIBPNG_VER > 10111
+#if PNG_LIBPNG_VER > 95
 #if defined(PNG_SORT_PALETTE)
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -896,7 +915,7 @@ static MagickBooleanType ImageIsMonochrome(Image *image)
   }
   return(MagickTrue);
 }
-#endif /* PNG_LIBPNG_VER > 10011 */
+#endif /* PNG_LIBPNG_VER > 95 */
 #endif /* MAGICKCORE_PNG_DELEGATE */
 
 /*
@@ -1008,7 +1027,7 @@ static MagickBooleanType IsPNG(const unsigned char *magick,const size_t length)
 extern "C" {
 #endif
 
-#if (PNG_LIBPNG_VER > 10011)
+#if (PNG_LIBPNG_VER > 95)
 static size_t WriteBlobMSBULong(Image *image,const unsigned long value)
 {
   unsigned char
@@ -1057,13 +1076,13 @@ static void LogPNGChunk(int logging, png_bytep type, size_t length)
       "  Writing %c%c%c%c chunk, length: %lu",
       type[0],type[1],type[2],type[3],(unsigned long) length);
 }
-#endif /* PNG_LIBPNG_VER > 10011 */
+#endif /* PNG_LIBPNG_VER > 95 */
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif
 
-#if PNG_LIBPNG_VER > 10011
+#if PNG_LIBPNG_VER > 95
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -1658,13 +1677,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     logging,
     num_text,
     num_passes,
-    pass,
-    ping_info_bit_depth,
-    ping_info_color_type,
-    ping_info_interlace_method,
-    ping_info_compression_method,
-    ping_info_filter_method,
-    ping_info_num_trans;
+    pass;
 
   MagickBooleanType
     status;
@@ -1672,13 +1685,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;
@@ -1686,11 +1692,6 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   png_struct
     *ping;
 
-  png_uint_32
-    ping_info_height,
-    ping_info_width,
-    ping_rowbytes;
-
   png_textp
     text;
 
@@ -1810,7 +1811,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)
@@ -1864,45 +1864,32 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #endif
 
   png_read_info(ping,ping_info);
-
-  png_get_IHDR(ping,ping_info,&ping_info_width,&ping_info_height,
-               &ping_info_bit_depth,&ping_info_color_type,
-               &ping_info_interlace_method,&ping_info_compression_method,
-               &ping_info_filter_method);
-
-  (void) png_get_tRNS(ping, ping_info, &ping_trans_alpha, &ping_info_num_trans,
-                      &ping_trans_color);
-
-  (void) png_get_bKGD(ping, ping_info, &ping_background);
-
-  ping_rowbytes=png_get_rowbytes(ping,ping_info);
-
-  if (ping_info_bit_depth < 8)
+  if (ping_info->bit_depth < 8)
     {
-      if (((int) ping_info_color_type == PNG_COLOR_TYPE_PALETTE))
+      if (((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE))
         png_set_packing(ping);
     }
-  image->depth=ping_info_bit_depth;
+  image->depth=ping_info->bit_depth;
   image->depth=GetImageQuantumDepth(image,MagickFalse);
-  image->interlace=ping_info_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_info_width, ping_info_height);
+        ping_info->width, ping_info->height);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG color_type: %d, bit_depth: %d",
-        ping_info_color_type, ping_info_bit_depth);
+        ping_info->color_type, ping_info->bit_depth);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG compression_method: %d",
-        ping_info_compression_method);
+        ping_info->compression_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG interlace_method: %d, filter_method: %d",
-        ping_info_interlace_method,ping_info_filter_method);
+        ping_info->interlace_type,ping_info->filter_type);
     }
 
 #if (PNG_LIBPNG_VER > 10008) && defined(PNG_READ_iCCP_SUPPORTED)
-  if (png_get_valid(ping,ping_info,PNG_INFO_iCCP))
+  if (ping_info->valid & PNG_INFO_iCCP)
     {
       int
         compression;
@@ -1952,9 +1939,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;
@@ -1963,22 +1949,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,
@@ -1995,14 +1968,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);
@@ -2014,18 +1995,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;
@@ -2052,8 +2022,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;
@@ -2063,13 +2050,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
       (void) png_get_PLTE(ping,ping_info,&palette,&number_colors);
       if ((number_colors == 0) &&
-          ((int) ping_info_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 >
@@ -2086,7 +2073,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;
@@ -2094,9 +2081,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)
@@ -2115,10 +2102,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.
@@ -2126,20 +2112,20 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       if (logging != MagickFalse)
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Reading PNG bKGD chunk.");
-      if (ping_info_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
@@ -2147,7 +2133,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.
@@ -2159,33 +2145,39 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Reading PNG tRNS chunk.");
 
-      max_sample = (1 << ping_info_bit_depth) - 1;
+      max_sample = (1 << ping_info->bit_depth) - 1;
 
-      if ((ping_info_color_type == PNG_COLOR_TYPE_GRAY &&
-          (int)ping_trans_color->gray > max_sample) ||
-          (ping_info_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(),
               "    Ignoring PNG tRNS chunk with out-of-range sample.");
+#if (PNG_LIBPNG_VER < 10007)
+          ping_info->trans_alpha=(unsigned char *) RelinquishMagickMemory(
+            ping_info->trans_alpha);
+          ping_info->valid&=(~PNG_INFO_tRNS);
+#else
           png_free_data(ping, ping_info, PNG_FREE_TRNS, 0);
+#endif
           image->matte=MagickFalse;
         }
       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_info_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_info_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;
@@ -2196,7 +2188,7 @@ 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
@@ -2206,13 +2198,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     Initialize image structure.
   */
   mng_info->image_box.left=0;
-  mng_info->image_box.right=(long) ping_info_width;
+  mng_info->image_box.right=(long) ping_info->width;
   mng_info->image_box.top=0;
-  mng_info->image_box.bottom=(long) ping_info_height;
+  mng_info->image_box.bottom=(long) ping_info->height;
   if (mng_info->mng_type == 0)
     {
-      mng_info->mng_width=ping_info_width;
-      mng_info->mng_height=ping_info_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;
     }
@@ -2221,14 +2213,14 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       image->page.y=mng_info->y_off[mng_info->object_id];
     }
   image->compression=ZipCompression;
-  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->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_info_bit_depth;
+      image->colors=1UL << ping_info->bit_depth;
 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
       if (image->colors > 256)
         image->colors=256;
@@ -2236,7 +2228,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       if (image->colors > 65536L)
         image->colors=65536L;
 #endif
-      if ((int) ping_info_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2259,7 +2251,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       */
       if (AcquireImageColormap(image,image->colors) == MagickFalse)
         ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
-      if ((int) ping_info_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2280,7 +2272,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           unsigned long
             scale;
 
-          scale=(QuantumRange/((1UL << ping_info_bit_depth)-1));
+          scale=(QuantumRange/((1UL << ping_info->bit_depth)-1));
           if (scale < 1)
              scale=1;
           for (i=0; i < (long) image->colors; i++)
@@ -2317,9 +2309,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");
@@ -2365,17 +2357,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       int
         depth;
 
-      depth=(long) ping_info_bit_depth;
+      depth=(long) ping_info->bit_depth;
 #endif
-      image->matte=(((int) ping_info_color_type == PNG_COLOR_TYPE_RGB_ALPHA) ||
-          ((int) ping_info_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);
@@ -2391,13 +2382,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
             r=png_pixels+row_offset;
             p=r;
-            if (ping_info_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 */
@@ -2407,9 +2398,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                        *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_info_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++;
@@ -2440,53 +2431,53 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                   *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_info_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_info_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_info_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_info_color_type == PNG_COLOR_TYPE_GRAY ||
-            ping_info_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_info_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_info_color_type == PNG_COLOR_TYPE_RGB ||
-              ping_info_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_info_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_info_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_info_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_info_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_info_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
@@ -2521,7 +2512,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       /*
         Convert grayscale image to PseudoClass pixel packets.
       */
-      image->matte=ping_info_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));
@@ -2530,7 +2521,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);
@@ -2540,7 +2531,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         indices=GetAuthenticIndexQueue(image);
         p=png_pixels+row_offset;
         r=quantum_scanline;
-        switch (ping_info_bit_depth)
+        switch (ping_info->bit_depth)
         {
           case 1:
           {
@@ -2589,7 +2580,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           }
           case 8:
           {
-            if (ping_info_color_type == 4)
+            if (ping_info->color_type == 4)
               for (x=(long) image->columns-1; x >= 0; x--)
               {
                 *r++=*p++;
@@ -2622,7 +2613,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=(Quantum) quantum;
               r++;
-              if (ping_info_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   quantum=((*p++) << 8);
                   quantum|=(*p++);
@@ -2642,7 +2633,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=quantum;
               r++;
-              if (ping_info_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   q->opacity=(*p << 8) | *(p+1);
                   q->opacity*=65537L;
@@ -2653,7 +2644,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #else /* MAGICKCORE_QUANTUM_DEPTH == 8 */
               *r++=(*p++);
               p++; /* strip low byte */
-              if (ping_info_color_type == 4)
+              if (ping_info->color_type == 4)
                 {
                   q->opacity=(Quantum) (QuantumRange-(*p++));
                   p++;
@@ -2711,7 +2702,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;
@@ -2727,16 +2718,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
     if (storage_class == PseudoClass)
    {
-      if ((int) ping_info_color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
       {
-         for (x=0; x < ping_info_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_info_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)
             {
@@ -2787,18 +2778,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             IndexPacket
               indexpacket;
 
-            if ((int) ping_info_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_info_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_info_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];
@@ -2900,6 +2891,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
@@ -2912,17 +2913,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             (void) ThrowMagickException(&image->exception,GetMagickModule(),
               ResourceLimitError,"Cloning image for object buffer failed",
               "`%s'",image->filename);
-          if (ping_info_width > 250000L || ping_info_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_info_width;
-          mng_info->ob[object_id]->height=ping_info_height;
-          mng_info->ob[object_id]->color_type=ping_info_color_type;
-          mng_info->ob[object_id]->sample_depth=ping_info_bit_depth;
-          mng_info->ob[object_id]->interlace_method=ping_info_interlace_method;
-          mng_info->ob[object_id]->compression_method=
-             ping_info_compression_method;
-          mng_info->ob[object_id]->filter_method=ping_info_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;
@@ -6341,26 +6343,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_info_height,
-    ping_info_width;
-
   long
     y;
 
@@ -6384,20 +6375,12 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     logging,
     matte;
 
-  volatile int
-    ping_info_bit_depth, 
-    ping_info_color_type,
-    ping_info_interlace_method,
-    ping_info_compression_method,
-    ping_info_filter_method,
-    ping_info_num_trans;
-
   volatile unsigned long
     image_colors,
-    image_depth,
-    old_bit_depth;
+    image_depth;
 
   unsigned long
+    old_bit_depth,
     quality,
     rowbytes,
     save_image_depth;
@@ -6409,27 +6392,6 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   LockSemaphoreInfo(png_semaphore);
 #endif
 
-  /* Initialize some stuff */
-  ping_info_bit_depth=0, 
-  ping_info_color_type=0,
-  ping_info_interlace_method=0,
-  ping_info_compression_method=0,
-  ping_info_filter_method=0,
-  ping_info_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;
@@ -6491,8 +6453,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 # endif
 #endif
   x=0;
-  ping_info_width=image->columns;
-  ping_info_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)
@@ -6507,9 +6469,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   if (logging != MagickFalse)
     {
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    width=%lu",ping_info_width);
+        "    width=%lu",ping_info->width);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    height=%lu",ping_info_height);
+        "    height=%lu",ping_info->height);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    image_matte=%u",image->matte);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6518,7 +6480,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         "    requested PNG image_depth=%lu",image->depth);
     }
   save_image_depth=image_depth;
-  ping_info_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))
@@ -6605,9 +6567,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   old_bit_depth=0;
   if (mng_info->write_png8)
     {
-      ping_info_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
-      ping_info_bit_depth=8;
-      image_depth=ping_info_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. */
@@ -6639,7 +6601,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           /*
             Set image palette.
           */
-          ping_info_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;
@@ -6682,22 +6644,24 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 #if (PNG_LIBPNG_VER > 10008)
           palette=(png_colorp) RelinquishMagickMemory(palette);
 #endif
-            image_depth=ping_info_bit_depth;
-            ping_info_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++)
               {
@@ -6713,7 +6677,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++;
@@ -6722,31 +6686,23 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   break;
               }
               for (i=0; i < (long) number_colors; i++)
-                if (trans_alpha[i] != 255)
-                  ping_info_num_trans=(unsigned short) (i+1);
-
-              if (ping_info_num_trans == 0)
-                 png_set_invalid(ping, ping_info, PNG_INFO_tRNS);
-              if (!png_get_valid(ping, ping_info, PNG_INFO_tRNS))
-                ping_info_num_trans=0;
-              if (ping_info_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_info_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)
         {
@@ -6756,21 +6712,21 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   else if (mng_info->write_png24)
     {
       image_matte=MagickFalse;
-      ping_info_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_info_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+      ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
     }
   else
     {
-      image_depth=ping_info_bit_depth;
+      image_depth=ping_info->bit_depth;
       if (mng_info->write_png_colortype)
         {
-          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)
+          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
@@ -6778,16 +6734,16 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           if (logging != MagickFalse)
              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
              "Selecting PNG colortype");
-          ping_info_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_info_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_info_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 || 
@@ -6795,7 +6751,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              image_info->type == GrayscaleType) &&
              image_matte == MagickFalse && ImageIsGray(image))
             {
-              ping_info_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 ||
@@ -6803,56 +6759,56 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               image_info->type == GrayscaleMatteType) &&
               image_matte == MagickTrue && ImageIsGray(image))
             {
-              ping_info_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_info_color_type);
+         "Selected PNG colortype=%d",ping_info->color_type);
 
-      if (ping_info_bit_depth < 8)
+      if (ping_info->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_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_info_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_info_bit_depth=1;
-                  if (ping_info_bit_depth < (int)mng_info->write_png_depth)
-                    ping_info_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_info_color_type == PNG_COLOR_TYPE_PALETTE)
+      if (ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
         {
-           ping_info_bit_depth=1;
-           while ((int) (1 << ping_info_bit_depth) < (long) image_colors)
-             ping_info_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_info_bit_depth);
+                "    Tentative PNG bit depth: %d",ping_info->bit_depth);
              }
            if (mng_info->write_png_depth)
              {
-               old_bit_depth=ping_info_bit_depth;
-               if (ping_info_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_info_bit_depth = mng_info->write_png_depth;
-                   if (ping_info_bit_depth > 8)
-                      ping_info_bit_depth = 8;
-                   if (ping_info_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(),
@@ -6862,17 +6818,17 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              }
         }
     }
-  image_depth=ping_info_bit_depth;
+  image_depth=ping_info->bit_depth;
   if (logging != MagickFalse)
     {
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Tentative PNG color type: %d",ping_info_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_info_bit_depth: %d",ping_info_bit_depth);
+        "    ping_info->bit_depth: %d",ping_info->bit_depth);
     }
 
   if (matte && (mng_info->optimize || mng_info->IsPalette))
@@ -6881,7 +6837,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         *p;
 
       p=GetVirtualPixels(image,0,0,image->columns,1,&image->exception);
-      ping_info_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);
@@ -6891,7 +6847,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         {
           if (IsGray(p) == MagickFalse)
             {
-              ping_info_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
               break;
             }
           p++;
@@ -6921,7 +6877,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             and do not set the PNG_INFO_tRNS flag in ping_info->valid.
           */
           image_matte=MagickFalse;
-          ping_info_color_type&=0x03;
+          ping_info->color_type&=0x03;
         }
       else
         {
@@ -6929,24 +6885,24 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             mask;
 
           mask=0xffff;
-          if (ping_info_bit_depth == 8)
+          if (ping_info->bit_depth == 8)
              mask=0x00ff;
-          if (ping_info_bit_depth == 4)
+          if (ping_info->bit_depth == 4)
              mask=0x000f;
-          if (ping_info_bit_depth == 2)
+          if (ping_info->bit_depth == 2)
              mask=0x0003;
-          if (ping_info_bit_depth == 1)
+          if (ping_info->bit_depth == 1)
              mask=0x0001;
           ping_info->valid|=PNG_INFO_tRNS;
-          ping_trans_color.red=(png_uint_16)
+          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))));
         }
       if (ping_info->valid & PNG_INFO_tRNS)
@@ -6966,7 +6922,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.  */
@@ -6979,7 +6935,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. */
@@ -6994,13 +6950,13 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         }
       if (ping_info->valid & PNG_INFO_tRNS)
         {
-          ping_info_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;
             }
         }
     }
@@ -7012,33 +6968,33 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         ImageIsGray(image) && (!image_matte || image_depth >= 8))
       {
         if (image_matte != MagickFalse)
-            ping_info_color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
+            ping_info->color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
         else
           {
-            ping_info_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_info_bit_depth=16;
+          ping_info->bit_depth=16;
         else
           {
-            ping_info_bit_depth=8;
-            if ((int) ping_info_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_info_bit_depth=1;
-                    while ((int) (1 << ping_info_bit_depth)
+                    ping_info->bit_depth=1;
+                    while ((int) (1 << ping_info->bit_depth)
                         < (long) image_colors)
-                      ping_info_bit_depth <<= 1;
+                      ping_info->bit_depth <<= 1;
                   }
               }
-            else if (mng_info->optimize && ping_info_color_type ==
+            else if (mng_info->optimize && ping_info->color_type ==
                 PNG_COLOR_TYPE_GRAY && image_colors < 17 && 
                 mng_info->IsPalette)
               {
@@ -7064,14 +7020,14 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                      depth_1_ok=MagickFalse;
                 }
                 if (depth_1_ok && mng_info->write_png_depth <= 1)
-                   ping_info_bit_depth=1;
+                   ping_info->bit_depth=1;
                 else if (depth_2_ok && mng_info->write_png_depth <= 2)
-                   ping_info_bit_depth=2;
+                   ping_info->bit_depth=2;
                 else if (depth_4_ok && mng_info->write_png_depth <= 4)
-                   ping_info_bit_depth=4;
+                   ping_info->bit_depth=4;
               }
           }
-          image_depth=ping_info_bit_depth;
+          image_depth=ping_info->bit_depth;
       }
     else
       if (mng_info->IsPalette)
@@ -7087,7 +7043,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             /*
               Set image palette.
             */
-            ping_info_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)
               {
@@ -7137,9 +7093,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               {
                 ping_info->bit_depth=1;
                 while ((1UL << ping_info->bit_depth) < number_colors)
-                  ping_info_bit_depth <<= 1;
+                  ping_info->bit_depth <<= 1;
               }
-            ping_info_num_trans=0;
+            ping_info->num_trans=0;
             if (matte)
             {
               ExceptionInfo
@@ -7181,7 +7137,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                           if (trans[(long) packet_index] != (png_byte) (255-
                              ScaleQuantumToChar(GetOpacityPixelComponent(p))))
                             {
-                              ping_info_color_type=(png_byte)
+                              ping_info->color_type=(png_byte)
                                 PNG_COLOR_TYPE_RGB_ALPHA;
                               break;
                             }
@@ -7191,9 +7147,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                     }
                   p++;
                 }
-                if ((int) ping_info_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+                if ((int) ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                 {
-                  ping_info_num_trans=0;
+                  ping_info->num_trans=0;
                   ping_info->valid&=(~PNG_INFO_tRNS);
                   ping_info->valid&=(~PNG_INFO_PLTE);
                   mng_info->IsPalette=MagickFalse;
@@ -7211,22 +7167,22 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   if (trans[i] == 256)
                     trans[i]=255;
                   if (trans[i] != 255)
-                    ping_info_num_trans=(unsigned short) (i+1);
+                    ping_info->num_trans=(unsigned short) (i+1);
                 }
               }
-              if (ping_info_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_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];
               }
             }
 
@@ -7234,9 +7190,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
@@ -7245,17 +7201,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_info_bit_depth < 8 && ping_info_color_type ==
+    if (ping_info->bit_depth < 8 && ping_info->color_type ==
         PNG_COLOR_TYPE_GRAY)
       {
          png_uint_16
@@ -7264,7 +7220,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
          png_color_16
            background;
 
-         maxval=(png_uint_16) ((1 << ping_info_bit_depth)-1);
+         maxval=(png_uint_16) ((1 << ping_info->bit_depth)-1);
 
 
          background.gray=(png_uint_16)
@@ -7275,12 +7231,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_info_color_type);
+      "    PNG color type: %d",ping_info->color_type);
   /*
     Initialize compression level and filtering.
   */
@@ -7328,7 +7284,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if (logging != MagickFalse)
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Filter_type: PNG_INTRAPIXEL_DIFFERENCING");
-      ping_info_filter_method=PNG_INTRAPIXEL_DIFFERENCING;
+      ping_info->filter_type=PNG_INTRAPIXEL_DIFFERENCING;
     }
   else
     if (logging != MagickFalse)
@@ -7345,8 +7301,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if ((quality % 10) != 5)
         base_filter=(int) quality % 10;
       else
-        if (((int) ping_info_color_type == PNG_COLOR_TYPE_GRAY) ||
-            ((int) ping_info_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
@@ -7440,7 +7396,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                bp.x,bp.y);
        }
     }
-  ping_info_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);
@@ -7452,22 +7408,22 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
      if (mng_info->write_png_colortype-1 == PNG_COLOR_TYPE_GRAY)
        if (ImageIsGray(image) == MagickFalse)
          {
-           ping_info_color_type = PNG_COLOR_TYPE_RGB;
-           if (ping_info_bit_depth < 8)
-             ping_info_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_info_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_info_bit_depth) ||
+      mng_info->write_png_depth != ping_info->bit_depth) ||
      (mng_info->write_png_colortype &&
-     ((int) mng_info->write_png_colortype-1 != ping_info_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_info_color_type == 0))))
+      !(mng_info->write_png_colortype == 5 && ping_info->color_type == 0))))
     {
       if (logging != MagickFalse)
         {
@@ -7476,14 +7432,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_info_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_info_color_type);
+                  ping_info->color_type);
             }
         }
       png_error(ping,
@@ -7501,11 +7457,6 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
       "  Writing PNG header chunks");
 
-  png_set_IHDR(ping,ping_info,ping_info_width,ping_info_height,
-               ping_info_bit_depth,ping_info_color_type,
-               ping_info_interlace_method,ping_info_compression_method,
-               ping_info_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);
@@ -7664,7 +7615,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if ((!mng_info->write_png8 && !mng_info->write_png24 && 
          !mng_info->write_png32) &&
          (image_matte ||
-         (ping_info_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++)
@@ -7672,7 +7623,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_info_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,
@@ -7706,7 +7657,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_info_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,
@@ -7715,7 +7666,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                     quantum_info,GrayQuantum,png_pixels,&image->exception);
               }
-            else if (ping_info_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)
@@ -7731,8 +7682,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             mng_info->write_png32 ||
             (!mng_info->write_png8 && !mng_info->IsPalette))) */
         {
-          if ((ping_info_color_type != PNG_COLOR_TYPE_GRAY) &&
-              (ping_info_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(),
@@ -7748,10 +7699,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_info_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_info_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
@@ -7776,25 +7727,25 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "  Writing PNG image data");
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Width: %lu",ping_info_width);
+        "    Width: %lu",ping_info->width);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Height: %lu",ping_info_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_info_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_info_color_type);
+        "    PNG color-type written: %d",ping_info->color_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    PNG Interlace method: %d",ping_info_interlace_method);
+        "    PNG Interlace method: %d",ping_info->interlace_type);
     }
   /*
     Generate text chunks.
@@ -7814,6 +7765,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     value=GetImageProperty(image,property);
     if (value != (const char *) NULL)
       {
+#if (PNG_LIBPNG_VER > 10005)
         text=(png_textp) png_malloc(ping,(png_uint_32) sizeof(png_text));
         text[0].key=(char *) property;
         text[0].text=(char *) value;
@@ -7830,6 +7782,38 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           }
         png_set_text(ping,ping_info,text,1);
         png_free(ping,text);
+#else
+/* Work directly with ping_info struct; png_set_text before libpng version
+ * 1.0.5a is leaky */
+        if (ping_info->num_text == 0)
+          {
+            ping_info->text=(png_text *) AcquireQuantumMemory(256,
+              sizeof(*ping_info->text));
+            if (ping_info->text == (png_text *) NULL)
+              (void) ThrowMagickException(&image->exception,GetMagickModule(),
+                ResourceLimitError,"MemoryAllocationFailed","`%s'",
+                image->filename);
+          }
+        i=ping_info->num_text++;
+        if (i > 255)
+          (void) ThrowMagickException(&image->exception,GetMagickModule(),
+            ResourceLimitError,"Cannot write more than 256 PNG text chunks",
+            "`%s'",image->filename);
+        ping_info->text[i].key=(char *) property;
+        ping_info->text[i].text=(char *) value;
+        ping_info->text[i].text_length=strlen(value);
+        ping_info->text[i].compression=
+          image_info->compression == NoCompression ||
+          (image_info->compression == UndefinedCompression &&
+          ping_info->text[i].text_length < 128) ? -1 : 0;
+        if (logging != MagickFalse)
+          {
+            (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+              "  Setting up text chunk");
+            (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+              "    keyword: %s",ping_info->text[i].key);
+          }
+#endif
       }
     property=GetNextImageProperty(image);
   }
@@ -7844,8 +7828,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_info_width != mng_info->page.width) ||
-          (ping_info_height != mng_info->page.height))
+          (ping_info->width != mng_info->page.width) ||
+          (ping_info->height != mng_info->page.height))
         {
           unsigned char
             chunk[32];
@@ -7866,10 +7850,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_info_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_info_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;
@@ -7887,7 +7871,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 
   /* Save depth actually written */
 
-  s[0]=(char) ping_info_bit_depth;
+  s[0]=(char) ping_info->bit_depth;
   s[1]='\0';
 
   (void) SetImageProperty(image,"png:bit-depth-written",s);
@@ -7895,6 +7879,20 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   /*
     Free PNG resources.
   */
+#if (PNG_LIBPNG_VER < 10007)
+  if (ping_info->valid & PNG_INFO_PLTE)
+    {
+      ping_info->palette=(png_colorp)
+        RelinquishMagickMemory(ping_info->palette);
+      ping_info->valid&=(~PNG_INFO_PLTE);
+    }
+  if (ping_info->valid & PNG_INFO_tRNS)
+    {
+      ping_info->trans_alpha=(unsigned char *) RelinquishMagickMemory(
+        ping_info->trans_alpha);
+      ping_info->valid&=(~PNG_INFO_tRNS);
+    }
+#endif
 
   png_destroy_write_struct(&ping,&ping_info);
 
@@ -8775,7 +8773,7 @@ static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
     final_delay=0,
     initial_delay;
 
-#if (PNG_LIBPNG_VER < 10200)
+#if (PNG_LIBPNG_VER < 10007)
     if (image_info->verbose)
       printf("Your PNG library (libpng-%s) is rather old.\n",
          PNG_LIBPNG_VER_STRING);
@@ -9575,7 +9573,7 @@ static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"exit WriteMNGImage()");
   return(MagickTrue);
 }
-#else /* PNG_LIBPNG_VER > 10011 */
+#else /* PNG_LIBPNG_VER > 95 */
 static MagickBooleanType WritePNGImage(const ImageInfo *image_info,Image *image)
 {
   image=image;
@@ -9588,5 +9586,5 @@ static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
 {
   return(WritePNGImage(image_info,image));
 }
-#endif /* PNG_LIBPNG_VER > 10011 */
+#endif /* PNG_LIBPNG_VER > 95 */
 #endif