From: glennrp <glennrp@git.imagemagick.org>
Date: Wed, 24 Mar 2010 20:47:28 +0000 (+0000)
Subject: Retry the png updates, with relocated png_get_rowbytes() call.
X-Git-Tag: 7.0.1-0~9746
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=fb0f3953642fb6b185a4cb995d08dae9e672e6fa;p=imagemagick

Retry the png updates, with relocated png_get_rowbytes() call.
---

diff --git a/ChangeLog b/ChangeLog
index 4222098ce..17ea49fb0 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,9 +1,6 @@
 2010-03-24  6.6.0-9 Glenn Randers-Pehrson <glennrp@image...>
   * coders/png.c: Eliminated support of libpng versions older than 1.0.12.
-
-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.
+  * Relocated the new, misplaced png_get_rowbytes() call.
 
 2010-03-21  6.6.0-9 Cristy  <quetzlzacatenango@image...>
   * Windows does not support complex.h (reference
diff --git a/coders/png.c b/coders/png.c
index a91c184f5..1f552b42a 100644
--- a/coders/png.c
+++ b/coders/png.c
@@ -98,21 +98,6 @@
 /* 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.
@@ -1673,7 +1658,13 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     logging,
     num_text,
     num_passes,
-    pass;
+    pass,
+    ping_bit_depth,
+    ping_color_type,
+    ping_interlace_method,
+    ping_compression_method,
+    ping_filter_method,
+    ping_num_trans;
 
   MagickBooleanType
     status;
@@ -1681,6 +1672,13 @@ 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;
@@ -1691,6 +1689,11 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   png_textp
     text;
 
+  png_uint_32
+    ping_height,
+    ping_width,
+    ping_rowbytes;
+
   QuantumInfo
     *quantum_info;
 
@@ -1738,7 +1741,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   LockSemaphoreInfo(png_semaphore);
 #endif
 
-#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);
@@ -1807,6 +1810,7 @@ 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)
@@ -1860,32 +1864,43 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #endif
 
   png_read_info(ping,ping_info);
-  if (ping_info->bit_depth < 8)
+
+  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 (((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE))
+      if (((int) ping_color_type == PNG_COLOR_TYPE_PALETTE))
         png_set_packing(ping);
     }
-  image->depth=ping_info->bit_depth;
+  image->depth=ping_bit_depth;
   image->depth=GetImageQuantumDepth(image,MagickFalse);
-  image->interlace=ping_info->interlace_type != 0 ? PNGInterlace : NoInterlace;
+  image->interlace=ping_interlace_method != 0 ? PNGInterlace : NoInterlace;
   if (logging != MagickFalse)
     {
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG width: %lu, height: %lu",
-        ping_info->width, ping_info->height);
+        ping_width, ping_height);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG color_type: %d, bit_depth: %d",
-        ping_info->color_type, ping_info->bit_depth);
+        ping_color_type, ping_bit_depth);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG compression_method: %d",
-        ping_info->compression_type);
+        ping_compression_method);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG interlace_method: %d, filter_method: %d",
-        ping_info->interlace_type,ping_info->filter_type);
+        ping_interlace_method,ping_filter_method);
     }
 
-#if defined(PNG_READ_iCCP_SUPPORTED)
-  if (ping_info->valid & PNG_INFO_iCCP)
+#if (PNG_LIBPNG_VER > 10008) && defined(PNG_READ_iCCP_SUPPORTED)
+  if (png_get_valid(ping,ping_info,PNG_INFO_iCCP))
     {
       int
         compression;
@@ -1935,8 +1950,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
      double
         file_gamma;
 
-     if (mng_info->have_global_gama)
-       image->gamma=mng_info->global_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 (png_get_gAMA(ping,ping_info,&file_gamma))
        {
          image->gamma=(float) file_gamma;
@@ -1945,9 +1961,22 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
              "    Reading PNG gAMA chunk: gamma: %f",file_gamma);
        }
   }
-  if (mng_info->have_global_chrm != MagickFalse)
-    image->chromaticity=mng_info->global_chrm;
-  if (ping_info->valid & PNG_INFO_cHRM)
+  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))
     {
       (void) png_get_cHRM(ping,ping_info,
         &image->chromaticity.white_point.x,
@@ -1964,22 +1993,14 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     }
   if (image->rendering_intent)
     {
-      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;
+      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);
     }
-  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 (ping_info->valid & PNG_INFO_oFFs)
+  if (png_get_valid(ping,ping_info,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);
@@ -1991,7 +2012,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     }
 #endif
 #if defined(PNG_pHYs_SUPPORTED)
-  if (ping_info->valid & PNG_INFO_pHYs)
+  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))
     {
       int
         unit_type;
@@ -2018,25 +2050,8 @@ 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 (ping_info->valid & PNG_INFO_PLTE)
+  if (png_get_valid(ping,ping_info,PNG_INFO_PLTE))
     {
       int
         number_colors;
@@ -2046,13 +2061,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_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 ((ping_info->valid & PNG_INFO_tRNS) == 0)
+              if (!png_get_valid(ping,ping_info,PNG_INFO_tRNS))
                 if (mng_info->global_trns_length)
                   {
                     if (mng_info->global_trns_length >
@@ -2069,7 +2084,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #ifndef PNG_READ_EMPTY_PLTE_SUPPORTED
                    mng_info->have_saved_bkgd_index ||
 #endif
-                   ping_info->valid & PNG_INFO_bKGD)
+                   png_get_valid(ping,ping_info,PNG_INFO_bKGD))
                     {
                       png_color_16
                          background;
@@ -2077,9 +2092,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
-                        background.index=ping_info->background.index;
+                      if (png_get_valid(ping, ping_info, PNG_INFO_bKGD))
+                        background.index=ping_background->index;
                       background.red=(png_uint_16)
                         mng_info->global_plte[background.index].red;
                       background.green=(png_uint_16)
@@ -2098,9 +2113,10 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         }
 
 #if defined(PNG_READ_bKGD_SUPPORTED)
-  if (mng_info->have_global_bkgd && !(ping_info->valid & PNG_INFO_bKGD))
+  if (mng_info->have_global_bkgd &&
+          (!png_get_valid(ping,ping_info,PNG_INFO_bKGD)))
       image->background_color=mng_info->mng_global_bkgd;
-  if (ping_info->valid & PNG_INFO_bKGD)
+  if (png_get_valid(ping,ping_info,PNG_INFO_bKGD))
     {
       /*
         Set image background color.
@@ -2108,20 +2124,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_bit_depth <= MAGICKCORE_QUANTUM_DEPTH)
         {
-          image->background_color.red=ping_info->background.red;
-          image->background_color.green=ping_info->background.green;
-          image->background_color.blue=ping_info->background.blue;
+          image->background_color.red=ping_background->red;
+          image->background_color.green=ping_background->green;
+          image->background_color.blue=ping_background->blue;
         }
       else
         {
           image->background_color.red=
-            ScaleShortToQuantum(ping_info->background.red);
+            ScaleShortToQuantum(ping_background->red);
           image->background_color.green=
-            ScaleShortToQuantum(ping_info->background.green);
+            ScaleShortToQuantum(ping_background->green);
           image->background_color.blue=
-            ScaleShortToQuantum(ping_info->background.blue);
+            ScaleShortToQuantum(ping_background->blue);
         }
     }
 #endif
@@ -2129,7 +2145,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   transparent_color.green=0;
   transparent_color.blue=0;
   transparent_color.opacity=0;
-  if (ping_info->valid & PNG_INFO_tRNS)
+  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
     {
       /*
         Image has a transparent background.
@@ -2141,14 +2157,14 @@ 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_bit_depth) - 1;
 
-      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 ((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 (logging != MagickFalse)
             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -2158,16 +2174,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         }
       else
         {
-          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)
+          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)
             {
-              if (ping_info->bit_depth < 8)
+              if (ping_bit_depth < 8)
                 {
                   transparent_color.opacity=(Quantum) (((
-                    ping_info->trans_color.gray)*255)/max_sample);
+                    ping_trans_color->gray)*255)/max_sample);
                 }
               transparent_color.red=transparent_color.opacity;
               transparent_color.green=transparent_color.opacity;
@@ -2178,23 +2194,27 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 #if defined(PNG_READ_sBIT_SUPPORTED)
   if (mng_info->have_global_sbit)
     {
-      if (!(ping_info->valid & PNG_INFO_sBIT))
+      if (!png_get_valid(ping,ping_info,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_info->width;
+  mng_info->image_box.right=(long) ping_width;
   mng_info->image_box.top=0;
-  mng_info->image_box.bottom=(long) ping_info->height;
+  mng_info->image_box.bottom=(long) ping_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_width;
+      mng_info->mng_height=ping_height;
       mng_info->frame=mng_info->image_box;
       mng_info->clip=mng_info->image_box;
     }
@@ -2203,14 +2223,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_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->storage_class=PseudoClass;
-      image->colors=1UL << ping_info->bit_depth;
+      image->colors=1UL << ping_bit_depth;
 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
       if (image->colors > 256)
         image->colors=256;
@@ -2218,7 +2238,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_color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2241,7 +2261,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_color_type == PNG_COLOR_TYPE_PALETTE)
         {
           int
             number_colors;
@@ -2262,7 +2282,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           unsigned long
             scale;
 
-          scale=(QuantumRange/((1UL << ping_info->bit_depth)-1));
+          scale=(QuantumRange/((1UL << ping_bit_depth)-1));
           if (scale < 1)
              scale=1;
           for (i=0; i < (long) image->colors; i++)
@@ -2299,9 +2319,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       "    Reading PNG IDAT chunk(s)");
   if (num_passes > 1)
     png_pixels=(unsigned char *) AcquireQuantumMemory(image->rows,
-      ping_info->rowbytes*sizeof(*png_pixels));
+      ping_rowbytes*sizeof(*png_pixels));
   else
-    png_pixels=(unsigned char *) AcquireQuantumMemory(ping_info->rowbytes,
+    png_pixels=(unsigned char *) AcquireQuantumMemory(ping_rowbytes,
       sizeof(*png_pixels));
   if (png_pixels == (unsigned char *) NULL)
     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
@@ -2347,16 +2367,17 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       int
         depth;
 
-      depth=(long) ping_info->bit_depth;
+      depth=(long) ping_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) ||
-          (ping_info->valid & PNG_INFO_tRNS)) ? MagickTrue : MagickFalse;
+      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;
 
       for (y=0; y < (long) image->rows; y++)
       {
         if (num_passes > 1)
-          row_offset=ping_info->rowbytes*y;
+          row_offset=ping_rowbytes*y;
         else
           row_offset=0;
         png_read_row(ping,png_pixels+row_offset,NULL);
@@ -2372,13 +2393,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_color_type == PNG_COLOR_TYPE_GRAY)
               {
                 for (x=(long) image->columns-1; x >= 0; x--)
                 {
                   *r++=*p++;
                   p++;
-                  if ((ping_info->valid & PNG_INFO_tRNS) &&
+                  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS)) &&
                      (((*(p-2) << 8)|*(p-1)) == transparent_color.opacity))
                     {
                        /* Cheap transparency */
@@ -2388,9 +2409,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                        *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_info->color_type == PNG_COLOR_TYPE_RGB)
+            else if (ping_color_type == PNG_COLOR_TYPE_RGB)
               {
-              if (ping_info->valid & PNG_INFO_tRNS)
+              if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
                 for (x=(long) image->columns-1; x >= 0; x--)
                 {
                   *r++=*p++;
@@ -2421,53 +2442,53 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                   *r++=OpaqueOpacity;
                 }
               }
