From: cristy <urban-warrior@git.imagemagick.org>
Date: Tue, 26 Apr 2011 01:46:31 +0000 (+0000)
Subject: (no commit message)
X-Git-Tag: 7.0.1-0~7647
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=aff6d807f839a998fff6e87198f2418868ab508e;p=imagemagick

---

diff --git a/coders/miff.c b/coders/miff.c
index ee2db85e1..611996ccb 100644
--- a/coders/miff.c
+++ b/coders/miff.c
@@ -1420,7 +1420,7 @@ static Image *ReadMIFFImage(const ImageInfo *image_info,
             length--;
             if ((image->storage_class == PseudoClass) ||
                 (image->colorspace == CMYKColorspace))
-              indexes[x]=index;
+              SetIndexPixelComponent(indexes+x,index);
             *q++=pixel;
           }
           break;
@@ -2425,7 +2425,7 @@ static MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
               }
             pixel=(*p);
             if (indexes != (IndexPacket *) NULL)
-              index=indexes[x];
+              index=GetIndexPixelComponent(indexes+x);
             p++;
           }
           q=PopRunlengthPacket(image,q,length,pixel,index);
diff --git a/coders/mono.c b/coders/mono.c
index b64c3c52f..5e7997275 100644
--- a/coders/mono.c
+++ b/coders/mono.c
@@ -99,25 +99,25 @@ static Image *ReadMONOImage(const ImageInfo *image_info,
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
   register IndexPacket
     *indexes;
 
-  register ssize_t
-    x;
-
   register PixelPacket
     *q;
 
+  register ssize_t
+    x;
+
   size_t
     bit,
     byte;
 
+  ssize_t
+    y;
+
   /*
     Open image file.
   */
@@ -167,9 +167,9 @@ static Image *ReadMONOImage(const ImageInfo *image_info,
       if (bit == 0)
         byte=(size_t) ReadBlobByte(image);
       if (image_info->endian == LSBEndian)
-        indexes[x]=(IndexPacket) (((byte & 0x01) != 0) ? 0x00 : 0x01);
+        SetIndexPixelComponent(indexes+x,((byte & 0x01) != 0) ? 0x00 : 0x01);
       else
-        indexes[x]=(IndexPacket) (((byte & 0x01) != 0) ? 0x01 : 0x00);
+        SetIndexPixelComponent(indexes+x,((byte & 0x01) != 0) ? 0x01 : 0x00);
       bit++;
       if (bit == 8)
         bit=0;
@@ -282,9 +282,6 @@ ModuleExport void UnregisterMONOImage(void)
 static MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
   Image *image)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -298,6 +295,9 @@ static MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
     bit,
     byte;
 
+  ssize_t
+    y;
+
   /*
     Open output image file.
   */
@@ -346,7 +346,7 @@ static MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
     if (bit != 0)
       (void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/mpc.c b/coders/mpc.c
index bb7d38518..a788536cf 100644
--- a/coders/mpc.c
+++ b/coders/mpc.c
@@ -176,7 +176,9 @@ static Image *ReadMPCImage(const ImageInfo *image_info,ExceptionInfo *exception)
     i;
 
   size_t
-    length;
+    depth,
+    length,
+    quantum_depth;
 
   ssize_t
     count;
@@ -184,10 +186,6 @@ static Image *ReadMPCImage(const ImageInfo *image_info,ExceptionInfo *exception)
   StringInfo
     *profile;
 
-  size_t
-    depth,
-    quantum_depth;
-
   /*
     Open image file.
   */
@@ -512,7 +510,8 @@ static Image *ReadMPCImage(const ImageInfo *image_info,ExceptionInfo *exception)
                   }
                 if (LocaleCompare(keyword,"maximum-error") == 0)
                   {
-                    image->error.normalized_maximum_error=StringToDouble(options);
+                    image->error.normalized_maximum_error=
+                      StringToDouble(options);
                     break;
                   }
                 if (LocaleCompare(keyword,"mean-error") == 0)
@@ -1152,8 +1151,8 @@ static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
             image->iterations,(double) image->delay,(double)
             image->ticks_per_second);
         else
-          (void) FormatMagickString(buffer,MaxTextExtent,
-            "scene=%.20g  iterations=%.20g  delay=%.20g  ticks-per-second=%.20g\n",
+          (void) FormatMagickString(buffer,MaxTextExtent,"scene=%.20g  "
+            "iterations=%.20g  delay=%.20g  ticks-per-second=%.20g\n",
             (double) image->scene,(double) image->iterations,(double)
             image->delay,(double) image->ticks_per_second);
         (void) WriteBlobString(image,buffer);
@@ -1200,8 +1199,8 @@ static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
     if (image->rendering_intent != UndefinedIntent)
       {
         (void) FormatMagickString(buffer,MaxTextExtent,
-          "rendering-intent=%s\n",
-           CommandOptionToMnemonic(MagickIntentOptions,image->rendering_intent));
+          "rendering-intent=%s\n",CommandOptionToMnemonic(MagickIntentOptions,
+          image->rendering_intent));
         (void) WriteBlobString(image,buffer);
       }
     if (image->gamma != 0.0)
diff --git a/coders/mpeg.c b/coders/mpeg.c
index 73a5cf948..554b5f2b4 100644
--- a/coders/mpeg.c
+++ b/coders/mpeg.c
@@ -483,15 +483,13 @@ static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
     i;
 
   size_t
-    length;
+    count,
+    length,
+    scene;
 
   unsigned char
     *blob;
 
-  size_t
-    count,
-    scene;
-
   /*
     Open output image file.
   */
diff --git a/coders/mtv.c b/coders/mtv.c
index 306173c7a..a9132fd83 100644
--- a/coders/mtv.c
+++ b/coders/mtv.c
@@ -98,9 +98,6 @@ static Image *ReadMTVImage(const ImageInfo *image_info,ExceptionInfo *exception)
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -114,7 +111,8 @@ static Image *ReadMTVImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *p;
 
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     *pixels;
@@ -187,7 +185,7 @@ static Image *ReadMTVImage(const ImageInfo *image_info,ExceptionInfo *exception)
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -302,8 +300,8 @@ ModuleExport void UnregisterMTVImage(void)
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  WriteMTVImage() writes an image to a file in red, green, and blue
-%  MTV rasterfile format.
+%  WriteMTVImage() writes an image to a file in red, green, and blue MTV
+%  rasterfile format.
 %
 %  The format of the WriteMTVImage method is:
 %
