Eliminated some of the deprecated direct references to ping_info members.

diff --git a/coders/png.c b/coders/png.c
index bbf9f19d8c96d56f9d95ee02b09a9e1e500b94d6..a282b35069c940ce9d80c25b3aa8edaf09fb0973 100644 (file)
--- a/coders/png.c
+++ b/coders/png.c
@@ -1677,7 +1677,12 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
     logging,
     num_text,
     num_passes,
-    pass;
+    pass,
+    ping_info_bit_depth,
+    ping_info_color_type,
+    ping_info_interlace_method,
+    ping_info_compression_method,
+    ping_info_filter_method;
 
   MagickBooleanType
     status;
@@ -1692,6 +1697,10 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
   png_struct
     *ping;
 
+  png_uint_32
+    ping_info_height,
+    ping_info_width;
+
   png_textp
     text;
 
@@ -1864,28 +1873,34 @@ 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_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);
+
+  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_type != 0 ? PNGInterlace : NoInterlace;
+  image->interlace=ping_info_interlace_method != 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_type);
+        ping_info_compression_method);
       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
         "    PNG interlace_method: %d, filter_method: %d",
-        ping_info->interlace_type,ping_info->filter_type);
+        ping_info_interlace_method,ping_info_filter_method);
     }
 
 #if (PNG_LIBPNG_VER > 10008) && defined(PNG_READ_iCCP_SUPPORTED)
@@ -2050,7 +2065,7 @@ 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)
             {
@@ -2112,7 +2127,7 @@ 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_info->background.red;
           image->background_color.green=ping_info->background.green;
@@ -2145,11 +2160,11 @@ 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 &&
+      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 &&
+          (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)))
@@ -2172,9 +2187,9 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
           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_color_type == PNG_COLOR_TYPE_GRAY)
             {
-              if (ping_info->bit_depth < 8)
+              if (ping_info_bit_depth < 8)
                 {
                   transparent_color.opacity=(Quantum) (((
                     ping_info->trans_color.gray)*255)/max_sample);
@@ -2198,13 +2213,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;
     }
@@ -2213,14 +2228,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;
@@ -2228,7 +2243,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;
@@ -2251,7 +2266,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;
@@ -2272,7 +2287,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++)
@@ -2357,10 +2372,10 @@ 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) ||
+      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++)
@@ -2382,7 +2397,7 @@ 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--)
                 {
@@ -2398,7 +2413,7 @@ 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 (ping_info->valid & PNG_INFO_tRNS)
                 for (x=(long) image->columns-1; x >= 0; x--)
@@ -2431,53 +2446,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
@@ -2512,7 +2527,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));
@@ -2531,7 +2546,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:
           {
@@ -2580,7 +2595,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++;
@@ -2613,7 +2628,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++);
@@ -2633,7 +2648,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;
@@ -2644,7 +2659,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++;
@@ -2712,6 +2727,59 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
       */
       storage_class=image->storage_class;
       image->matte=MagickTrue;
+
+#if 1  /* balfour fix */
+/* From imagemagick discourse server, 5 Feb 2010 */
+
+    if (storage_class == PseudoClass)
+   {
+      if ((int) ping_info_color_type == PNG_COLOR_TYPE_PALETTE)
+      {
+         for (x=0; x < ping_info->num_trans; x++)
+         {
+            image->colormap[x].opacity = ScaleCharToQuantum((unsigned char)(255-ping_info->trans_alpha[x]));
+         }
+      }
+      else if (ping_info_color_type == PNG_COLOR_TYPE_GRAY)
+      {
+         for (x=0; x < (int) image->colors; x++)
+         {
+            if (image->colormap[x].red == transparent_color.opacity)
+            {
+               image->colormap[x].opacity = (Quantum) TransparentOpacity;
+            }
+         }
+      }
+   }
+   else
+   {
+
+      for (y=0; y < (long) image->rows; y++)
+      {
+        image->storage_class=storage_class;
+        q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
+        if (q == (PixelPacket *) NULL)
+          break;
+        indices=GetAuthenticIndexQueue(image);
+
+          for (x=(long) image->columns-1; x >= 0; x--)
+          {
+            if (ScaleQuantumToChar(q->red) == transparent_color.red &&
+                ScaleQuantumToChar(q->green) == transparent_color.green &&
+                ScaleQuantumToChar(q->blue) == transparent_color.blue)
+               q->opacity=(Quantum) TransparentOpacity;
+            else
+              SetOpacityPixelComponent(q,OpaqueOpacity);
+            q++;
+          }
+        if (SyncAuthenticPixels(image,exception) == MagickFalse)
+          break;
+      }
+   }
+
+#else /* not balfour */
+
+
       for (y=0; y < (long) image->rows; y++)
       {
         image->storage_class=storage_class;
@@ -2725,7 +2793,7 @@ 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];
@@ -2736,7 +2804,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
                   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];