-            else if (ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+            else if (ping_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_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_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_color_type == PNG_COLOR_TYPE_GRAY ||
+            ping_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_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_color_type == PNG_COLOR_TYPE_RGB ||
+              ping_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_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_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_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_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_color_type == PNG_COLOR_TYPE_PALETTE)
           (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
             IndexQuantum,png_pixels+row_offset,exception);
         else
@@ -2502,7 +2523,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_color_type == PNG_COLOR_TYPE_GRAY_ALPHA ?
         MagickTrue : MagickFalse;
       quantum_scanline=(Quantum *) AcquireQuantumMemory(image->columns,
         (image->matte ?  2 : 1)*sizeof(*quantum_scanline));
@@ -2511,7 +2532,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       for (y=0; y < (long) image->rows; y++)
       {
         if (num_passes > 1)
-          row_offset=ping_info->rowbytes*y;
+          row_offset=ping_rowbytes*y;
         else
           row_offset=0;
         png_read_row(ping,png_pixels+row_offset,NULL);
@@ -2521,7 +2542,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_bit_depth)
         {
           case 1:
           {
@@ -2570,7 +2591,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           }
           case 8:
           {
-            if (ping_info->color_type == 4)
+            if (ping_color_type == 4)
               for (x=(long) image->columns-1; x >= 0; x--)
               {
                 *r++=*p++;
@@ -2603,7 +2624,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=(Quantum) quantum;
               r++;
-              if (ping_info->color_type == 4)
+              if (ping_color_type == 4)
                 {
                   quantum=((*p++) << 8);
                   quantum|=(*p++);
@@ -2623,7 +2644,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
               quantum|=(*p++);
               *r=quantum;
               r++;
-              if (ping_info->color_type == 4)
+              if (ping_color_type == 4)
                 {
                   q->opacity=(*p << 8) | *(p+1);
                   q->opacity*=65537L;
@@ -2634,7 +2655,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_color_type == 4)
                 {
                   q->opacity=(Quantum) (QuantumRange-(*p++));
                   p++;
@@ -2692,7 +2713,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           "  exit ReadOnePNGImage() early.");
       return(image);
     }
-  if (ping_info->valid & PNG_INFO_tRNS)
+  if (png_get_valid(ping,ping_info,PNG_INFO_tRNS))
     {
       ClassType
         storage_class;
@@ -2708,16 +2729,16 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
 
     if (storage_class == PseudoClass)
    {
-      if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
+      if ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE)
       {
-         for (x=0; x < ping_info->num_trans; x++)
+         for (x=0; x < ping_num_trans; x++)
          {
-            image->colormap[x].opacity = ScaleCharToQuantum((unsigned char)(255-ping_info->trans_alpha[x]));
+            image->colormap[x].opacity = ScaleCharToQuantum((unsigned char)(255-ping_trans_alpha[x]));
          }
       }
-      else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
+      else if (ping_color_type == PNG_COLOR_TYPE_GRAY)
       {
-         for (x=0; x < image->colors; x++)
+         for (x=0; x < (int) image->colors; x++)
          {
             if (image->colormap[x].red == transparent_color.opacity)
             {
@@ -2768,18 +2789,18 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             IndexPacket
               indexpacket;
 
-            if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
+            if ((int) ping_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_num_trans)
                   q->opacity=ScaleCharToQuantum((unsigned char)
-                    (255-ping_info->trans_alpha[(long) indexpacket]));
+                    (255-ping_trans_alpha[(long) indexpacket]));
                 else
                   SetOpacityPixelComponent(q,OpaqueOpacity);
                 q++;
               }
-            else if (ping_info->color_type == PNG_COLOR_TYPE_GRAY)
+            else if (ping_color_type == PNG_COLOR_TYPE_GRAY)
               for (x=0; x < (long) image->columns; x++)
               {
                 indexpacket=indices[x];
@@ -2881,16 +2902,6 @@ 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
@@ -2903,18 +2914,17 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
             (void) ThrowMagickException(&image->exception,GetMagickModule(),
               ResourceLimitError,"Cloning image for object buffer failed",
               "`%s'",image->filename);
-          png_get_IHDR(ping,ping_info,&width,&height,&bit_depth,&color_type,
-            &interlace_method,&compression_method,&filter_method);
-          if (width > 250000L || height > 250000L)
+          if (ping_width > 250000L || ping_height > 250000L)
              png_error(ping,"PNG Image dimensions are too large.");
-          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)
+          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))
             {
               int
                 number_colors;
@@ -5885,7 +5895,7 @@ static Image *ReadMNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"exit ReadMNGImage()");
   return(GetFirstImageInList(image));
 }
-#else /* PNG_LIBPNG_VER > 10011 */
+#else /* PNG_LIBPNG_VER > 95 */
 static Image *ReadPNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
 {
   printf("Your PNG library is too old: You have libpng-%s\n",
@@ -5898,7 +5908,7 @@ static Image *ReadMNGImage(const ImageInfo *image_info,ExceptionInfo *exception)
 {
   return(ReadPNGImage(image_info,exception));
 }
-#endif /* PNG_LIBPNG_VER > 10011 */
+#endif /* PNG_LIBPNG_VER > 95 */
 #endif
 
 /*
@@ -5952,12 +5962,14 @@ ModuleExport unsigned long RegisterPNGImage(void)
 #if defined(PNG_LIBPNG_VER_STRING)
   (void) ConcatenateMagickString(version,"libpng ",MaxTextExtent);
   (void) ConcatenateMagickString(version,PNG_LIBPNG_VER_STRING,MaxTextExtent);
+#if (PNG_LIBPNG_VER > 10005)
   if (LocaleCompare(PNG_LIBPNG_VER_STRING,png_get_header_ver(NULL)) != 0)
     {
       (void) ConcatenateMagickString(version,",",MaxTextExtent);
       (void) ConcatenateMagickString(version,png_get_libpng_ver(NULL),
             MaxTextExtent);
     }
+#endif
 #endif
   entry=SetMagickInfo("MNG");
   entry->seekable_stream=MagickTrue;  /* To do: eliminate this. */
@@ -6086,7 +6098,7 @@ ModuleExport void UnregisterPNGImage(void)
 }
 
 #if defined(MAGICKCORE_PNG_DELEGATE)
-#if PNG_LIBPNG_VER > 10011
+#if PNG_LIBPNG_VER > 95
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -6164,11 +6176,26 @@ ModuleExport void UnregisterPNGImage(void)
 %    transparent region at the top and/or left.
 */
 
+#if (PNG_LIBPNG_VER > 99 && PNG_LIBPNG_VER < 10007)
+/* This function became available in libpng version 1.0.6g. */
+static void
+png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
+{
+    if (png_ptr->zbuf)
+       png_free(png_ptr, png_ptr->zbuf); png_ptr->zbuf=NULL;
+    png_ptr->zbuf_size=(png_size_t) size;
+    png_ptr->zbuf=(png_bytep) png_malloc(png_ptr, size);
+    if (png_ptr->zbuf == 0)
+       png_error(png_ptr,"Unable to allocate zbuf");
+}
+#endif
+
 static void
 png_write_raw_profile(const ImageInfo *image_info,png_struct *ping,
    png_info *ping_info, unsigned char *profile_type, unsigned char
    *profile_description, unsigned char *profile_data, png_uint_32 length)
 {
+#if (PNG_LIBPNG_VER > 10005)
    png_textp
      text;
 
@@ -6187,7 +6214,19 @@ png_write_raw_profile(const ImageInfo *image_info,png_struct *ping,
 
    unsigned char
      hex[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+#endif
 
+#if (PNG_LIBPNG_VER <= 10005)
+   if (image_info->verbose)
+     (void) printf("Not ");
+   image_info=image_info;
+   ping=ping;
+   ping_info=ping_info;
+   profile_type=profile_type;
+   profile_description=profile_description;
+   profile_data=profile_data;
+   length=length;
+#endif
    if (LocaleNCompare((char *) profile_type+1, "ng-chunk-",9) == 0)
       return;
 
@@ -6196,6 +6235,7 @@ png_write_raw_profile(const ImageInfo *image_info,png_struct *ping,
      (void) printf("writing raw profile: type=%s, length=%lu\n",
        (char *) profile_type, length);
      }
+#if (PNG_LIBPNG_VER > 10005)
    text=(png_textp) png_malloc(ping,(png_uint_32) sizeof(png_text));
    description_length=(png_uint_32) strlen((const char *) profile_description);
    allocated_length=(png_uint_32) (length*2 + (length >> 5) + 20
@@ -6234,6 +6274,7 @@ png_write_raw_profile(const ImageInfo *image_info,png_struct *ping,
    png_free(ping,text[0].text);
    png_free(ping,text[0].key);
    png_free(ping,text);
+#endif
 }
 
 static MagickBooleanType png_write_chunk_from_profile(Image *image,
@@ -6302,15 +6343,26 @@ 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;
 
@@ -6334,12 +6386,20 @@ 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;
+    image_depth,
+    old_bit_depth;
 
   unsigned long
-    old_bit_depth,
     quality,
     rowbytes,
     save_image_depth;
@@ -6351,6 +6411,27 @@ 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;
@@ -6412,8 +6493,8 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 # endif
 #endif
   x=0;
-  ping_info->width=image->columns;
-  ping_info->height=image->rows;
+  ping_width=image->columns;
+  ping_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)
@@ -6428,9 +6509,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   if (logging != MagickFalse)
     {
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    width=%lu",ping_info->width);
+        "    width=%lu",ping_width);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    height=%lu",ping_info->height);
+        "    height=%lu",ping_height);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    image_matte=%u",image->matte);
      (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6439,7 +6520,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_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))
@@ -6526,9 +6607,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_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+      ping_bit_depth=8;
+      image_depth=ping_bit_depth;
         {
           /* TO DO: make this a function cause it's used twice, except
              for reducing the sample depth from 8. */
@@ -6560,7 +6641,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           /*
             Set image palette.
           */
-          ping_info->color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+          ping_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
           ping_info->valid|=PNG_INFO_PLTE;
 #if defined(PNG_SORT_PALETTE)
           save_number_colors=image_colors;
@@ -6600,25 +6681,25 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
               palette[i].blue=ScaleQuantumToChar((Quantum) QuantumRange);
             }
           png_set_PLTE(ping,ping_info,palette,(int) number_colors);
+#if (PNG_LIBPNG_VER > 10008)
           palette=(png_colorp) RelinquishMagickMemory(palette);
-            image_depth=ping_info->bit_depth;
-            ping_info->num_trans=0;
+#endif
+            image_depth=ping_bit_depth;
+            ping_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++)
-                 ping_info->trans_alpha[i]=255;
+                 trans_alpha[i]=255;
               exception=(&image->exception);
               for (y=0; y < (long) image->rows; y++)
               {
@@ -6634,7 +6715,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   if (p->opacity != OpaqueOpacity)
                     {
                       indices[x]=(IndexPacket) (number_colors-1);
-                      ping_info->trans_alpha[(long) indices[x]]=(png_byte) (255-
+                      trans_alpha[(long) indices[x]]=(png_byte) (255-
                         ScaleQuantumToChar(GetOpacityPixelComponent(p)));
                     }
                   p++;
@@ -6643,23 +6724,31 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                   break;
               }
               for (i=0; i < (long) number_colors; i++)
-                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);
+                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);
             }
           /*
             Identify which colormap entry is the background color.
           */
           for (i=0; i < (long) MagickMax(1L*number_colors-1L,1L); i++)
-            if (IsPNGColorEqual(ping_info->background,image->colormap[i]))
+            if (IsPNGColorEqual(ping_background,image->colormap[i]))
               break;
-          ping_info->background.index=(png_byte) i;
+          ping_background.index=(png_byte) i;
         }
       if (image_matte != MagickFalse)
         {
@@ -6669,21 +6758,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_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_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
     }
   else
     {
-      image_depth=ping_info->bit_depth;
+      image_depth=ping_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_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)
             image_matte=MagickTrue;
         }
       else
@@ -6691,16 +6780,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_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_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_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
               image_matte=MagickTrue;
             }
           if ((image_info->type == UndefinedType || 
@@ -6708,7 +6797,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_color_type=(png_byte) PNG_COLOR_TYPE_GRAY;
               image_matte=MagickFalse;
             }
           if ((image_info->type == UndefinedType ||
@@ -6716,56 +6805,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_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_color_type);
 
-      if (ping_info->bit_depth < 8)
+      if (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_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)
+      if (ping_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 < mng_info->write_png_depth)
-                    ping_info->bit_depth = mng_info->write_png_depth;
+                  ping_bit_depth=1;
+                  if (ping_bit_depth < (int)mng_info->write_png_depth)
+                    ping_bit_depth = mng_info->write_png_depth;
                 }
             }
         }