@@ -321,9 +319,6 @@ static MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image)
   char
     buffer[MaxTextExtent];
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -339,6 +334,9 @@ static MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image)
   register unsigned char
     *q;
 
+  ssize_t
+    y;
+
   unsigned char
     *pixels;
 
diff --git a/coders/null.c b/coders/null.c
index 0260f6697..dd7a03e17 100644
--- a/coders/null.c
+++ b/coders/null.c
@@ -99,9 +99,6 @@ static Image *ReadNULLImage(const ImageInfo *image_info,
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickPixelPacket
     background;
 
@@ -114,6 +111,9 @@ static Image *ReadNULLImage(const ImageInfo *image_info,
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   /*
     Initialize Image structure.
   */
diff --git a/coders/otb.c b/coders/otb.c
index e931c31a5..5739298f8 100644
--- a/coders/otb.c
+++ b/coders/otb.c
@@ -102,9 +102,6 @@ static Image *ReadOTBImage(const ImageInfo *image_info,ExceptionInfo *exception)
   int
     byte;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -117,6 +114,9 @@ static Image *ReadOTBImage(const ImageInfo *image_info,ExceptionInfo *exception)
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   unsigned char
     bit,
     info,
@@ -184,7 +184,8 @@ static Image *ReadOTBImage(const ImageInfo *image_info,ExceptionInfo *exception)
           if (byte == EOF)
             ThrowReaderException(CorruptImageError,"CorruptImage");
         }
-      indexes[x]=(IndexPacket) ((byte & (0x01 << (7-bit))) ? 0x00 : 0x01);
+      SetIndexPixelComponent(indexes+x,(byte & (0x01 << (7-bit))) ?
+        0x00 : 0x01);
       bit++;
       if (bit == 8)
         bit=0;
@@ -300,9 +301,6 @@ static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
 #define SetBit(a,i,set) \
   a=(unsigned char) ((set) ? (a) | (1L << (i)) : (a) & ~(1L << (i)))
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -312,6 +310,9 @@ static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
   register ssize_t
     x;
 
+  ssize_t
+    y;
+
   unsigned char
     bit,
     byte,
@@ -375,7 +376,7 @@ static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
     if (image->previous == (Image *) NULL)
       {
         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
diff --git a/coders/palm.c b/coders/palm.c
index 2f69f054a..c24ba4c10 100644
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -21,7 +21,7 @@
 %  dedicated to making software imaging solutions freely available.           %
 %                                                                             %
 %  You may not use this file except in compliance with the License.  You may  %
-%   obtain a copy of the License at                                            %
+%  obtain a copy of the License at                                            %
 %                                                                             %
 %    http://www.imagemagick.org/script/license.php                            %
 %                                                                             %
@@ -250,9 +250,6 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
   IndexPacket
     index;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -274,12 +271,8 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
     *q;
 
   ssize_t
-    count;
-
-  unsigned char
-    *lastrow,
-    *one_row,
-    *ptr;
+    count,
+    y;
 
   size_t
     bytes_per_row,
@@ -299,6 +292,11 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
     size,
     bit;
 
+  unsigned char
+    *lastrow,
+    *one_row,
+    *ptr;
+
   unsigned short
     color16;
 
@@ -326,9 +324,6 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
     image->rows=ReadBlobMSBShort(image);
     if (EOFBlob(image) != MagickFalse)
       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
-    /*
-      Copied from coders/pnm.c. TODO other checks ...
-    */
     if ((image->columns == 0) || (image->rows == 0))
       ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
     bytes_per_row=ReadBlobMSBShort(image);
@@ -480,9 +475,12 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
           {
             color16=(*ptr++ << 8);
             color16|=(*ptr++);
-            q->red=(Quantum) ((QuantumRange*((color16 >> 11) & 0x1f))/0x1f);
-            q->green=(Quantum) ((QuantumRange*((color16 >> 5) & 0x3f))/0x3f);
-            q->blue=(Quantum) ((QuantumRange*((color16 >> 0) & 0x1f))/0x1f);
+            SetRedPixelComponent(q,(QuantumRange*((color16 >> 11) & 0x1f))/
+              0x1f);
+            SetGreenPixelComponent(q,(QuantumRange*((color16 >> 5) & 0x3f))/
+              0x3f);
+            SetBluePixelComponent(q,(QuantumRange*((color16 >> 0) & 0x1f))/
+              0x1f);
             SetOpacityPixelComponent(q,OpaqueOpacity);
             q++;
           }
@@ -495,8 +493,10 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
             if ((size_t) (ptr-one_row) >= bytes_per_row)
               ThrowReaderException(CorruptImageError,"CorruptImage");
             index=(IndexPacket) (mask-(((*ptr) & (mask << bit)) >> bit));
-            indexes[x]=index;
-            *q++=image->colormap[(ssize_t) index];
+            SetIndexPixelComponent(indexes+x,index);
+            SetRedPixelComponent(q,image->colormap[(ssize_t) index].red);
+            SetGreenPixelComponent(q,image->colormap[(ssize_t) index].green);
+            SetBluePixelComponent(q,image->colormap[(ssize_t) index].blue);
             if (bit)
               bit-=bits_per_pixel;
             else
@@ -504,6 +504,7 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
                 ptr++;
                 bit=8-bits_per_pixel;
               }
+            q++;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
@@ -511,7 +512,7 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
         if (image->previous == (Image *) NULL)
           {
             status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+              image->rows);
             if (status == MagickFalse)
               break;
           }
@@ -690,6 +691,13 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
   register PixelPacket
     *p;
 
+  size_t
+    count,
+    bits_per_pixel,
+    bytes_per_row,
+    nextDepthOffset,
+    one;
+
   unsigned char
     bit,
     byte,
@@ -702,18 +710,10 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
   unsigned int
     transparentIndex;
 
-  size_t
-    count,
-    bits_per_pixel,
-    bytes_per_row,
-    nextDepthOffset,
-    one;
-
   unsigned short
     color16,
     flags;
 
-
   /*
     Open output image file.
   */
@@ -823,15 +823,16 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
 
           affinity_image=ConstituteImage(256,1,"RGB",CharPixel,&PalmPalette,
             &exception);