@@ -2764,6 +2832,7 @@ static Image *ReadOnePNGImage(MngInfo *mng_info,
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
       }
+#endif /* not balfour */
       image->storage_class=DirectClass;
     }
 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
@@ -2837,16 +2906,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
@@ -2859,17 +2918,16 @@ 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_info_width > 250000L || ping_info_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;
+          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 (ping_info->valid & PNG_INFO_PLTE)
             {
               int
@@ -6287,7 +6345,12 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   int
     image_matte,
     num_passes,
-    pass;
+    pass,
+    ping_info_bit_depth,
+    ping_info_color_type,
+    ping_info_interlace_method,
+    ping_info_compression_method,
+    ping_info_filter_method;
 
   png_colorp
      palette;
@@ -6298,6 +6361,10 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
   png_struct
     *ping;
 
+  png_uint_32
+    ping_info_height,
+    ping_info_width;
+
   long
     y;
 
@@ -6399,8 +6466,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)
@@ -6415,9 +6482,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(),
@@ -6426,7 +6493,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))
@@ -6513,9 +6580,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. */
@@ -6547,7 +6614,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;
@@ -6590,7 +6657,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
 #if (PNG_LIBPNG_VER > 10008)
           palette=(png_colorp) RelinquishMagickMemory(palette);
 #endif
-            image_depth=ping_info->bit_depth;
+            image_depth=ping_info_bit_depth;
             ping_info->num_trans=0;
             if (matte)
             {
@@ -6658,21 +6725,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
@@ -6680,16 +6747,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 || 
@@ -6697,7 +6764,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 ||
@@ -6705,56 +6772,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 < mng_info->write_png_depth)
-                    ping_info->bit_depth = mng_info->write_png_depth;
+                  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;
                 }
             }
         }
-      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 < mng_info->write_png_depth)
+               old_bit_depth=ping_info_bit_depth;
+               if (ping_info_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_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)
                      {
                        if (logging != MagickFalse)
                          (void) LogMagickEvent(CoderEvent,GetMagickModule(),
@@ -6764,17 +6831,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))
@@ -6783,7 +6850,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);
@@ -6793,7 +6860,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++;
@@ -6823,7 +6890,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
         {
@@ -6831,13 +6898,13 @@ 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_info->trans_color.red=(png_uint_16)
@@ -6896,7 +6963,7 @@ 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_info->trans_color.red&=0xff;
@@ -6914,10 +6981,10 @@ 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_info->trans_color.gray*=0x0101;
           }
@@ -6926,21 +6993,21 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
         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)
               {
@@ -6966,14 +7033,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)
@@ -6989,7 +7056,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)
               {
@@ -7039,7 +7106,7 @@ 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;
             if (matte)
@@ -7083,7 +7150,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;
                             }
@@ -7093,7 +7160,7 @@ 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->valid&=(~PNG_INFO_tRNS);
@@ -7157,7 +7224,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
     /*
       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
@@ -7166,7 +7233,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)
@@ -7182,7 +7249,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
       }
   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.
   */
@@ -7230,7 +7297,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_info_filter_method=PNG_INTRAPIXEL_DIFFERENCING;
     }
   else
     if (logging != MagickFalse)
@@ -7247,8 +7314,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
@@ -7342,7 +7409,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                bp.x,bp.y);
        }
     }
-  ping_info->interlace_type=image_info->interlace != NoInterlace;
+  ping_info_interlace_method=image_info->interlace != NoInterlace;
 
   if (mng_info->write_mng)
     png_set_sig_bytes(ping,8);
@@ -7354,22 +7421,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 &&
-      mng_info->write_png_depth != ping_info->bit_depth) ||
+     (int) mng_info->write_png_depth != ping_info_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_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)
         {
@@ -7378,14 +7445,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,
@@ -7403,6 +7470,11 @@ 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);
@@ -7561,7 +7633,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++)
@@ -7569,7 +7641,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,
@@ -7603,7 +7675,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,
@@ -7612,7 +7684,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)
@@ -7628,8 +7700,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(),
@@ -7645,10 +7717,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
@@ -7673,25 +7745,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_type);
+        "    PNG Interlace method: %d",ping_info_interlace_method);
     }
   /*
     Generate text chunks.
@@ -7774,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_info_width != mng_info->page.width) ||
+          (ping_info_height != mng_info->page.height))
         {
           unsigned char
             chunk[32];
@@ -7796,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_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;
@@ -7817,7 +7889,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);