-      if (ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
+      if (ping_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_bit_depth=1;
+           while ((int) (1 << ping_bit_depth) < (long) image_colors)
+             ping_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_bit_depth);
              }
            if (mng_info->write_png_depth)
              {
-               old_bit_depth=ping_info->bit_depth;
-               if (ping_info->bit_depth < mng_info->write_png_depth)
+               old_bit_depth=ping_bit_depth;
+               if (ping_bit_depth < (int)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 != old_bit_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)
                      {
                        if (logging != MagickFalse)
                          (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6775,17 +6864,17 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              }
         }
     }
-  image_depth=ping_info->bit_depth;
+  image_depth=ping_bit_depth;
   if (logging != MagickFalse)
     {
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Tentative PNG color type: %d",ping_info->color_type);
+        "    Tentative PNG color type: %d",ping_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_bit_depth: %d",ping_bit_depth);
     }
 
   if (matte && (mng_info->optimize || mng_info->IsPalette))
@@ -6794,7 +6883,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_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);
@@ -6804,7 +6893,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         {
           if (IsGray(p) == MagickFalse)
             {
-              ping_info->color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
+              ping_color_type=(png_byte) PNG_COLOR_TYPE_RGB_ALPHA;
               break;
             }
           p++;
@@ -6834,7 +6923,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_color_type&=0x03;
         }
       else
         {
@@ -6842,24 +6931,24 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             mask;
 
           mask=0xffff;
-          if (ping_info->bit_depth == 8)
+          if (ping_bit_depth == 8)
              mask=0x00ff;
-          if (ping_info->bit_depth == 4)
+          if (ping_bit_depth == 4)
              mask=0x000f;
-          if (ping_info->bit_depth == 2)
+          if (ping_bit_depth == 2)
              mask=0x0003;
-          if (ping_info->bit_depth == 1)
+          if (ping_bit_depth == 1)
              mask=0x0001;
           ping_info->valid|=PNG_INFO_tRNS;
-          ping_info->trans_color.red=(png_uint_16)
+          ping_trans_color.red=(png_uint_16)
             (ScaleQuantumToShort(GetRedPixelComponent(p)) & mask);
-          ping_info->trans_color.green=(png_uint_16)
+          ping_trans_color.green=(png_uint_16)
             (ScaleQuantumToShort(GetGreenPixelComponent(p)) & mask);
-          ping_info->trans_color.blue=(png_uint_16)
+          ping_trans_color.blue=(png_uint_16)
             (ScaleQuantumToShort(GetBluePixelComponent(p)) & mask);
-          ping_info->trans_color.gray=(png_uint_16)
+          ping_trans_color.gray=(png_uint_16)
             (ScaleQuantumToShort(PixelIntensityToQuantum(p)) & mask);
-          ping_info->trans_color.index=(png_byte)
+          ping_trans_color.index=(png_byte)
             (ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p))));
         }
       if (ping_info->valid & PNG_INFO_tRNS)