-          (void) TransformImageColorspace(affinity_image,affinity_image->colorspace);
+          (void) TransformImageColorspace(affinity_image,
+            affinity_image->colorspace);
           (void) RemapImage(quantize_info,image,affinity_image);
           for (y=0; y < (ssize_t) image->rows; y++)
           {
             p=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
             indexes=GetAuthenticIndexQueue(image);
             for (x=0; x < (ssize_t) image->columns; x++)
-              indexes[x]=(IndexPacket) FindColor(&image->colormap[(ssize_t)
-                indexes[x]]);
+              SetIndexPixelComponent(indexes+x,FindColor(&image->colormap[
+                (ssize_t) GetIndexPixelComponent(indexes+x)]));
           }
           affinity_image=DestroyImage(affinity_image);
         }
@@ -883,10 +884,10 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
           for (x=0; x < (int) image->columns; x++)
           {
             if (bits_per_pixel >= 8)
-              color=(unsigned char) indexes[x];
+              color=(unsigned char) GetIndexPixelComponent(indexes+x);
             else
-              color=(unsigned char) (indexes[x]*((one << bits_per_pixel)-1)/
-                MagickMax(1*image->colors-1,1));
+              color=(unsigned char) (GetIndexPixelComponent(indexes+x)*
+                ((one << bits_per_pixel)-1)/MagickMax(1*image->colors-1,1));
             byte|=color << bit;
             if (bit != 0)
               bit-=(unsigned char) bits_per_pixel;
@@ -928,9 +929,9 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
               {
                 if ((y == 0) || (lastrow[x + bit] != one_row[x + bit]))
                   {
-                  byte |= (1 << (7 - bit));
-                  *tptr++ = (char) one_row[x + bit];
-                }
+                    byte |= (1 << (7 - bit));
+                    *tptr++ = (char) one_row[x + bit];
+                  }
               }
               (void) WriteBlobByte(image, byte);
               (void) WriteBlob(image,tptr-tmpbuf,(unsigned char *) tmpbuf);
diff --git a/coders/pcd.c b/coders/pcd.c
index 70f5926aa..65c5d1e1a 100644
--- a/coders/pcd.c
+++ b/coders/pcd.c
@@ -144,9 +144,6 @@ static MagickBooleanType DecodeImage(Image *image,unsigned char *luma,
       key;
   } PCDTable;
 
-  ssize_t
-    quantum;
-
   PCDTable
     *pcd_table[3];
 
@@ -161,22 +158,21 @@ static MagickBooleanType DecodeImage(Image *image,unsigned char *luma,
     *p,
     *q;
 
-  size_t
-    length;
-
-  ssize_t
-    count;
-
-  unsigned char
-    *buffer;
-
   size_t
     bits,
+    length,
     plane,
     pcd_length[3],
     row,
     sum;
 
+  ssize_t
+    count,
+    quantum;
+
+  unsigned char
+    *buffer;
+
   /*
     Initialize Huffman tables.
   */
@@ -450,8 +446,7 @@ static void Upsample(const size_t width,const size_t height,
       p--;
       q-=2;
       *q=(*p);
-      *(q+1)=(unsigned char) ((((size_t) *p)+
-        ((size_t) *(p+1))+1) >> 1);
+      *(q+1)=(unsigned char) ((((size_t) *p)+((size_t) *(p+1))+1) >> 1);
     }
   }
   for (y=0; y < (ssize_t) (height-1); y++)
@@ -468,10 +463,8 @@ static void Upsample(const size_t width,const size_t height,
       p+=2;
       r+=2;
     }
-    *q++=(unsigned char) ((((size_t) *p++)+
-      ((size_t) *r++)+1) >> 1);
-    *q++=(unsigned char) ((((size_t) *p++)+
-      ((size_t) *r++)+1) >> 1);
+    *q++=(unsigned char) ((((size_t) *p++)+((size_t) *r++)+1) >> 1);
+    *q++=(unsigned char) ((((size_t) *p++)+((size_t) *r++)+1) >> 1);
   }
   p=pixels+(2*height-2)*scaled_width;
   q=pixels+(2*height-1)*scaled_width;
@@ -483,9 +476,6 @@ static Image *ReadPCDImage(const ImageInfo *image_info,ExceptionInfo *exception)
   Image
     *image;
 
-  ssize_t
-    x;
-
   MagickBooleanType
     status;
 
@@ -507,8 +497,16 @@ static Image *ReadPCDImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *c2,
     *yy;
 
+  size_t
+    height,
+    number_images,
+    rotate,
+    scene,
+    width;
+
   ssize_t
-    count;
+    count,
+    x;
 
   unsigned char
     *chroma1,
@@ -519,13 +517,6 @@ static Image *ReadPCDImage(const ImageInfo *image_info,ExceptionInfo *exception)
   unsigned int
     overview;
 
-  size_t
-    height,
-    number_images,
-    rotate,
-    scene,
-    width;
-
   /*
     Open image file.
   */
@@ -680,9 +671,9 @@ static Image *ReadPCDImage(const ImageInfo *image_info,ExceptionInfo *exception)
             break;
           for (x=0; x < (ssize_t) image->columns; x++)
           {
-            q->red=ScaleCharToQuantum(*yy++);
-            q->green=ScaleCharToQuantum(*c1++);
-            q->blue=ScaleCharToQuantum(*c2++);
+            SetRedPixelComponent(q,ScaleCharToQuantum(*yy++));
+            SetGreenPixelComponent(q,ScaleCharToQuantum(*c1++));
+            SetBluePixelComponent(q,ScaleCharToQuantum(*c2++));
             q++;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -788,9 +779,9 @@ static Image *ReadPCDImage(const ImageInfo *image_info,ExceptionInfo *exception)
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      q->red=ScaleCharToQuantum(*yy++);
-      q->green=ScaleCharToQuantum(*c1++);
-      q->blue=ScaleCharToQuantum(*c2++);
+      SetRedPixelComponent(q,ScaleCharToQuantum(*yy++));
+      SetGreenPixelComponent(q,ScaleCharToQuantum(*c1++));
+      SetBluePixelComponent(q,ScaleCharToQuantum(*c2++));
       q++;
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -956,9 +947,6 @@ static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
     *downsample_image,
     *tile_image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -976,6 +964,9 @@ static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
     i,
     x;
 
+  ssize_t
+    y;
+
   /*
     Scale image to tile size.
   */
@@ -1042,7 +1033,7 @@ static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
       break;
     for (x=0; x < (ssize_t) downsample_image->columns; x++)
     {
-      (void) WriteBlobByte(image,ScaleQuantumToChar(q->green));
+      (void) WriteBlobByte(image,ScaleQuantumToChar(GetGreenPixelComponent(q)));
       q++;
     }
     q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
@@ -1051,7 +1042,7 @@ static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
       break;
     for (x=0; x < (ssize_t) downsample_image->columns; x++)
     {
-      (void) WriteBlobByte(image,ScaleQuantumToChar(q->blue));
+      (void) WriteBlobByte(image,ScaleQuantumToChar(GetBluePixelComponent(q)));
       q++;
     }
     status=SetImageProgress(image,SaveImageTag,y,tile_image->rows);
diff --git a/coders/pcl.c b/coders/pcl.c
index 6ba965f5f..b7d87839d 100644
--- a/coders/pcl.c
+++ b/coders/pcl.c
@@ -184,13 +184,13 @@ static Image *ReadPCLImage(const ImageInfo *image_info,ExceptionInfo *exception)
   SegmentInfo
     bounds;
 
-  ssize_t
-    count;
-
   size_t
     height,
     width;
 
+  ssize_t
+    count;
+
   assert(image_info != (const ImageInfo *) NULL);
   assert(image_info->signature == MagickSignature);
   if (image_info->debug != MagickFalse)
@@ -553,15 +553,15 @@ static size_t PCLPackbitsCompressImage(const size_t length,
   int
     count;
 
-  ssize_t
-    j;
-
   register ssize_t
     x;
 
   register unsigned char
     *q;
 
+  ssize_t
+    j;
+
   unsigned char
     packbits[128];
 
@@ -656,9 +656,6 @@ static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
   const char
     *option;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -668,30 +665,19 @@ static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
   register const IndexPacket
     *indexes;
 
-  register const PixelPacket
-    *p;
-
-  register ssize_t
-    i,
-    x;
-
-  register unsigned char
-    *q;
-
-  size_t
-    length,
+  register const PixelPacket *p; register ssize_t i, x; register unsigned char *q; size_t density, length,
+    one,
     packets;
 
+  ssize_t
+    y;
+
   unsigned char
     bits_per_pixel,
     *compress_pixels,
     *pixels,
     *previous_pixels;
 
-  size_t
-    density,
-    one;
-
   /*
     Open output image file.
   */
@@ -775,8 +761,7 @@ static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
               ScaleQuantumToChar(image->colormap[i].blue),(double) i);
             (void) WriteBlobString(image,buffer);
           }
-          one=1;
-          for ( ; i < (ssize_t) (one << bits_per_pixel); i++)
+          for (one=1; i < (ssize_t) (one << bits_per_pixel); i++)
           {
             (void) FormatMagickString(buffer,MaxTextExtent,"\033*v%.20gI",
               (double) i);
@@ -922,8 +907,7 @@ static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
         }
         case RLECompression:
         {
-          packets=PCLPackbitsCompressImage(length,pixels,
-            compress_pixels);
+          packets=PCLPackbitsCompressImage(length,pixels,compress_pixels);
           (void) FormatMagickString(buffer,MaxTextExtent,"\033*b%.20gW",
             (double) packets);
           (void) WriteBlobString(image,buffer);
diff --git a/coders/pcx.c b/coders/pcx.c
index 66d629f8a..70ced8533 100644
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -228,9 +228,6 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     id,
     mask;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -257,8 +254,13 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *p,
     *r;
 
+  size_t
+    one,
+    pcx_packets;
+
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     packet,
@@ -266,10 +268,6 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
     *pcx_pixels,
     *scanline;
 
-  size_t
-    one,
-    pcx_packets;
-
   /*
     Open image file.
   */
@@ -604,14 +602,14 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
       for (x=0; x < (ssize_t) image->columns; x++)
       {
         if (image->storage_class == PseudoClass)
-          indexes[x]=(IndexPacket) (*r++);
+          SetIndexPixelComponent(indexes+x,*r++);
         else
           {
-            q->red=ScaleCharToQuantum(*r++);
-            q->green=ScaleCharToQuantum(*r++);
-            q->blue=ScaleCharToQuantum(*r++);
+            SetRedPixelComponent(q,ScaleCharToQuantum(*r++));
+            SetGreenPixelComponent(q,ScaleCharToQuantum(*r++));
+            SetBluePixelComponent(q,ScaleCharToQuantum(*r++));
             if (image->matte != MagickFalse)
-              q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*r++));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*r++));
           }
         q++;
       }