@@ -6879,7 +6968,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             {
               if (p->opacity != OpaqueOpacity)
                 {
-                  if (IsPNGColorEqual(ping_info->trans_color,*p) == 0)
+                  if (IsPNGColorEqual(ping_trans_color,*p) == 0)
                   {
                      break;  /* Can't use RGB + tRNS for multiple
                                 transparent colors.  */
@@ -6892,7 +6981,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                 }
                else
                 {
-                  if (IsPNGColorEqual(ping_info->trans_color,*p))
+                  if (IsPNGColorEqual(ping_trans_color,*p))
                       break; /* Can't use RGB + tRNS when another pixel
                                 having the same RGB samples is
                                 transparent. */
@@ -6907,13 +6996,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_color_type &= 0x03;  /* changes 4 or 6 to 0 or 2 */
           if (image_depth == 8)
             {
-              ping_info->trans_color.red&=0xff;
-              ping_info->trans_color.green&=0xff;
-              ping_info->trans_color.blue&=0xff;
-              ping_info->trans_color.gray&=0xff;
+              ping_trans_color.red&=0xff;
+              ping_trans_color.green&=0xff;
+              ping_trans_color.blue&=0xff;
+              ping_trans_color.gray&=0xff;
             }
         }
     }
@@ -6925,33 +7014,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_color_type=PNG_COLOR_TYPE_GRAY_ALPHA;
         else
           {
-            ping_info->color_type=PNG_COLOR_TYPE_GRAY;
+            ping_color_type=PNG_COLOR_TYPE_GRAY;
             if (save_image_depth == 16 && image_depth == 8)
-              ping_info->trans_color.gray*=0x0101;
+              ping_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_bit_depth=16;
         else
           {
-            ping_info->bit_depth=8;
-            if ((int) ping_info->color_type == PNG_COLOR_TYPE_PALETTE)
+            ping_bit_depth=8;
+            if ((int) ping_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_bit_depth=1;
+                    while ((int) (1 << ping_bit_depth)
                         < (long) image_colors)
-                      ping_info->bit_depth <<= 1;
+                      ping_bit_depth <<= 1;
                   }
               }
-            else if (mng_info->optimize && ping_info->color_type ==
+            else if (mng_info->optimize && ping_color_type ==
                 PNG_COLOR_TYPE_GRAY && image_colors < 17 && 
                 mng_info->IsPalette)
               {
@@ -6977,14 +7066,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_bit_depth=1;
                 else if (depth_2_ok && mng_info->write_png_depth <= 2)
-                   ping_info->bit_depth=2;
+                   ping_bit_depth=2;
                 else if (depth_4_ok && mng_info->write_png_depth <= 4)
-                   ping_info->bit_depth=4;
+                   ping_bit_depth=4;
               }
           }
-          image_depth=ping_info->bit_depth;
+          image_depth=ping_bit_depth;
       }
     else
       if (mng_info->IsPalette)
@@ -7000,7 +7089,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
             /*
               Set image palette.
             */
-            ping_info->color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
+            ping_color_type=(png_byte) PNG_COLOR_TYPE_PALETTE;
             ping_info->valid|=PNG_INFO_PLTE;
             if (mng_info->have_write_global_plte && !matte)
               {
@@ -7041,16 +7130,18 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                     "  Setting up PLTE chunk with %d colors",
                     (int) number_colors);
                 png_set_PLTE(ping,ping_info,palette,(int) number_colors);
+#if (PNG_LIBPNG_VER > 10008)
                 palette=(png_colorp) RelinquishMagickMemory(palette);
+#endif
               }
             /* color_type is PNG_COLOR_TYPE_PALETTE */
             if (!mng_info->write_png_depth)
               {
                 ping_info->bit_depth=1;
                 while ((1UL << ping_info->bit_depth) < number_colors)
-                  ping_info->bit_depth <<= 1;
+                  ping_bit_depth <<= 1;
               }
-            ping_info->num_trans=0;
+            ping_num_trans=0;
             if (matte)
             {
               ExceptionInfo
@@ -7092,7 +7183,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_color_type=(png_byte)
                                 PNG_COLOR_TYPE_RGB_ALPHA;
                               break;
                             }
@@ -7102,9 +7193,9 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                     }
                   p++;
                 }
-                if ((int) ping_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+                if ((int) ping_color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                 {
-                  ping_info->num_trans=0;
+                  ping_num_trans=0;
                   ping_info->valid&=(~PNG_INFO_tRNS);
                   ping_info->valid&=(~PNG_INFO_PLTE);
                   mng_info->IsPalette=MagickFalse;
@@ -7122,22 +7213,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_num_trans=(unsigned short) (i+1);
                 }
               }
-              if (ping_info->num_trans == 0)
+              if (ping_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_num_trans=0;
+              if (ping_num_trans != 0)
               {
-                ping_info->trans_alpha=(unsigned char *) AcquireQuantumMemory(
-                  number_colors,sizeof(*ping_info->trans_alpha));
-                if (ping_info->trans_alpha == (unsigned char *) NULL)
+                ping_trans_alpha=(unsigned char *) AcquireQuantumMemory(
+                  number_colors,sizeof(*ping_trans_alpha));
+                if (ping_trans_alpha == (unsigned char *) NULL)
                   ThrowWriterException(ResourceLimitError,
                      "MemoryAllocationFailed");
                 for (i=0; i < (long) number_colors; i++)
-                    ping_info->trans_alpha[i]=(png_byte) trans[i];
+                    ping_trans_alpha[i]=(png_byte) trans[i];
               }
             }
 
@@ -7145,9 +7236,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_info->background,image->colormap[i]))
+              if (IsPNGColorEqual(ping_background,image->colormap[i]))
                 break;