@@ -620,7 +618,7 @@ static Image *ReadPCXImage(const ImageInfo *image_info,ExceptionInfo *exception)
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -833,9 +831,6 @@ static MagickBooleanType PCXWritePixels(PCXInfo *pcx_info,
 
 static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -863,6 +858,9 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
   size_t
     length;
 
+  ssize_t
+    y;
+
   unsigned char
     *pcx_colormap,
     *pcx_pixels;
@@ -1113,7 +1111,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
               for (x=0; x < (ssize_t) image->columns; x++)
               {
                 byte<<=1;
-                if (indexes[x] == polarity)
+                if (GetIndexPixelComponent(indexes+x) == polarity)
                   byte|=0x01;
                 bit++;
                 if (bit == 8)
diff --git a/coders/pdb.c b/coders/pdb.c
index 64aeefc90..c3bea820d 100644
--- a/coders/pdb.c
+++ b/coders/pdb.c
@@ -271,11 +271,6 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
   IndexPacket
     index;
 
-  ssize_t
-    img_offset, /* TS */
-    comment_offset = 0,
-    y;
-
   MagickBooleanType
     status;
 
@@ -297,18 +292,21 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
   register unsigned char
     *p;
 
-  ssize_t
-    count;
-
-  unsigned char
-    *pixels;
-
   size_t
     bits_per_pixel,
     num_pad_bytes, /* TS */
     one,
     packets;
 
+  ssize_t
+    count,
+    img_offset, /* TS */
+    comment_offset = 0,
+    y;
+
+  unsigned char
+    *pixels;
+
   /*
     Open image file.
   */
@@ -357,7 +355,6 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
   count=ReadBlob(image,3,(unsigned char *) tag);
   if (count != 3  ||  memcmp(tag,"\x6f\x80\x00",3) != 0)
     ThrowReaderException(CorruptImageError,"CorruptImage");
-
   if (pdb_info.number_records > 1)
     {
       comment_offset=(int) ReadBlobMSBLong(image);
@@ -366,7 +363,6 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
       if (count != 3  ||  memcmp(tag,"\x6f\x80\x01",3) != 0)
         ThrowReaderException(CorruptImageError,"CorruptImage");
     }
-
   num_pad_bytes = (size_t) (img_offset - TellBlob( image ));
   while (num_pad_bytes--) ReadBlobByte( image );
   /*
@@ -448,17 +444,17 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
           {
             index=(IndexPacket) (*p & (0x80 >> bit) ? 0x00 : 0x01);
             SetIndexPixelComponent(indexes+x+bit,index);
-            *q++=image->colormap[(ssize_t) index];
           }
           p++;
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
         status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
+      (void) SyncImage(image);
       break;
     }
     case 2:
@@ -475,26 +471,23 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
         for (x=0; x < (ssize_t) image->columns; x+=4)
         {
           index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03));
-          indexes[x]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x,index);
           index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03));
-          indexes[x+1]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x+1,index);
           index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03));
-          indexes[x+2]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x+2,index);
           index=ConstrainColormapIndex(image,3UL-((*p) & 0x03));
-          indexes[x+3]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x+3,index);
           p++;
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
         status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
+      (void) SyncImage(image);
       break;
     }
     case 4:
@@ -511,20 +504,19 @@ static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception)
         for (x=0; x < (ssize_t) image->columns; x+=2)
         {
           index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f));
-          indexes[x]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x,index);
           index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f));
-          indexes[x+1]=index;
-          *q++=image->colormap[(ssize_t) index];
+          SetIndexPixelComponent(indexes+x+1,index);
           p++;
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
         status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
+      (void) SyncImage(image);
       break;
     }
     default:
@@ -695,9 +687,6 @@ static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image)
   int
     bits;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -720,19 +709,20 @@ static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image)
     *q;
 
   size_t
-    packet_size;
+    bits_per_pixel,
+    literal,
+    packets,
+    packet_size,
+    repeat;
+
+  ssize_t
+    y;
 
   unsigned char
     *buffer,
     *runlength,
     *scanline;
 
-  size_t
-    bits_per_pixel,
-    literal,
-    packets,
-    repeat;
-
   /*
     Open output image file.
   */
diff --git a/coders/pdf.c b/coders/pdf.c
index 39f132a3b..8166b5c9d 100644
--- a/coders/pdf.c
+++ b/coders/pdf.c
@@ -357,13 +357,13 @@ static Image *ReadPDFImage(const ImageInfo *image_info,ExceptionInfo *exception)
     bounds,
     hires_bounds;
 
-  ssize_t
-    count;
-
   size_t
     scene,
     spotcolor;
 
+  ssize_t
+    count;
+
   assert(image_info != (const ImageInfo *) NULL);
   assert(image_info->signature == MagickSignature);
   if (image_info->debug != MagickFalse)
@@ -860,12 +860,12 @@ static char *EscapeParenthesis(const char *text)
   register ssize_t
     i;
 
-  static char
-    buffer[MaxTextExtent];
-
   size_t
     escapes;
 
+  static char
+    buffer[MaxTextExtent];
+
   escapes=0;
   p=buffer;
   for (i=0; i < (ssize_t) MagickMin(strlen(text),(MaxTextExtent-escapes-1)); i++)
@@ -979,10 +979,6 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
   GeometryInfo
     geometry_info;
 
-  ssize_t
-    count,
-    y;
-
   Image
     *next,
     *tile_image;
@@ -1025,7 +1021,17 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
     x;
 
   size_t
-    length;
+    info_id,
+    length,
+    object,
+    pages_id,
+    root_id,
+    text_size,
+    version;
+
+  ssize_t
+    count,
+    y;
 
   struct tm
     local_time;
@@ -1036,14 +1042,6 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
   unsigned char
     *pixels;
 
-  size_t
-    info_id,
-    object,
-    pages_id,
-    root_id,
-    text_size,
-    version;
-
   /*
     Open output image file.
   */
@@ -1714,7 +1712,7 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
                 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
                 if (image->colorspace == CMYKColorspace)
-                  *q++=ScaleQuantumToChar(indexes[x]);
+                  *q++=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
                 p++;
               }
               if (image->previous == (Image *) NULL)
@@ -1763,7 +1761,8 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                 Ascii85Encode(image,ScaleQuantumToChar(
                   GetBluePixelComponent(p)));
                 if (image->colorspace == CMYKColorspace)
-                  Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
+                  Ascii85Encode(image,ScaleQuantumToChar(
+                    GetIndexPixelComponent(indexes+x)));
                 p++;
               }
               if (image->previous == (Image *) NULL)
@@ -1849,7 +1848,8 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                   break;
                 indexes=GetVirtualIndexQueue(image);
                 for (x=0; x < (ssize_t) image->columns; x++)
-                  Ascii85Encode(image,(unsigned char) indexes[x]);
+                  Ascii85Encode(image,(unsigned char)
+                    GetIndexPixelComponent(indexes+x));
                 if (image->previous == (Image *) NULL)
                   {
                     status=SetImageProgress(image,SaveImageTag,
@@ -2155,7 +2155,7 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
                 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
                 if (image->colorspace == CMYKColorspace)
-                  *q++=ScaleQuantumToChar(indexes[x]);
+                  *q++=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
                 p++;
               }
             }
@@ -2198,7 +2198,8 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                 Ascii85Encode(image,ScaleQuantumToChar(
                   GetBluePixelComponent(p)));
                 if (image->colorspace == CMYKColorspace)
-                  Ascii85Encode(image,ScaleQuantumToChar(indexes[x]));
+                  Ascii85Encode(image,ScaleQuantumToChar(
+                    GetIndexPixelComponent(indexes+x)));
                 p++;
               }
             }
@@ -2273,7 +2274,8 @@ static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
                   break;
                 indexes=GetVirtualIndexQueue(tile_image);
                 for (x=0; x < (ssize_t) tile_image->columns; x++)