-            ping_info->background.index=(png_byte) i;
+            ping_background.index=(png_byte) i;
           }
       }
     else
@@ -7156,17 +7247,17 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           image_depth=8;
         if ((save_image_depth == 16) && (image_depth == 8))
           {
-            ping_info->trans_color.red*=0x0101;
-            ping_info->trans_color.green*=0x0101;
-            ping_info->trans_color.blue*=0x0101;
-            ping_info->trans_color.gray*=0x0101;
+            ping_trans_color.red*=0x0101;
+            ping_trans_color.green*=0x0101;
+            ping_trans_color.blue*=0x0101;
+            ping_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_bit_depth < 8 && ping_color_type ==
         PNG_COLOR_TYPE_GRAY)
       {
          png_uint_16
@@ -7175,7 +7266,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_bit_depth)-1);
 
 
          background.gray=(png_uint_16)
@@ -7186,22 +7277,24 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
              "  Setting up bKGD chunk");
          png_set_bKGD(ping,ping_info,&background);
 
-         ping_info->trans_color.gray=(png_uint_16) (QuantumScale*(maxval*
-           ping_info->trans_color.gray));
+         ping_trans_color.gray=(png_uint_16) (QuantumScale*(maxval*
+           ping_trans_color.gray));
       }
   if (logging != MagickFalse)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-      "    PNG color type: %d",ping_info->color_type);
+      "    PNG color type: %d",ping_color_type);
   /*
     Initialize compression level and filtering.
   */
   if (logging != MagickFalse)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
       "  Setting up deflate compression");
+#if (PNG_LIBPNG_VER > 99)
   if (logging != MagickFalse)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
       "    Compression buffer size: 32768");
   png_set_compression_buffer_size(ping,32768L);
+#endif
   if (logging != MagickFalse)
     (void) LogMagickEvent(CoderEvent,GetMagickModule(),
       "    Compression mem level: 9");
@@ -7237,7 +7330,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       if (logging != MagickFalse)
         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
           "    Filter_type: PNG_INTRAPIXEL_DIFFERENCING");
-      ping_info->filter_type=PNG_INTRAPIXEL_DIFFERENCING;
+      ping_filter_method=PNG_INTRAPIXEL_DIFFERENCING;
     }
   else
     if (logging != MagickFalse)
@@ -7254,8 +7347,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_color_type == PNG_COLOR_TYPE_GRAY) ||
+            ((int) ping_color_type == PNG_COLOR_TYPE_PALETTE) ||
             (quality < 50))
           base_filter=PNG_NO_FILTERS;
         else
@@ -7278,7 +7371,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     profile=GetImageProfile(image,name);
     if (profile != (StringInfo *) NULL)
       {
-#if defined(PNG_WRITE_iCCP_SUPPORTED)
+#if (PNG_LIBPNG_VER > 10008) && 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)
@@ -7349,7 +7442,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                bp.x,bp.y);
        }
     }