-                  Ascii85Encode(image,(unsigned char) indexes[x]);
+                  Ascii85Encode(image,(unsigned char)
+                    GetIndexPixelComponent(indexes+x));
               }
               Ascii85Flush(image);
               break;
diff --git a/coders/pes.c b/coders/pes.c
index 24469e53d..125e0ca1f 100644
--- a/coders/pes.c
+++ b/coders/pes.c
@@ -455,6 +455,11 @@ static Image *ReadPESImage(const ImageInfo *image_info,ExceptionInfo *exception)
   register ssize_t
     i;
 
+  size_t
+    number_blocks,
+    number_colors,
+    number_stitches;
+
   ssize_t
     count,
     offset;
@@ -463,11 +468,6 @@ static Image *ReadPESImage(const ImageInfo *image_info,ExceptionInfo *exception)
     magick[4],
     version[4];
 
-  size_t
-    number_blocks,
-    number_colors,
-    number_stitches;
-
   /*
     Open image file.
   */
diff --git a/coders/pict.c b/coders/pict.c
index 6168b4765..a394e53e9 100644
--- a/coders/pict.c
+++ b/coders/pict.c
@@ -427,10 +427,6 @@ static unsigned char *ExpandBuffer(unsigned char *pixels,
 static unsigned char *DecodeImage(Image *blob,Image *image,
   size_t bytes_per_line,const unsigned int bits_per_pixel,size_t *extent)
 {
-  ssize_t
-    j,
-    y;
-
   MagickSizeType
     number_pixels;
 
@@ -442,21 +438,21 @@ static unsigned char *DecodeImage(Image *blob,Image *image,
     *q;
 
   size_t
+    bytes_per_pixel,
     length,
-    row_bytes;
+    row_bytes,
+    scanline_length,
+    width;
 
   ssize_t
-    count;
+    count,
+    j,
+    y;
 
   unsigned char
     *pixels,
     *scanline;
 
-  size_t
-    bytes_per_pixel,
-    scanline_length,
-    width;
-
   /*
     Determine pixel buffer size.
   */
@@ -596,11 +592,6 @@ static size_t EncodeImage(Image *image,const unsigned char *scanline,
 #define MaxCount  128
 #define MaxPackbitsRunlength  128
 
-  ssize_t
-    count,
-    repeat_count,
-    runlength;
-
   register const unsigned char
     *p;
 
@@ -613,6 +604,11 @@ static size_t EncodeImage(Image *image,const unsigned char *scanline,
   size_t
     length;
 
+  ssize_t
+    count,
+    repeat_count,
+    runlength;
+
   unsigned char
     index;
 
@@ -806,12 +802,6 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
     c,
     code;
 
-  ssize_t
-    flags,
-    j,
-    version,
-    y;
-
   MagickBooleanType
     jpeg,
     status;
@@ -839,7 +829,11 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
     length;
 
   ssize_t
-    count;
+    count,
+    flags,
+    j,
+    version,
+    y;
 
   StringInfo
     *profile;
@@ -1180,10 +1174,13 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
                 if (tile_image->storage_class == PseudoClass)
                   {
                     index=ConstrainColormapIndex(tile_image,*p);
-                    indexes[x]=index;
-                    q->red=tile_image->colormap[(ssize_t) index].red;
-                    q->green=tile_image->colormap[(ssize_t) index].green;
-                    q->blue=tile_image->colormap[(ssize_t) index].blue;
+                    SetIndexPixelComponent(indexes+x,index);
+                    SetRedPixelComponent(q,
+                      tile_image->colormap[(ssize_t) index].red);
+                    SetGreenPixelComponent(q,
+                      tile_image->colormap[(ssize_t) index].green);
+                    SetBluePixelComponent(q,
+                      tile_image->colormap[(ssize_t) index].blue);
                   }
                 else
                   {
@@ -1191,12 +1188,13 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
                       {
                         i=(*p++);
                         j=(*p);
-                        q->red=ScaleCharToQuantum((unsigned char)
-                          ((i & 0x7c) << 1));
-                        q->green=ScaleCharToQuantum((unsigned char)
-                          (((i & 0x03) << 6) | ((j & 0xe0) >> 2)));
-                        q->blue=ScaleCharToQuantum((unsigned char)
-                          ((j & 0x1f) << 3));
+                        SetRedPixelComponent(q,ScaleCharToQuantum(
+                          (unsigned char) ((i & 0x7c) << 1)));
+                        SetGreenPixelComponent(q,ScaleCharToQuantum(
+                          (unsigned char) (((i & 0x03) << 6) |
+                          ((j & 0xe0) >> 2))));
+                        SetBluePixelComponent(q,ScaleCharToQuantum(
+                          (unsigned char) ((j & 0x1f) << 3)));
                       }
                     else
                       if (tile_image->matte == MagickFalse)
@@ -1205,23 +1203,24 @@ static Image *ReadPICTImage(const ImageInfo *image_info,
                             ThrowReaderException(CorruptImageError,
                               "NotEnoughPixelData");
                           SetRedPixelComponent(q,ScaleCharToQuantum(*p));
-                          q->green=ScaleCharToQuantum(
-                            *(p+tile_image->columns));
-                          q->blue=ScaleCharToQuantum(
-                            *(p+2*tile_image->columns));
+                          SetGreenPixelComponent(q,ScaleCharToQuantum(
+                            *(p+tile_image->columns)));
+                          SetBluePixelComponent(q,ScaleCharToQuantum(
+                            *(p+2*tile_image->columns)));
                         }
                       else
                         {
                           if (p > (pixels+extent+3*image->columns))
                             ThrowReaderException(CorruptImageError,
                               "NotEnoughPixelData");
-                          q->opacity=(Quantum) (QuantumRange-
-                            ScaleCharToQuantum(*p));
-                          q->red=ScaleCharToQuantum(*(p+tile_image->columns));
-                          q->green=(Quantum) ScaleCharToQuantum(
-                            *(p+2*tile_image->columns));
-                          q->blue=ScaleCharToQuantum(
-                            *(p+3*tile_image->columns));
+                          SetOpacityPixelComponent(q,(Quantum) (QuantumRange-
+                            ScaleCharToQuantum(*p)));
+                          SetRedPixelComponent(q,ScaleCharToQuantum(
+                            *(p+tile_image->columns)));
+                          SetGreenPixelComponent(q,ScaleCharToQuantum(
+                            *(p+2*tile_image->columns)));
+                          SetBluePixelComponent(q,ScaleCharToQuantum(
+                            *(p+3*tile_image->columns)));
                         }
                   }
                 p++;
@@ -1545,9 +1544,6 @@ static MagickBooleanType WritePICTImage(const ImageInfo *image_info,
     x_resolution,
     y_resolution;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -1576,16 +1572,18 @@ static MagickBooleanType WritePICTImage(const ImageInfo *image_info,
     x;
 
   size_t
-    count;
+    bytes_per_line,
+    count,
+    storage_class;
+
+  ssize_t
+    y;
 
   unsigned char
     *buffer,
     *packed_scanline,
     *scanline;
 
-  size_t
-    bytes_per_line,
-    storage_class;
 
   unsigned short
     base_address,
@@ -1888,13 +1886,13 @@ static MagickBooleanType WritePICTImage(const ImageInfo *image_info,
         break;
       indexes=GetVirtualIndexQueue(image);
       for (x=0; x < (ssize_t) image->columns; x++)
-        scanline[x]=(unsigned char) indexes[x];
+        scanline[x]=(unsigned char) GetIndexPixelComponent(indexes+x);
       count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
         packed_scanline);
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -1904,8 +1902,8 @@ static MagickBooleanType WritePICTImage(const ImageInfo *image_info,
       {
         (void) ResetMagickMemory(scanline,0,row_bytes);
         for (y=0; y < (ssize_t) image->rows; y++)
-          count+=EncodeImage(image,scanline,(size_t)
-            (row_bytes & 0x7FFF),packed_scanline);
+          count+=EncodeImage(image,scanline,(size_t) (row_bytes & 0x7FFF),
+            packed_scanline);
       }
     else
       {
diff --git a/coders/pix.c b/coders/pix.c
index 4c03e4585..f0f849146 100644
--- a/coders/pix.c
+++ b/coders/pix.c
@@ -93,9 +93,6 @@ static Image *ReadPIXImage(const ImageInfo *image_info,ExceptionInfo *exception)
   IndexPacket
     index;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -113,14 +110,15 @@ static Image *ReadPIXImage(const ImageInfo *image_info,ExceptionInfo *exception)
   register PixelPacket
     *q;
 
-  size_t
-    length;
-
   size_t
     bits_per_pixel,
     height,
+    length,
     width;
 
+  ssize_t
+    y;
+
   /*
     Open image file.
   */
@@ -191,10 +189,10 @@ static Image *ReadPIXImage(const ImageInfo *image_info,ExceptionInfo *exception)
               }
           }
         if (image->storage_class == PseudoClass)
-          indexes[x]=index;
-        q->blue=blue;
-        q->green=green;
-        q->red=red;
+          SetIndexPixelComponent(indexes+x,index);
+        SetBluePixelComponent(q,blue);
+        SetGreenPixelComponent(q,green);
+        SetRedPixelComponent(q,red);
         length--;
         q++;
       }
@@ -203,7 +201,7 @@ static Image *ReadPIXImage(const ImageInfo *image_info,ExceptionInfo *exception)
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
diff --git a/coders/plasma.c b/coders/plasma.c
index ac2eb6e5a..5851f9ac5 100644
--- a/coders/plasma.c
+++ b/coders/plasma.c
@@ -132,9 +132,6 @@ static Image *ReadPlasmaImage(const ImageInfo *image_info,
   ImageInfo
     *read_info;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -154,6 +151,9 @@ static Image *ReadPlasmaImage(const ImageInfo *image_info,
     depth,
     max_depth;
 
+  ssize_t
+    y;
+
   /*
     Recursively apply plasma to the image.
   */
@@ -173,7 +173,7 @@ static Image *ReadPlasmaImage(const ImageInfo *image_info,
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      q->opacity=(Quantum) (QuantumRange/2);
+      SetOpacityPixelComponent(q,QuantumRange/2);
       q++;
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
diff --git a/coders/pnm.c b/coders/pnm.c
index f84458ca4..b7981a2a7 100644
--- a/coders/pnm.c
+++ b/coders/pnm.c
@@ -158,9 +158,7 @@ static size_t PNMInteger(Image *image,const unsigned int base)
     *p;
 
   size_t
-    extent;
-
-  size_t
+    extent,
     value;
 
   /*
@@ -235,10 +233,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
   Image
     *image;
 
-  ssize_t
-    row,
-    y;
-
   MagickBooleanType
     status;
 
@@ -255,15 +249,15 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
     i;
 
   size_t
+    depth,
     extent,
+    max_value,
     packet_size;
 
   ssize_t
-    count;
-
-  size_t
-    depth,
-    max_value;
+    count,
+    row,
+    y;
 
   /*
     Open image file.
@@ -440,7 +434,7 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             break;
           for (x=0; x < (ssize_t) image->columns; x++)
           {
-            q->red=(Quantum) (PNMInteger(image,2) == 0 ? QuantumRange : 0);
+            SetRedPixelComponent(q,PNMInteger(image,2) == 0 ? QuantumRange : 0);
             SetGreenPixelComponent(q,GetRedPixelComponent(q));
             SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
@@ -493,9 +487,10 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             intensity=PNMInteger(image,10);
-            q->red=(Quantum) intensity;
+            SetRedPixelComponent(q,intensity);
             if (scale != (Quantum *) NULL)
-              q->red=scale[ConstrainPixel(image,(ssize_t) intensity,max_value)];
+              SetRedPixelComponent(q,scale[ConstrainPixel(image,(ssize_t)
+                intensity,max_value)]);
             SetGreenPixelComponent(q,GetRedPixelComponent(q));
             SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
@@ -561,9 +556,9 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                 pixel.blue=(MagickRealType) scale[ConstrainPixel(image,(ssize_t)
                   pixel.blue,max_value)];
               }
-            q->red=(Quantum) pixel.red;
-            q->green=(Quantum) pixel.green;
-            q->blue=(Quantum) pixel.blue;
+            SetRedPixelComponent(q,pixel.red);
+            SetGreenPixelComponent(q,pixel.green);
+            SetBluePixelComponent(q,pixel.blue);
             q++;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -595,9 +590,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
         extent=GetQuantumExtent(image,quantum_info,quantum_type);
         for (y=0; y < (ssize_t) image->rows; y++)
         {
-          ssize_t
-            offset;
-
           MagickBooleanType
             sync;
 
@@ -605,7 +597,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             *restrict q;
 
           ssize_t
-            count;
+            count,
+            offset;
 
           size_t
             length;
@@ -669,9 +662,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
         for (y=0; y < (ssize_t) image->rows; y++)
         {
-          ssize_t
-            offset;
-
           MagickBooleanType
             sync;
 
@@ -685,7 +675,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             *restrict q;
 
           ssize_t
-            count;
+            count,
+            offset;
 
           unsigned char
             *pixels;
@@ -779,9 +770,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
         for (y=0; y < (ssize_t) image->rows; y++)
         {
-          ssize_t
-            offset;
-
           MagickBooleanType
             sync;
 
@@ -795,7 +783,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             *restrict q;
 
           ssize_t
-            count;
+            count,
+            offset;
 
           unsigned char
             *pixels;
@@ -845,12 +834,12 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                 for (x=0; x < (ssize_t) image->columns; x++)
                 {
                   p=PushShortPixel(MSBEndian,p,&pixel);
-                  q->red=ScaleShortToQuantum(pixel);
+                  SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
                   p=PushShortPixel(MSBEndian,p,&pixel);
-                  q->green=ScaleShortToQuantum(pixel);
+                  SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
                   p=PushShortPixel(MSBEndian,p,&pixel);
-                  q->blue=ScaleShortToQuantum(pixel);
-                  q->opacity=OpaqueOpacity;
+                  SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+                  SetOpacityPixelComponent(q,OpaqueOpacity);
                   q++;
                 }
               }
@@ -863,12 +852,12 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     p=PushCharPixel(p,&pixel);
-                    q->red=ScaleAnyToQuantum(pixel,range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                     p=PushCharPixel(p,&pixel);
-                    q->green=ScaleAnyToQuantum(pixel,range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                     p=PushCharPixel(p,&pixel);
-                    q->blue=ScaleAnyToQuantum(pixel,range);
-                    q->opacity=OpaqueOpacity;
+                    SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                    SetOpacityPixelComponent(q,OpaqueOpacity);
                     q++;
                   }
                 }
@@ -880,12 +869,12 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                   for (x=0; x < (ssize_t) image->columns; x++)
                   {
                     p=PushShortPixel(MSBEndian,p,&pixel);
-                    q->red=ScaleAnyToQuantum(pixel,range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                     p=PushShortPixel(MSBEndian,p,&pixel);
-                    q->green=ScaleAnyToQuantum(pixel,range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                     p=PushShortPixel(MSBEndian,p,&pixel);
-                    q->blue=ScaleAnyToQuantum(pixel,range);
-                    q->opacity=OpaqueOpacity;
+                    SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                    SetOpacityPixelComponent(q,OpaqueOpacity);
                     q++;
                   }
                 }
@@ -959,9 +948,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
         for (y=0; y < (ssize_t) image->rows; y++)
         {
-          ssize_t
-            offset;
-
           MagickBooleanType
             sync;
 
@@ -975,7 +961,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             *restrict q;
 
           ssize_t
-            count;
+            count,
+            offset;
 
           unsigned char
             *pixels;
@@ -1078,7 +1065,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                       p=PushCharPixel(p,&pixel);
                       SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
                       p=PushCharPixel(p,&pixel);
-                      indexes[x]=ScaleAnyToQuantum(pixel,range);
+                      SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,
+                        range));
                       SetOpacityPixelComponent(q,OpaqueOpacity);
                       if (image->matte != MagickFalse)
                         {
@@ -1103,7 +1091,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
                       p=PushShortPixel(MSBEndian,p,&pixel);
                       SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
                       p=PushShortPixel(MSBEndian,p,&pixel);
-                      indexes[x]=ScaleAnyToQuantum(pixel,range);
+                      SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,
+                        range));
                       SetOpacityPixelComponent(q,OpaqueOpacity);
                       if (image->matte != MagickFalse)
                         {
@@ -1200,9 +1189,6 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
         extent=GetQuantumExtent(image,quantum_info,quantum_type);
         for (y=0; y < (ssize_t) image->rows; y++)
         {
-          ssize_t
-            offset;
-
           MagickBooleanType
             sync;
 
@@ -1210,7 +1196,8 @@ static Image *ReadPNMImage(const ImageInfo *image_info,ExceptionInfo *exception)
             *restrict q;
 
           ssize_t
-            count;
+            count,
+            offset;
 
           size_t
             length;
@@ -1440,9 +1427,6 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
   IndexPacket
     index;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -1467,7 +1451,8 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
     packet_size;
 
   ssize_t
-    count;
+    count,
+    y;
 
   /*
     Open output image file.
@@ -2045,8 +2030,8 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
                       q=PopCharPixel((unsigned char) pixel,q);
                       if (image->matte != MagickFalse)
                         {
-                          pixel=(unsigned char) ScaleQuantumToAny(GetOpacityPixelComponent(p),
-                            range);
+                          pixel=(unsigned char) ScaleQuantumToAny(
+                            GetOpacityPixelComponent(p),range);
                           q=PopCharPixel((unsigned char) pixel,q);
                         }
                       p++;
@@ -2058,8 +2043,8 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
                       q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                       if (image->matte != MagickFalse)
                         {
-                          pixel=(unsigned char) ScaleQuantumToAny(GetOpacityPixelComponent(p),
-                            range);
+                          pixel=(unsigned char) ScaleQuantumToAny(
+                            GetOpacityPixelComponent(p),range);
                           q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                         }
                       p++;
@@ -2078,7 +2063,8 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
                       q=PopCharPixel((unsigned char) pixel,q);
                       pixel=ScaleQuantumToAny(GetBluePixelComponent(p),range);
                       q=PopCharPixel((unsigned char) pixel,q);
-                      pixel=ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range);
+                      pixel=ScaleQuantumToAny(
+                        GetIndexPixelComponent(indexes+x),range);
                       q=PopCharPixel((unsigned char) pixel,q);
                       if (image->matte != MagickFalse)
                         {
@@ -2097,7 +2083,8 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
                       q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                       pixel=ScaleQuantumToAny(GetBluePixelComponent(p),range);
                       q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
-                      pixel=ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range);
+                      pixel=ScaleQuantumToAny(
+                        GetIndexPixelComponent(indexes+x),range);
                       q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
                       if (image->matte != MagickFalse)
                         {