-  ping_info->interlace_type=image_info->interlace != NoInterlace;
+  ping_interlace_method=image_info->interlace != NoInterlace;
 
   if (mng_info->write_mng)
     png_set_sig_bytes(ping,8);
@@ -7361,22 +7454,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_color_type = PNG_COLOR_TYPE_RGB;
+           if (ping_bit_depth < 8)
+             ping_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_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
     }
 
   if ((mng_info->write_png_depth &&
-      mng_info->write_png_depth != ping_info->bit_depth) ||
+     (int) mng_info->write_png_depth != ping_bit_depth) ||
      (mng_info->write_png_colortype &&
-     (mng_info->write_png_colortype-1 != ping_info->color_type &&
+     ((int) mng_info->write_png_colortype-1 != ping_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_color_type == 0))))
     {
       if (logging != MagickFalse)
         {
@@ -7385,14 +7478,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_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_color_type);
             }
         }
       png_error(ping,
@@ -7410,6 +7503,11 @@ 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);
@@ -7568,7 +7666,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_bit_depth >= MAGICKCORE_QUANTUM_DEPTH)) &&
          (mng_info->optimize || mng_info->IsPalette) && ImageIsGray(image))
       {
         for (y=0; y < (long) image->rows; y++)
@@ -7576,7 +7674,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_color_type == PNG_COLOR_TYPE_GRAY)
             {
               if (mng_info->IsPalette)
                 (void) ExportQuantumPixels(image,(const CacheView *) NULL,
@@ -7610,7 +7708,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_color_type == PNG_COLOR_TYPE_GRAY)
               {
                 if (image->storage_class == DirectClass)
                   (void) ExportQuantumPixels(image,(const CacheView *) NULL,
@@ -7619,7 +7717,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_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)
@@ -7635,8 +7733,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_color_type != PNG_COLOR_TYPE_GRAY) &&
+              (ping_color_type != PNG_COLOR_TYPE_GRAY_ALPHA))
             {
               if (logging)
                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -7652,10 +7750,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_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_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
               (void) ExportQuantumPixels(image,(const CacheView *) NULL,
                 quantum_info,GrayAlphaQuantum,png_pixels,&image->exception);
             else
@@ -7680,35 +7778,40 @@ 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_width);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    Height: %lu",ping_info->height);
+        "    Height: %lu",ping_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_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_color_type);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
-        "    PNG Interlace method: %d",ping_info->interlace_type);
+        "    PNG Interlace method: %d",ping_interlace_method);
     }
   /*
     Generate text chunks.
   */
+#if (PNG_LIBPNG_VER <= 10005)
+  ping_info->num_text=0;
+#endif
   ResetImagePropertyIterator(image);
   property=GetNextImageProperty(image);
   while (property != (const char *) NULL)
   {
+#if (PNG_LIBPNG_VER > 10005)
     png_textp
       text;
+#endif
 
     value=GetImageProperty(image,property);
     if (value != (const char *) NULL)
@@ -7743,8 +7846,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_width != mng_info->page.width) ||
+          (ping_height != mng_info->page.height))
         {
           unsigned char
             chunk[32];
@@ -7765,10 +7868,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_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_height));
           (void) WriteBlob(image,31,chunk);
           (void) WriteBlobMSBULong(image,crc32(0,chunk,31));
           mng_info->old_framing_mode=4;
@@ -7786,7 +7889,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 
   /* Save depth actually written */
 
-  s[0]=(char) ping_info->bit_depth;
+  s[0]=(char) ping_bit_depth;
   s[1]='\0';
 
   (void) SetImageProperty(image,"png:bit-depth-written",s);
@@ -7794,6 +7897,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   /*
     Free PNG resources.
   */
+
   png_destroy_write_struct(&ping,&ping_info);
 
   png_pixels=(unsigned char *) RelinquishMagickMemory(png_pixels);