diff --git a/coders/jpeg.c b/coders/jpeg.c
index 07589a9..136169f 100644
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -81,6 +81,7 @@
 #if defined(__MINGW32__)
 # define XMD_H 1  /* Avoid conflicting typedef for INT32 */
 typedef unsigned char boolean;
+#define HAVE_BOOLEAN
 #endif
 #undef HAVE_STDLIB_H
 #include "jpeglib.h"
diff --git a/coders/raw.c b/coders/raw.c
index e321558..803e1fd 100644
--- a/coders/raw.c
+++ b/coders/raw.c
@@ -100,9 +100,6 @@
     *canvas_image,
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -119,7 +116,8 @@
     length;
 
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     *pixels;
@@ -193,12 +191,12 @@
       register const PixelPacket
         *restrict p;
 
-      register ssize_t
-        x;
-
       register PixelPacket
         *restrict q;
 
+      register ssize_t
+        x;
+
       if (count != (ssize_t) length)
         {
           ThrowFileException(exception,CorruptImageError,
@@ -235,7 +233,7 @@
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -434,9 +432,6 @@
 */
 static MagickBooleanType WriteRAWImage(const ImageInfo *image_info,Image *image)
 {
-  ssize_t
-    y;
-
   MagickOffsetType
     scene;
 
@@ -452,12 +447,13 @@
   register const PixelPacket
     *p;
 
-  ssize_t
-    count;
-
   size_t
     length;
 
+  ssize_t
+    count,
+    y;
+
   unsigned char
     *pixels;
 
diff --git a/coders/rgb.c b/coders/rgb.c
index 0ec26f2..87ae3c1 100644
--- a/coders/rgb.c
+++ b/coders/rgb.c
@@ -117,13 +117,13 @@
   register ssize_t
     i;
 
+  size_t
+    length;
+
   ssize_t
     count,
     y;
 
-  size_t
-    length;
-
   unsigned char
     *pixels;
 
@@ -1078,13 +1078,13 @@
   QuantumType
     quantum_type;
 
+  size_t
+    length;
+
   ssize_t
     count,
     y;
 
-  size_t
-    length;
-
   unsigned char
     *pixels;
 
diff --git a/coders/rla.c b/coders/rla.c
index 1b9e126..8480b91 100644
--- a/coders/rla.c
+++ b/coders/rla.c
@@ -162,12 +162,6 @@
     length,
     runlength;
 
-  ssize_t
-    y;
-
-  ssize_t
-    *scanlines;
-
   MagickBooleanType
     status;
 
@@ -182,7 +176,9 @@
     *q;
 
   ssize_t
-    count;
+    count,
+    *scanlines,
+    y;
 
   RLAInfo
     rla_info;
@@ -308,23 +304,24 @@
               {
                 case 0:
                 {
-                  q->red=ScaleCharToQuantum(byte);
+                  SetRedPixelComponent(q,ScaleCharToQuantum(byte));
                   break;
                 }
                 case 1:
                 {
-                  q->green=ScaleCharToQuantum(byte);
+                  SetGreenPixelComponent(q,ScaleCharToQuantum(byte));
                   break;
                 }
                 case 2:
                 {
-                  q->blue=ScaleCharToQuantum(byte);
+                  SetBluePixelComponent(q,ScaleCharToQuantum(byte));
                   break;
                 }
                 case 3:
                 default:
                 {
-                  q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(byte));
+                  SetOpacityPixelComponent(q,QuantumRange-
+                    ScaleCharToQuantum(byte));
                   break;
                 }
               }
@@ -348,23 +345,23 @@
           {
             case 0:
             {
-              q->red=ScaleCharToQuantum(byte);
+              SetRedPixelComponent(q,ScaleCharToQuantum(byte));
               break;
             }
             case 1:
             {
-              q->green=ScaleCharToQuantum(byte);
+              SetGreenPixelComponent(q,ScaleCharToQuantum(byte));
               break;
             }
             case 2:
             {
-              q->blue=ScaleCharToQuantum(byte);
+              SetBluePixelComponent(q,ScaleCharToQuantum(byte));
               break;
             }
             case 3:
             default:
             {
-              q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(byte));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(byte));
               break;
             }
           }
@@ -377,7 +374,7 @@
       }
     }
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/rle.c b/coders/rle.c
index 2f96ace..a3f5c90 100644
--- a/coders/rle.c
+++ b/coders/rle.c
@@ -141,9 +141,6 @@
     operand,
     status;
 
-  ssize_t
-    y;
-
   MagickStatusType
     flags;
 
@@ -165,8 +162,16 @@
   register unsigned char
     *p;
 
+  size_t
+    bits_per_pixel,
+    map_length,
+    number_colormaps,
+    number_planes,
+    one;
+
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     background_color[256],
@@ -175,13 +180,6 @@
     plane,
     *rle_pixels;
 
-  size_t
-    bits_per_pixel,
-    map_length,
-    number_colormaps,
-    number_planes,
-    one;
-
   /*
     Open image file.
   */
@@ -369,7 +367,8 @@
           for (i=0; i < (ssize_t) operand; i++)
           {
             pixel=(unsigned char) ReadBlobByte(image);
-            if ((y < (ssize_t) image->rows) && ((x+i) < (ssize_t) image->columns))
+            if ((y < (ssize_t) image->rows) &&
+                ((x+i) < (ssize_t) image->columns))
               *p=pixel;
             p+=number_planes;
           }
@@ -390,7 +389,8 @@
             x*number_planes+plane;
           for (i=0; i < (ssize_t) operand; i++)
           {
-            if ((y < (ssize_t) image->rows) && ((x+i) < (ssize_t) image->columns))
+            if ((y < (ssize_t) image->rows) &&
+                ((x+i) < (ssize_t) image->columns))
               *p=pixel;
             p+=number_planes;
           }
@@ -447,7 +447,7 @@
             SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
             SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
             if (image->matte != MagickFalse)
-              SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(*p++));
             q++;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -503,13 +503,13 @@
                 break;
               indexes=GetAuthenticIndexQueue(image);
               for (x=0; x < (ssize_t) image->columns; x++)
-                indexes[x]=(IndexPacket) (*p++);
+                SetIndexPixelComponent(indexes+x,*p++);
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
               if (image->previous == (Image *) NULL)
                 {
-                  status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+                  status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+                    y,image->rows);
                   if (status == MagickFalse)
                     break;
                 }
@@ -528,18 +528,19 @@
                 break;
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                q->red=image->colormap[*p++].red;
-                q->green=image->colormap[*p++].green;
-                q->blue=image->colormap[*p++].blue;
-                SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+                SetRedPixelComponenet(q,image->colormap[*p++].red);
+                SetGreenPixelComponenet(q,image->colormap[*p++].green);
+                SetBluePixelComponenet(q,image->colormap[*p++].blue);
+                SetOpacityPixelComponent(q,QuantumRange-
+                  ScaleCharToQuantum(*p++));
                 q++;
               }
               if (SyncAuthenticPixels(image,exception) == MagickFalse)
                 break;
               if (image->previous == (Image *) NULL)
                 {
-                  status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+                  status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+                    y,image->rows);
                   if (status == MagickFalse)
                     break;
                 }
diff --git a/coders/scr.c b/coders/scr.c
index 7c956d1..1acb4f9 100644
--- a/coders/scr.c
+++ b/coders/scr.c
@@ -215,13 +215,19 @@
 
               if(binar[z])
             {
-                q->red=ScaleCharToQuantum(colour_palette[3*ink]);
-                q->green=ScaleCharToQuantum(colour_palette[1+(3*ink)]);
-                q->blue=ScaleCharToQuantum(colour_palette[2+(3*ink)]);
+                SetRedPixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[3*ink]));
+                SetGreenPixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[1+(3*ink)]));
+                SetBluePixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[2+(3*ink)]));
             } else {
-                q->red=ScaleCharToQuantum(colour_palette[3*paper]);
-                q->green=ScaleCharToQuantum(colour_palette[1+(3*paper)]);
-                q->blue=ScaleCharToQuantum(colour_palette[2+(3*paper)]);
+                SetRedPixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[3*paper]));
+                SetGreenPixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[1+(3*paper)]));
+                SetBluePixelComponent(q,ScaleCharToQuantum(
+                  colour_palette[2+(3*paper)]));
             }
 
               pix++;
diff --git a/coders/sct.c b/coders/sct.c
index ec259ad..66c6019 100644
--- a/coders/sct.c
+++ b/coders/sct.c
@@ -126,9 +126,6 @@
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -150,7 +147,8 @@
     *q;
 
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     buffer[768];
@@ -245,25 +243,25 @@
         {
           case 0:
           {
-            q->red=pixel;
-            q->green=pixel;
-            q->blue=pixel;
+            SetRedPixelComponent(q,pixel);
+            SetGreenPixelComponent(q,pixel);
+            SetBluePixelComponent(q,pixel);
             break;
           }
           case 1:
           {
-            q->green=pixel;
+            SetGreenPixelComponent(q,pixel);
             break;
           }
           case 2:
           {
-            q->blue=pixel; break;
+            SetBluePixelComponent(q,pixel);
             break;
           }
           case 3: 
           {
             if (image->colorspace == CMYKColorspace)
-              indexes[x]=(IndexPacket) pixel;
+              SetBlackPixelComponent(indexes+x,pixel);
             break;
           }
         }
@@ -275,7 +273,7 @@
         (void) ReadBlobByte(image);  /* pad */
     }
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/sgi.c b/coders/sgi.c
index 6cf92ea..eb5e2d7 100644
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -176,12 +176,12 @@
     *p,
     *q;
 
-  ssize_t
-    count;
-
   size_t
     pixel;
 
+  ssize_t
+    count;
+
   p=packets;
   q=pixels;
   if (bytes_per_pixel == 2)
@@ -551,15 +551,15 @@
                 break;
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                q->red=ScaleShortToQuantum((unsigned short)
-                  ((*(p+0) << 8) | (*(p+1))));
-                q->green=ScaleShortToQuantum((unsigned short)
-                  ((*(p+2) << 8) | (*(p+3))));
-                q->blue=ScaleShortToQuantum((unsigned short)
-                  ((*(p+4) << 8) | (*(p+5))));
+                SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+                  ((*(p+0) << 8) | (*(p+1)))));
+                SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+                  ((*(p+2) << 8) | (*(p+3)))));
+                SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+                  ((*(p+4) << 8) | (*(p+5)))));
                 SetOpacityPixelComponent(q,OpaqueOpacity);
                 if (image->matte != MagickFalse)
-                  q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
+                  SetOpacityPixelComponent(q,QuantumRange-ScaleShortToQuantum(
                     (unsigned short) ((*(p+6) << 8) | (*(p+7)))));
                 p+=8;
                 q++;
@@ -589,7 +589,8 @@
               q->blue=ScaleCharToQuantum(*(p+2));
               SetOpacityPixelComponent(q,OpaqueOpacity);
               if (image->matte != MagickFalse)
-                q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(*(p+3)));
+                SetOpacityPixelComponent(q,QuantumRange-
+                  ScaleCharToQuantum(*(p+3)));
               p+=4;
               q++;
             }
@@ -627,7 +628,7 @@
               {
                 quantum=(*p << 8);
                 quantum|=(*(p+1));
-                indexes[x]=(IndexPacket) quantum;
+                SetIndexPixelComponent(indexes+x,quantum);
                 p+=8;
                 q++;
               }
@@ -652,7 +653,7 @@
             indexes=GetAuthenticIndexQueue(image);
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              indexes[x]=(IndexPacket) (*p);
+              SetIndexPixelComponent(indexes+x,*p);
               p+=4;
               q++;
             }
@@ -853,10 +854,6 @@
   const char
     *value;
 
-  ssize_t
-    y,
-    z;
-
   MagickBooleanType
     status;
 
@@ -879,6 +876,10 @@
   register unsigned char
     *q;
 
+  ssize_t
+    y,
+    z;
+
   unsigned char
     *iris_pixels,
     *packets;
@@ -987,7 +988,7 @@
           *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
           *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
           *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
-          *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
+          *q++=ScaleQuantumToChar(GetAlphaPixelComponent(p));
           p++;
         }
       else
@@ -1001,13 +1002,13 @@
           *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
           *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
           *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
-          *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
+          *q++=ScaleQuantumToShort(GetAlphaPixelComponent(p));
           p++;
         }
       if (image->previous == (Image *) NULL)
         {
           status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -1049,17 +1050,15 @@
       }
       default:
       {
+        size_t
+          length,
+          number_packets,
+          *runlength;
+
         ssize_t
           offset,
           *offsets;
 
-        size_t
-          length,
-          number_packets;
-
-        size_t
-          *runlength;
-
         /*
           Convert SGI uncompressed pixels.
         */
diff --git a/coders/stegano.c b/coders/stegano.c
index 96c1b74..8ced904 100644
--- a/coders/stegano.c
+++ b/coders/stegano.c
@@ -100,9 +100,9 @@
 {
 #define GetBit(alpha,i) MagickMin((((size_t) (alpha) >> (size_t) \
   (i)) & 0x01),16)
-#define SetBit(alpha,i,set) (alpha)=(IndexPacket) ((set) != 0 ? \
-  (size_t) (alpha) | (one << (size_t) (i)) : (size_t) \
-  (alpha) & ~(one << (size_t) (i)))
+#define SetBit(indexes,i,set) SetIndexPixelComponent(indexes,((set) != 0 ? \
+  (size_t) GetIndexPixelComponent(indexes) | (one << (size_t) (i)) : (size_t) \
+  GetIndexPixelComponent(indexes) & ~(one << (size_t) (i))))
 
   Image
     *image,
@@ -195,17 +195,17 @@
         {
           case 0:
           {
-            SetBit(*indexes,i,GetBit(pixel.red,j));
+            SetBit(indexes,i,GetBit(pixel.red,j));
             break;
           }
           case 1:
           {
-            SetBit(*indexes,i,GetBit(pixel.green,j));
+            SetBit(indexes,i,GetBit(pixel.green,j));
             break;
           }
           case 2:
           {
-            SetBit(*indexes,i,GetBit(pixel.blue,j));
+            SetBit(indexes,i,GetBit(pixel.blue,j));
             break;
           }
         }
diff --git a/coders/sun.c b/coders/sun.c
index 62b41c6..0faca57 100644
--- a/coders/sun.c
+++ b/coders/sun.c
@@ -138,7 +138,8 @@
   const size_t length,unsigned char *pixels,size_t maxpixels)
 {
   register const unsigned char
-    *p, *l;
+    *l,
+    *p;
 
   register unsigned char
     *q;
@@ -232,9 +233,6 @@
   int
     bit;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -258,7 +256,8 @@
     length;
 
   ssize_t
-    count;
+    count,
+    y;
 
   SUNInfo
     sun_info;
@@ -448,14 +447,15 @@
         for (x=0; x < ((ssize_t) image->columns-7); x+=8)
         {
           for (bit=7; bit >= 0; bit--)
-            indexes[x+7-bit]=(IndexPacket) ((*p) & (0x01 << bit) ? 0x00 : 0x01);
+            SetIndexPixelComponent(indexes+x+7-bit,((*p) & (0x01 << bit) ?
+              0x00 : 0x01));
           p++;
         }
         if ((image->columns % 8) != 0)
           {
             for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
-              indexes[x+7-bit]=(IndexPacket)
-                ((*p) & (0x01 << bit) ? 0x00 : 0x01);
+              SetIndexPixelComponent(indexes+x+7-bit,(*p) & (0x01 << bit) ?
+                0x00 : 0x01);
             p++;
           }
         if ((((image->columns/8)+(image->columns % 8 ? 1 : 0)) % 2) != 0)
@@ -485,7 +485,7 @@
               break;
             indexes=GetAuthenticIndexQueue(image);
             for (x=0; x < (ssize_t) image->columns; x++)
-              indexes[x]=(IndexPacket) (*p++);
+              SetIndexPixelComponent(indexes+x,*p++);
             if ((image->columns % 2) != 0)
               p++;
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -521,7 +521,8 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               if (image->matte != MagickFalse)
-                SetOpacityPixelComponent(q,(QuantumRange-ScaleCharToQuantum(*p++)));
+                SetOpacityPixelComponent(q,(QuantumRange-
+                  ScaleCharToQuantum(*p++)));
               if (sun_info.type == RT_STANDARD)
                 {
                   SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
@@ -536,9 +537,12 @@
                 }
               if (image->colors != 0)
                 {
-                  q->red=image->colormap[(ssize_t) q->red].red;
-                  q->green=image->colormap[(ssize_t) q->green].green;
-                  q->blue=image->colormap[(ssize_t) q->blue].blue;
+                  SetRedPixelComponent(q,image->colormap[(ssize_t)
+                    q->red].red);
+                  SetGreenPixelComponent(q,image->colormap[(ssize_t)
+                    q->green].green);
+                  SetBluePixelComponent(q,image->colormap[(ssize_t)
+                    q->blue].blue);
                 }
               q++;
             }
@@ -849,7 +853,7 @@
           for (x=0; x < (ssize_t) image->columns; x++)
           {
             if (image->matte != MagickFalse)
-              *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
+              *q++=ScaleQuantumToChar(GetAlphaPixelComponent(p));
             *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
             *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
             *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
@@ -921,14 +925,14 @@
             Dump colormap to file.
           */
           for (i=0; i < (ssize_t) image->colors; i++)
-            (void) WriteBlobByte(image,
-              ScaleQuantumToChar(image->colormap[i].red));
+            (void) WriteBlobByte(image,ScaleQuantumToChar(
+              image->colormap[i].red));
           for (i=0; i < (ssize_t) image->colors; i++)
-            (void) WriteBlobByte(image,
-              ScaleQuantumToChar(image->colormap[i].green));
+            (void) WriteBlobByte(image,ScaleQuantumToChar(
+              image->colormap[i].green));
           for (i=0; i < (ssize_t) image->colors; i++)
-            (void) WriteBlobByte(image,
-              ScaleQuantumToChar(image->colormap[i].blue));
+            (void) WriteBlobByte(image,ScaleQuantumToChar(
+              image->colormap[i].blue));
           /*
             Convert PseudoClass packet to SUN colormapped pixel.
           */
@@ -940,7 +944,8 @@
             indexes=GetVirtualIndexQueue(image);
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              (void) WriteBlobByte(image,(unsigned char) indexes[x]);
+              (void) WriteBlobByte(image,(unsigned char)
+                GetIndexPixelComponent(indexes+x));
               p++;
             }
             if (image->columns & 0x01)
@@ -948,7 +953,7 @@
             if (image->previous == (Image *) NULL)
               {
                 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+                  image->rows);
                 if (status == MagickFalse)
                   break;
               }
diff --git a/coders/tga.c b/coders/tga.c
index 88540aa..f9ea204 100644
--- a/coders/tga.c
+++ b/coders/tga.c
@@ -134,9 +134,6 @@
   IndexPacket
     index;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -146,15 +143,23 @@
   register IndexPacket
     *indexes;
 
+  register PixelPacket
+    *q;
+
   register ssize_t
     i,
     x;
 
-  register PixelPacket
-    *q;
+  size_t
+    base,
+    flag,
+    offset,
+    real,
+    skip;
 
   ssize_t
-    count;
+    count,
+    y;
 
   TGAInfo
     tga_info;
@@ -164,13 +169,6 @@
     k,
     runlength;
 
-  size_t
-    base,
-    flag,
-    offset,
-    real,
-    skip;
-
   /*
     Open image file.
   */
@@ -443,7 +441,7 @@
       if (status == MagickFalse)
         ThrowReaderException(CorruptImageError,"UnableToReadImageData");
       if (image->storage_class == PseudoClass)
-        indexes[x]=index;
+        SetIndexPixelComponent(indexes+x,index);
       SetRedPixelComponent(q,pixel.red);
       SetGreenPixelComponent(q,pixel.green);
       SetBluePixelComponent(q,pixel.blue);
@@ -636,9 +634,6 @@
   const char
     *value;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -658,7 +653,8 @@
     *q;
 
   ssize_t
-    count;
+    count,
+    y;
 
   TargaInfo
     targa_info;
@@ -798,8 +794,8 @@
             *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
             *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
             if (image->matte != MagickFalse)
-              *q++=(unsigned char) ScaleQuantumToChar((Quantum)
-                (GetAlphaPixelComponent(p)));
+              *q++=(unsigned char) ScaleQuantumToChar(
+                GetAlphaPixelComponent(p));
             if (image->colorspace == CMYKColorspace)
               *q++=ScaleQuantumToChar(indexes[x]);
           }
@@ -809,7 +805,7 @@
     if (image->previous == (Image *) NULL)
       {
         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-              image->rows);
+          image->rows);
         if (status == MagickFalse)
           break;
       }
diff --git a/coders/thumbnail.c b/coders/thumbnail.c
index ddcef06..1f16349 100644
--- a/coders/thumbnail.c
+++ b/coders/thumbnail.c
@@ -169,12 +169,12 @@
   register ssize_t
     i;
 
-  ssize_t
-    offset;
-
   size_t
     length;
 
+  ssize_t
+    offset;
+
   unsigned char
     magick[MaxTextExtent];
 
diff --git a/coders/tiff.c b/coders/tiff.c
index 22e097f..d394e2a 100644
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -747,9 +747,6 @@
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     associated_alpha,
     debug,
@@ -769,8 +766,12 @@
 
   size_t
     length,
+    lsb_first,
     pad;
 
+  ssize_t
+    y;
+
   TIFF
     *tiff;
 
@@ -806,9 +807,6 @@
   unsigned char
     *pixels;
 
-  size_t
-    lsb_first;
-
   /*
     Open image.
   */
@@ -1404,11 +1402,15 @@
           p=(unsigned char *) (((uint32 *) pixels)+image->columns*i);
           for (x=0; x < (ssize_t) image->columns; x++)
           {
-            q->red=ScaleCharToQuantum((unsigned char) (TIFFGetR(*p)));
-            q->green=ScaleCharToQuantum((unsigned char) (TIFFGetG(*p)));
-            q->blue=ScaleCharToQuantum((unsigned char) (TIFFGetB(*p)));
+            SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+              (TIFFGetR(*p))));
+            SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+              (TIFFGetG(*p))));
+            SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+              (TIFFGetB(*p))));
             if (image->matte != MagickFalse)
-              q->opacity=ScaleCharToQuantum((unsigned char) (TIFFGetA(*p)));
+              SetOpacityPixelComponent(q,ScaleCharToQuantum((unsigned char)
+                (TIFFGetA(*p))));
             p++;
             q++;
           }
@@ -1495,10 +1497,13 @@
               if (image->matte != MagickFalse)
                 for (column=columns_remaining; column > 0; column--)
                 {
-                  q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
-                  q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
-                  q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
-                  q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
+                  SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetR(*p)));
+                  SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetG(*p)));
+                  SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetB(*p)));
+                  SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(
                     (unsigned char) TIFFGetA(*p)));
                   q++;
                   p++;
@@ -1506,9 +1511,12 @@
               else
                 for (column=columns_remaining; column > 0; column--)
                 {
-                  q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
-                  q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
-                  q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
+                  SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetR(*p)));
+                  SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetG(*p)));
+                  SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+                    TIFFGetB(*p)));
                   q++;
                   p++;
                 }
@@ -1575,12 +1583,15 @@
           q+=image->columns-1;
           for (x=0; x < (ssize_t) image->columns; x++)
           {
-            q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
-            q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
-            q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
+            SetRedPixelComponent(q,ScaleCharToQuantum((unsigned char)
+              TIFFGetR(*p)));
+            SetBluePixelComponent(q,ScaleCharToQuantum((unsigned char)
+              TIFFGetG(*p)));
+            SetGreenPixelComponent(q,ScaleCharToQuantum((unsigned char)
+              TIFFGetB(*p)));
             if (image->matte != MagickFalse)
-              q->opacity=(Quantum) (QuantumRange-
-                ScaleCharToQuantum((unsigned char) TIFFGetA(*p)));
+              SetOpacityPixelComponent(q,QuantumRange-ScaleCharToQuantum(
+                (unsigned char) TIFFGetA(*p)));
             p--;
             q--;
           }
@@ -2161,12 +2172,6 @@
   int32
     status;
 
-  ssize_t
-    bytes_per_pixel,
-    j,
-    k,
-    l;
-
   register ssize_t
     i;
 
@@ -2178,6 +2183,12 @@
     number_tiles,
     tile_width;
 
+  ssize_t
+    bytes_per_pixel,
+    j,
+    k,
+    l;
+
   if (TIFFIsTiled(tiff) == 0)
     return(TIFFWriteScanline(tiff,tiff_info->scanline,(uint32) row,sample));
   /*
@@ -2187,7 +2198,8 @@
   (void) CopyMagickMemory(tiff_info->scanlines+i,(char *) tiff_info->scanline,
     (size_t) TIFFScanlineSize(tiff));
   if (((size_t) (row % tiff_info->tile_geometry.height) !=
-      (tiff_info->tile_geometry.height-1)) && (row != (ssize_t) (image->rows-1)))
+      (tiff_info->tile_geometry.height-1)) &&
+      (row != (ssize_t) (image->rows-1)))
     return(0);
   /*
     Write tile to TIFF image.
@@ -2410,9 +2422,6 @@
   EndianType
     endian_type;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     debug,
     status;
@@ -2433,6 +2442,9 @@
     length,
     lsb_first;
 
+  ssize_t
+    y;
+
   TIFF
     *tiff;
 
diff --git a/coders/tim.c b/coders/tim.c
index a3735b3..2a3b224 100644
--- a/coders/tim.c
+++ b/coders/tim.c
@@ -105,9 +105,6 @@
     bits_per_pixel,
     has_clut;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -126,8 +123,16 @@
   register unsigned char
     *p;
 
+  size_t
+    bytes_per_line,
+    height,
+    image_size,
+    pixel_mode,
+    width;
+
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     *tim_data,
@@ -136,13 +141,6 @@
   unsigned short
     word;
 
-  size_t
-    bytes_per_line,
-    height,
-    image_size,
-    pixel_mode,
-    width;
-
   /*
     Open image file.
   */
@@ -266,13 +264,13 @@
           p=tim_pixels+y*bytes_per_line;
           for (x=0; x < ((ssize_t) image->columns-1); x+=2)
           {
-            indexes[x]=(IndexPacket) ((*p) & 0x0f);
-            indexes[x+1]=(IndexPacket) ((*p >> 4) & 0x0f);
+            SetIndexPixelComponent(indexes+x,(*p) & 0x0f);
+            SetIndexPixelComponent(indexes+x+1,(*p >> 4) & 0x0f);
             p++;
           }
           if ((image->columns % 2) != 0)
             {
-              indexes[x]=(IndexPacket) ((*p >> 4) & 0x0f);
+              SetIndexPixelComponent(indexes+x,(*p >> 4) & 0x0f);
               p++;
             }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -300,7 +298,7 @@
           indexes=GetAuthenticIndexQueue(image);
           p=tim_pixels+y*bytes_per_line;
           for (x=0; x < (ssize_t) image->columns; x++)
-            indexes[x]=(*p++);
+            SetIndexPixelComponent(indexes+x,*p++);
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
           if (image->previous == (Image *) NULL)
@@ -328,9 +326,12 @@
           {
             word=(*p++);
             word|=(*p++ << 8);
-            q->blue=ScaleCharToQuantum(ScaleColor5to8((1UL*word >> 10) & 0x1f));
-            q->green=ScaleCharToQuantum(ScaleColor5to8((1UL*word >> 5) & 0x1f));
-            q->red=ScaleCharToQuantum(ScaleColor5to8(1UL*word & 0x1f));
+            SetBluePixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+              (1UL*word >> 10) & 0x1f)));
+            SetGreenPixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+              (1UL*word >> 5) & 0x1f)));
+            SetRedPixelComponent(q,ScaleCharToQuantum(ScaleColor5to8(
+              (1UL*word >> 0) & 0x1f)));
             q++;
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
diff --git a/coders/ttf.c b/coders/ttf.c
index 096ca16..c3f8803 100644
--- a/coders/ttf.c
+++ b/coders/ttf.c
@@ -187,9 +187,6 @@
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -203,6 +200,9 @@
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   /*
     Open image file.
   */
diff --git a/coders/txt.c b/coders/txt.c
index 0d0eeeb..baa65d4 100644
--- a/coders/txt.c
+++ b/coders/txt.c
@@ -170,9 +170,6 @@
   Image
     *texture;
 
-  ssize_t
-    offset;
-
   MagickBooleanType
     status;
 
@@ -182,6 +179,9 @@
   RectangleInfo
     page;
 
+  ssize_t
+    offset;
+
   TypeMetric
     metrics;
 
@@ -223,10 +223,10 @@
   /*
     Initialize Image structure.
   */
-  image->columns=(size_t) floor((((double) page.width*
-    image->x_resolution)/delta.x)+0.5);
-  image->rows=(size_t) floor((((double) page.height*
-    image->y_resolution)/delta.y)+0.5);
+  image->columns=(size_t) floor((((double) page.width*image->x_resolution)/
+    delta.x)+0.5);
+  image->rows=(size_t) floor((((double) page.height*image->y_resolution)/
+    delta.y)+0.5);
   image->page.x=0;
   image->page.y=0;
   texture=(Image *) NULL;
@@ -476,17 +476,18 @@
         q=GetAuthenticPixels(image,x_offset,y_offset,1,1,exception);
         if (q == (PixelPacket *) NULL)
           continue;
-        q->red=ScaleAnyToQuantum(pixel.red,range);
-        q->green=ScaleAnyToQuantum(pixel.green,range);
-        q->blue=ScaleAnyToQuantum(pixel.blue,range);
+        SetRedPixelComponent(q,ScaleAnyToQuantum(pixel.red,range));
+        SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel.green,range));
+        SetBluePixelComponent(q,ScaleAnyToQuantum(pixel.blue,range));
         if (image->colorspace == CMYKColorspace)
           {
             indexes=GetAuthenticIndexQueue(image);
-            *indexes=ScaleAnyToQuantum(pixel.index,range);
+            SetIndexPixelComponent(indexes,ScaleAnyToQuantum(pixel.index,
+              range));
           }
         if (image->matte != MagickFalse)
-          q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel.opacity,
-            range));
+          SetOpacityPixelComponent(q,QuantumRange-ScaleAnyToQuantum(
+            pixel.opacity,range));
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
       }
@@ -616,9 +617,6 @@
     colorspace[MaxTextExtent],
     tuple[MaxTextExtent];
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -637,6 +635,9 @@
   register ssize_t
     x;
 
+  ssize_t
+    y;
+
   /*
     Open output image file.
   */
diff --git a/coders/uil.c b/coders/uil.c
index 115ce8e..c706888 100644
--- a/coders/uil.c
+++ b/coders/uil.c
@@ -168,10 +168,6 @@
   int
     j;
 
-  ssize_t
-    k,
-    y;
-
   MagickBooleanType
     status,
     transparent;
@@ -192,14 +188,18 @@
     i,
     x;
 
-  static const char
-    Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk"
-                         "lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
-
   size_t
     characters_per_pixel,
     colors;
 
+  ssize_t
+    k,
+    y;
+
+  static const char
+    Cixel[MaxCixels+1] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjk"
+                         "lzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
+
   /*
     Open output image file.
   */
@@ -248,8 +248,8 @@
               break;
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              matte_image[i]=(unsigned char)
-              (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ? 1 : 0);
+              matte_image[i]=(unsigned char) (GetOpacityPixelComponent(p) ==
+                (Quantum) TransparentOpacity ? 1 : 0);
               if (matte_image[i] != 0)
                 transparent=MagickTrue;
               i++;
@@ -277,7 +277,7 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               if (matte_image[i] != 0)
-                indexes[x]=(IndexPacket) image->colors;
+                SetIndexPixelComponent(indexes+x,image->colors);
               p++;
             }
           }
@@ -359,7 +359,7 @@
       symbol[0]=Cixel[k];
       for (j=1; j < (int) characters_per_pixel; j++)
       {
-        k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+        k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
         symbol[j]=Cixel[k];
       }
       symbol[j]='\0';
@@ -371,7 +371,7 @@
       (y == (ssize_t) (image->rows-1) ? ");" : ","));
     (void) WriteBlobString(image,buffer);
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/uyvy.c b/coders/uyvy.c
index 9a07006..0bd1ff4 100644
--- a/coders/uyvy.c
+++ b/coders/uyvy.c
@@ -98,9 +98,6 @@
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -110,6 +107,9 @@
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   unsigned char
     u,
     v,
@@ -158,19 +158,19 @@
       y1=(unsigned char) ReadBlobByte(image);
       v=(unsigned char) ReadBlobByte(image);
       y2=(unsigned char) ReadBlobByte(image);
-      q->red=ScaleCharToQuantum(y1);
-      q->green=ScaleCharToQuantum(u);
-      q->blue=ScaleCharToQuantum(v);
+      SetRedPixelComponent(q,ScaleCharToQuantum(y1));
+      SetGreenPixelComponent(q,ScaleCharToQuantum(u));
+      SetBluePixelComponent(q,ScaleCharToQuantum(v));
       q++;
-      q->red=ScaleCharToQuantum(y2);
-      q->green=ScaleCharToQuantum(u);
-      q->blue=ScaleCharToQuantum(v);
+      SetRedPixelComponent(q,ScaleCharToQuantum(y2));
+      SetGreenPixelComponent(q,ScaleCharToQuantum(u));
+      SetBluePixelComponent(q,ScaleCharToQuantum(v));
       q++;
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
@@ -293,9 +293,6 @@
   Image
     *uyvy_image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     full,
     status;
@@ -306,6 +303,9 @@
   register ssize_t
     x;
 
+  ssize_t
+    y;
+
   /*
     Open output image file.
   */
@@ -343,7 +343,8 @@
           (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.green));
           (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
           (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.blue));
-          (void) WriteBlobByte(image,ScaleQuantumToChar(GetRedPixelComponent(p)));
+          (void) WriteBlobByte(image,ScaleQuantumToChar(
+             GetRedPixelComponent(p)));
         }
       pixel.red=(double) GetRedPixelComponent(p);
       pixel.green=(double) GetGreenPixelComponent(p);
@@ -352,7 +353,7 @@
       p++;
     }
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/vicar.c b/coders/vicar.c
index 4431b2c..77ad3aa 100644
--- a/coders/vicar.c
+++ b/coders/vicar.c
@@ -153,9 +153,6 @@
   int
     c;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status,
     value_expected;
@@ -173,7 +170,8 @@
     length;
 
   ssize_t
-    count;
+    count,
+    y;
 
   unsigned char
     *pixels;
@@ -433,12 +431,12 @@
   register const PixelPacket
     *p;
 
-  ssize_t
-    count;
-
   size_t
     length;
 
+  ssize_t
+    count;
+
   unsigned char
     *pixels;
 
diff --git a/coders/viff.c b/coders/viff.c
index 036c8ce..f78a08c 100644
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -213,9 +213,6 @@
   int
     bit;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -237,19 +234,20 @@
   register unsigned char
     *p;
 
-  ssize_t
-    count;
-
-  unsigned char
-    buffer[7],
-    *viff_pixels;
-
   size_t
     bytes_per_pixel,
     lsb_first,
     max_packets,
     quantum;
 
+  ssize_t
+    count,
+    y;
+
+  unsigned char
+    buffer[7],
+    *viff_pixels;
+
   ViffInfo
     viff_info;
 
@@ -346,7 +344,8 @@
       (void) ReadBlobByte(image);
     image->columns=viff_info.rows;
     image->rows=viff_info.columns;
-    image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL : MAGICKCORE_QUANTUM_DEPTH;
+    image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL :
+      MAGICKCORE_QUANTUM_DEPTH;
     /*
       Verify that we can read this VIFF image.
     */
@@ -631,7 +630,7 @@
                 {
                   quantum=(size_t) indexes[x+bit];
                   quantum|=0x01;
-                  indexes[x+bit]=(IndexPacket) quantum;
+                  SetIndexPixelComponent(indexes+x+bit,quantum);
                 }
             p++;
           }
@@ -642,7 +641,7 @@
                   {
                     quantum=(size_t) indexes[x+bit];
                     quantum|=0x01;
-                    indexes[x+bit]=(IndexPacket) quantum;
+                    SetIndexPixelComponent(indexes+x+bit,quantum);
                   }
               p++;
             }
@@ -666,7 +665,7 @@
             break;
           indexes=GetAuthenticIndexQueue(image);
           for (x=0; x < (ssize_t) image->columns; x++)
-            indexes[x]=(IndexPacket) (*p++);
+            SetIndexPixelComponent(indexes+x,*p++);
           if (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
           if (image->previous == (Image *) NULL)
@@ -691,16 +690,20 @@
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               SetRedPixelComponent(q,ScaleCharToQuantum(*p));
-              q->green=ScaleCharToQuantum(*(p+number_pixels));
-              q->blue=ScaleCharToQuantum(*(p+2*number_pixels));
+              SetGreenPixelComponent(q,ScaleCharToQuantum(*(p+number_pixels)));
+              SetBluePixelComponent(q,ScaleCharToQuantum(*(p+2*number_pixels)));
               if (image->colors != 0)
                 {
-                  q->red=image->colormap[(ssize_t) q->red].red;
-                  q->green=image->colormap[(ssize_t) q->green].green;
-                  q->blue=image->colormap[(ssize_t) q->blue].blue;
+                  SetRedPixelComponent(q,image->colormap[(ssize_t)
+                    q->red].red);
+                  SetGreenPixelComponent(q,image->colormap[(ssize_t)
+                    q->green].green);
+                  SetBluePixelComponent(q,image->colormap[(ssize_t)
+                    q->blue].blue);
                 }
-              q->opacity=(Quantum) (image->matte ? QuantumRange-
-                ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueOpacity);
+              SetOpacityPixelComponent(q,image->matte != MagickFalse ?
+                QuantumRange-ScaleCharToQuantum(*(p+number_pixels*3)) :
+                OpaqueOpacity);
               p++;
               q++;
             }
@@ -912,9 +915,6 @@
   const char
     *value;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -940,6 +940,9 @@
   register unsigned char
     *q;
 
+  ssize_t
+    y;
+
   unsigned char
     buffer[8],
     *viff_pixels;
@@ -978,7 +981,8 @@
     *viff_info.comment='\0';
     value=GetImageProperty(image,"comment");
     if (value != (const char *) NULL)
-      (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),511)+1);
+      (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),
+        511)+1);
     viff_info.rows=image->columns;
     viff_info.columns=image->rows;
     viff_info.subrows=0;
diff --git a/coders/wbmp.c b/coders/wbmp.c
index 75f8bc2..23ff0b2 100644
--- a/coders/wbmp.c
+++ b/coders/wbmp.c
@@ -121,9 +121,6 @@
   int
     byte;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -136,6 +133,9 @@
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   unsigned char
     bit;
 
@@ -201,7 +201,7 @@
           if (byte == EOF)
             ThrowReaderException(CorruptImageError,"CorruptImage");
         }
-      indexes[x]=(IndexPacket) ((byte & (0x01 << (7-bit))) ? 1 : 0);
+      SetIndexPixelComponent(indexes+x,(byte & (0x01 << (7-bit))) ? 1 : 0);
       bit++;
       if (bit == 8)
         bit=0;
@@ -347,9 +347,6 @@
 static MagickBooleanType WriteWBMPImage(const ImageInfo *image_info,
   Image *image)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -359,6 +356,9 @@
   register ssize_t
     x;
 
+  ssize_t
+    y;
+
   unsigned char
     bit,
     byte;
@@ -407,7 +407,7 @@
     if (bit != 0)
       (void) WriteBlobByte(image,byte);
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/webp.c b/coders/webp.c
index 7444b84..7795140 100644
--- a/coders/webp.c
+++ b/coders/webp.c
@@ -376,7 +376,8 @@
       *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
       if (image->matte != MagickFalse)
         *q++=ScaleQuantumToChar((Quantum) (QuantumRange-
-          (image->matte != MagickFalse ? GetOpacityPixelComponent(p) : OpaqueOpacity)));
+          (image->matte != MagickFalse ? GetOpacityPixelComponent(p) :
+          OpaqueOpacity)));
       p++;
     }
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
diff --git a/coders/xbm.c b/coders/xbm.c
index 92ec4c3..ce8a647 100644
--- a/coders/xbm.c
+++ b/coders/xbm.c
@@ -167,9 +167,6 @@
   Image
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -190,19 +187,20 @@
     hex_digits[256];
 
   size_t
-    length;
-
-  unsigned char
-    *data;
-
-  size_t
     bit,
     byte,
     bytes_per_line,
+    length,
     padding,
     value,
     version;
 
+  ssize_t
+    y;
+
+  unsigned char
+    *data;
+
   unsigned long
     height,
     width;
@@ -365,7 +363,7 @@
     {
       if (bit == 0)
         byte=(size_t) (*p++);
-      indexes[x]=(IndexPacket) ((byte & 0x01) != 0 ? 0x01 : 0x00);
+      SetIndexPixelComponent(indexes+x,(byte & 0x01) != 0 ? 0x01 : 0x00);
       bit++;
       byte>>=1;
       if (bit == 8)
@@ -374,7 +372,7 @@
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
@@ -479,9 +477,6 @@
     basename[MaxTextExtent],
     buffer[MaxTextExtent];
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -491,13 +486,14 @@
   register ssize_t
     x;
 
-  ssize_t
-    count;
-
   size_t
     bit,
     byte;
 
+  ssize_t
+    count,
+    y;
+
   /*
     Open output image file.
   */
@@ -589,7 +585,7 @@
         byte=0;
       };
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/xc.c b/coders/xc.c
index 4a0cd11..d8cb1d2 100644
--- a/coders/xc.c
+++ b/coders/xc.c
@@ -102,9 +102,6 @@
   MagickPixelPacket
     color;
 
-  ssize_t
-    y;
-
   PixelPacket
     pixel;
 
@@ -114,6 +111,9 @@
   register PixelPacket
     *q;
 
+  ssize_t
+    y;
+
   /*
     Initialize Image structure.
   */
@@ -151,7 +151,7 @@
       {
         indexes=GetAuthenticIndexQueue(image);
         for (x=0; x < (ssize_t) image->columns; x++)
-          indexes[x]=index;
+          SetIndexPixelComponetn(indexes+x,index);
       }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)
       break;
diff --git a/coders/xcf.c b/coders/xcf.c
index 6a20dd3..963b889 100644
--- a/coders/xcf.c
+++ b/coders/xcf.c
@@ -373,11 +373,11 @@
       {
         for (x=0; x < (ssize_t) tile_image->columns; x++)
         {
-          q->red=ScaleCharToQuantum(*graydata);
+          SetRedPixelComponent(q,ScaleCharToQuantum(*graydata));
           SetGreenPixelComponent(q,GetRedPixelComponent(q));
           SetBluePixelComponent(q,GetRedPixelComponent(q));
-          q->opacity=ScaleCharToQuantum((unsigned char) (255-
-            inLayerInfo->opacity));
+          SetOpacityPixelComponent(q,ScaleCharToQuantum(
+            (unsigned char) (255-inLayerInfo->opacity)));
           graydata++;
           q++;
         }
@@ -387,11 +387,12 @@
         {
           for (x=0; x < (ssize_t) tile_image->columns; x++)
           {
-            q->red=ScaleCharToQuantum(xcfdata->red);
-            q->green=ScaleCharToQuantum(xcfdata->green);
-            q->blue=ScaleCharToQuantum(xcfdata->blue);
-            q->opacity=(Quantum) (xcfdata->opacity == 0U ? TransparentOpacity :
-              ScaleCharToQuantum((unsigned char) (255-inLayerInfo->opacity)));
+            SetRedPixelComponent(q,ScaleCharToQuantum(xcfdata->red));
+            SetGreenPixelComponent(q,ScaleCharToQuantum(xcfdata->green));
+            SetBluePixelComponent(q,ScaleCharToQuantum(xcfdata->blue));
+            SetOpacityPixelComponent(q,xcfdata->opacity == 0U ?
+              TransparentOpacity : ScaleCharToQuantum((unsigned char) (255-
+              inLayerInfo->opacity)));
             xcfdata++;
             q++;
           }
@@ -409,23 +410,21 @@
   ExceptionInfo
     *exception;
 
-  ssize_t
-    i,
-    j;
-
   MagickOffsetType
     size;
 
   register PixelPacket
     *q;
 
-  ssize_t
-    bytes_per_pixel,
-    count;
-
   size_t
     length;
 
+  ssize_t
+    bytes_per_pixel,
+    count,
+    i,
+    j;
+
   unsigned char
     data,
     pixel,
@@ -475,36 +474,36 @@
               {
                 case 0:
                 {
-                  q->red=ScaleCharToQuantum(data);
+                  SetRedPixelComponent(q,ScaleCharToQuantum(data));
                   if (inDocInfo->image_type == GIMP_GRAY)
                     {
-                      q->green=ScaleCharToQuantum(data);
-                      q->blue=ScaleCharToQuantum(data);
-                      q->opacity=ScaleCharToQuantum((unsigned char) (255-
-                        inLayerInfo->opacity));
+                      SetGreenPixelComponent(q,ScaleCharToQuantum(data));
+                      SetBluePixelComponent(q,ScaleCharToQuantum(data));
+                      SetOpacityPixelComponent(q,ScaleCharToQuantum(
+                        (unsigned char) (255-inLayerInfo->opacity)));
                     }
                   else
                     {
-                      q->green= q->red;
-                      q->blue= q->red;
-                      q->opacity=ScaleCharToQuantum((unsigned char) (255-
-                        inLayerInfo->opacity));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
+                      SetOpacityPixelComponent(q,ScaleCharToQuantum(
+                        (unsigned char) (255-inLayerInfo->opacity)));
                     }
                   break;
                 }
                 case 1:
                 {
-                  q->green=ScaleCharToQuantum(data);
+                  SetGreenPixelComponent(q,ScaleCharToQuantum(data));
                   break;
                 }
                 case 2:
                 {
-                  q->blue=ScaleCharToQuantum(data);
+                  SetBluePixelComponent(q,ScaleCharToQuantum(data));
                   break;
                 }
                 case 3:
                 {
-                  q->opacity=(Quantum) (data == 0 ? TransparentOpacity :
+                  SetOpacityPixelComponent(q,data == 0 ? TransparentOpacity :
                     ScaleCharToQuantum((unsigned char) (255-
                     inLayerInfo->opacity)));
                   break;
@@ -536,36 +535,36 @@
               {
                 case 0:
                 {
-                  q->red=ScaleCharToQuantum(data);
+                  SetReadPixelComponent(q,ScaleCharToQuantum(data));
                   if (inDocInfo->image_type == GIMP_GRAY)
                     {
-                      q->green=ScaleCharToQuantum(data);
-                      q->blue=ScaleCharToQuantum(data);
-                      q->opacity=ScaleCharToQuantum((unsigned char) (255-
-                        inLayerInfo->opacity));
+                      SetGreenPixelComponent(q,ScaleCharToQuantum(data));
+                      SetBluePixelComponent(q,ScaleCharToQuantum(data));
+                      SetOpacityPixelComponent(q,ScaleCharToQuantum(
+                        (unsigned char) (255-inLayerInfo->opacity)));
                     }
                   else
                     {
                       SetGreenPixelComponent(q,GetRedPixelComponent(q));
                       SetBluePixelComponent(q,GetRedPixelComponent(q));
-                      q->opacity=ScaleCharToQuantum((unsigned char) (255-
-                        inLayerInfo->opacity));
+                      SetOpacityPixelComponent(q,ScaleCharToQuantum(
+                        (unsigned char) (255-inLayerInfo->opacity)));
                     }
                   break;
                 }
                 case 1:
                 {
-                  q->green=ScaleCharToQuantum(data);
+                  SetGreenPixelComponent(q,ScaleCharToQuantum(data));
                   break;
                 }
                 case 2:
                 {
-                  q->blue=ScaleCharToQuantum(data);
+                  SetBluePixelComponent(q,ScaleCharToQuantum(data));
                   break;
                 }
                 case 3:
                 {
-                  q->opacity=(Quantum) (data == 0 ? TransparentOpacity :
+                  SetOpacityPixelComponent(q,data == 0 ? TransparentOpacity :
                     ScaleCharToQuantum((unsigned char) (255-
                     inLayerInfo->opacity)));
                   break;
@@ -993,14 +992,12 @@
     i;
 
   size_t
+    image_type,
     length;
 
   ssize_t
     count;
 
-  size_t
-    image_type;
-
   XCFDocInfo
     doc_info;
 
diff --git a/coders/xpm.c b/coders/xpm.c
index ba657c2..bb94c6c 100644
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -225,10 +225,6 @@
   Image
     *image;
 
-  ssize_t
-    j,
-    y;
-
   MagickBooleanType
     active,
     status;
@@ -254,7 +250,9 @@
     *xpm_colors;
 
   ssize_t
-    count;
+    count,
+    j,
+    y;
 
   unsigned long
     colors,
@@ -408,7 +406,7 @@
           (void) CopyXPMColor(key,p,(size_t) width);
           j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
           if (image->storage_class == PseudoClass)
-            indexes[x]=(IndexPacket) j;
+            SetIndexPixelComponent(indexes+x,j);
           *r=image->colormap[j];
           r++;
           p+=width;
@@ -590,11 +588,6 @@
   ImageInfo
     *blob_info;
 
-  ssize_t
-    j,
-    k,
-    y;
-
   MagickBooleanType
     status,
     transparent;
@@ -625,6 +618,11 @@
     characters_per_pixel,
     colors;
 
+  ssize_t
+    j,
+    k,
+    y;
+
   /*
     Open output image file.
   */
@@ -718,7 +716,7 @@
         for (x=0; x < (ssize_t) picon->columns; x++)
         {
           if (q->opacity == (Quantum) TransparentOpacity)
-            indexes[x]=(IndexPacket) picon->colors;
+            SetIndexPixelComponent(indexes+x,picon->colors);
           q++;
         }
         if (SyncAuthenticPixels(picon,exception) == MagickFalse)
@@ -789,11 +787,11 @@
     (void) WriteBlobString(image,"\"");
     for (x=0; x < (ssize_t) picon->columns; x++)
     {
-      k=((ssize_t) indexes[x] % MaxCixels);
+      k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
       symbol[0]=Cixel[k];
       for (j=1; j < (ssize_t) characters_per_pixel; j++)
       {
-        k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+        k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
         symbol[j]=Cixel[k];
       }
       symbol[j]='\0';
@@ -852,12 +850,6 @@
     name[MaxTextExtent],
     symbol[MaxTextExtent];
 
-  ssize_t
-    j,
-    k,
-    opacity,
-    y;
-
   MagickBooleanType
     status;
 
@@ -877,6 +869,12 @@
   size_t
     characters_per_pixel;
 
+  ssize_t
+    j,
+    k,
+    opacity,
+    y;
+
   /*
     Open output image file.
   */
@@ -1020,11 +1018,11 @@
     (void) WriteBlobString(image,"\"");
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      k=((ssize_t) indexes[x] % MaxCixels);
+      k=((ssize_t) GetIndexPixelComponent(indexes+x) % MaxCixels);
       symbol[0]=Cixel[k];
       for (j=1; j < (ssize_t) characters_per_pixel; j++)
       {
-        k=(((int) indexes[x]-k)/MaxCixels) % MaxCixels;
+        k=(((int) GetIndexPixelComponent(indexes+x)-k)/MaxCixels) % MaxCixels;
         symbol[j]=Cixel[k];
       }
       symbol[j]='\0';
diff --git a/coders/xps.c b/coders/xps.c
index 8a8ffa1..85c84dc 100644
--- a/coders/xps.c
+++ b/coders/xps.c
@@ -140,13 +140,13 @@
   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)
diff --git a/coders/xwd.c b/coders/xwd.c
index e00c1b3..7a83581 100644
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -162,9 +162,6 @@
   int
     x_status;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     authentic_colormap;
 
@@ -187,13 +184,12 @@
     pixel;
 
   size_t
-    length;
+    length,
+    lsb_first;
 
   ssize_t
-    count;
-
-  size_t
-    lsb_first;
+    count,
+    y;
 
   XColor
     *colors;
@@ -409,17 +405,20 @@
             {
               pixel=XGetPixel(ximage,(int) x,(int) y);
               index=(IndexPacket) ((pixel >> red_shift) & red_mask);
-              q->red=ScaleShortToQuantum(colors[(ssize_t) index].red);
+              SetRedPixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+                index].red));
               index=(IndexPacket) ((pixel >> green_shift) & green_mask);
-              q->green=ScaleShortToQuantum(colors[(ssize_t) index].green);
+              SetGreenPixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+                index].green));
               index=(IndexPacket) ((pixel >> blue_shift) & blue_mask);
-              q->blue=ScaleShortToQuantum(colors[(ssize_t) index].blue);
+              SetBluePixelComponent(q,ScaleShortToQuantum(colors[(ssize_t)
+                index].blue));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
             status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+              image->rows);
             if (status == MagickFalse)
               break;
           }
@@ -434,19 +433,22 @@
               pixel=XGetPixel(ximage,(int) x,(int) y);
               color=(pixel >> red_shift) & red_mask;
               color=(color*65535UL)/red_mask;
-              q->red=ScaleShortToQuantum((unsigned short) color);
+              SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+                color));
               color=(pixel >> green_shift) & green_mask;
               color=(color*65535UL)/green_mask;
-              q->green=ScaleShortToQuantum((unsigned short) color);
+              SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+                color));
               color=(pixel >> blue_shift) & blue_mask;
               color=(color*65535UL)/blue_mask;
-              q->blue=ScaleShortToQuantum((unsigned short) color);
+              SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+                color));
               q++;
             }
             if (SyncAuthenticPixels(image,exception) == MagickFalse)
               break;
             status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+              image->rows);
             if (status == MagickFalse)
               break;
           }
@@ -475,13 +477,15 @@
           {
             index=ConstrainColormapIndex(image,XGetPixel(ximage,(int) x,
               (int) y));
-            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 (SyncAuthenticPixels(image,exception) == MagickFalse)
             break;
           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
-                image->rows);
+            image->rows);
           if (status == MagickFalse)
             break;
         }
@@ -599,9 +603,6 @@
   const char
     *value;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -621,17 +622,18 @@
     *q;
 
   size_t
-    length;
+    bits_per_pixel,
+    bytes_per_line,
+    length,
+    lsb_first,
+    scanline_pad;
+
+  ssize_t
+    y;
 
   unsigned char
     *pixels;
 
-  size_t
-    bits_per_pixel,
-    bytes_per_line,
-    lsb_first,
-    scanline_pad;
-
   XWDFileHeader
     xwd_info;
 
@@ -782,7 +784,7 @@
       *q++='\0';
     (void) WriteBlob(image,(size_t) (q-pixels),pixels);
     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
-                image->rows);
+      image->rows);
     if (status == MagickFalse)
       break;
   }
diff --git a/coders/ycbcr.c b/coders/ycbcr.c
index 2fe5acd..c596d24 100644
--- a/coders/ycbcr.c
+++ b/coders/ycbcr.c
@@ -102,9 +102,6 @@
     *canvas_image,
     *image;
 
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -127,12 +124,13 @@
   register PixelPacket
     *q;
 
-  ssize_t
-    count;
-
   size_t
     length;
 
+  ssize_t
+    count,
+    y;
+
   unsigned char
     *pixels;
 
@@ -957,9 +955,6 @@
 static MagickBooleanType WriteYCBCRImage(const ImageInfo *image_info,
   Image *image)
 {
-  ssize_t
-    y;
-
   MagickBooleanType
     status;
 
@@ -975,12 +970,13 @@
   register const PixelPacket
     *p;
 
-  ssize_t
-    count;
-
   size_t
     length;
 
+  ssize_t
+    count,
+    y;
+
   unsigned char
     *pixels;
 
@@ -1036,8 +1032,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            quantum_type,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,quantum_type,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1061,18 +1057,18 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            RedQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,RedQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            GreenQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,GreenQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            BlueQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,BlueQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1104,8 +1100,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            RedQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,RedQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1121,8 +1117,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            GreenQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,GreenQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1138,8 +1134,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            BlueQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,BlueQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1191,8 +1187,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            RedQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,RedQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1214,8 +1210,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            GreenQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,GreenQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
@@ -1237,8 +1233,8 @@
           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
           if (p == (const PixelPacket *) NULL)
             break;
-          length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
-            BlueQuantum,pixels,&image->exception);
+          length=ExportQuantumPixels(image,(const CacheView *) NULL,
+            quantum_info,BlueQuantum,pixels,&image->exception);
           count=WriteBlob(image,length,pixels);
           if (count != (ssize_t) length)
             break;
diff --git a/coders/yuv.c b/coders/yuv.c
index b7aaa9a..0307377 100644
--- a/coders/yuv.c
+++ b/coders/yuv.c
@@ -105,11 +105,6 @@
   InterlaceType
     interlace;
 
-  ssize_t
-    horizontal_factor,
-    vertical_factor,
-    y;
-
   MagickBooleanType
     status;
 
@@ -126,10 +121,11 @@
     *p;
 
   ssize_t
-    quantum;
-
-  ssize_t
-    count;
+    count,
+    horizontal_factor,
+    quantum,
+    vertical_factor,
+    y;
 
   unsigned char
     *scanline;
@@ -257,11 +253,11 @@
                 q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
                 p+=2;
               }
-            q->green=(Quantum) 0;
-            q->blue=(Quantum) 0;
+            SetGreenPixelComponent(q,0);
+            SetBluePixelComponent(q,0);
             q++;
-            q->green=0;
-            q->blue=0;
+            SetGreenPixelComponent(q,0);
+            SetBluePixelComponent(q,0);
             if (quantum == 1)
               chroma_pixels->blue=ScaleCharToQuantum(*p++);
             else
@@ -273,7 +269,8 @@
               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
             else
               {
-                q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+                SetRedPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+                  *(p+1)));
                 p+=2;
               }
             chroma_pixels++;
@@ -294,11 +291,12 @@
               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
             else
               {
-                q->red=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+                SetRedPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+                  *(p+1)));
                 p+=2;
               }
-            q->green=0;
-            q->blue=0;
+            SetGreenPixelComponent(q,0);
+            SetBluePixelComponent(q,0);
             q++;
           }
         }
@@ -338,15 +336,16 @@
             break;
           for (x=0; x < (ssize_t) chroma_image->columns; x++)
           {
-            q->red=(Quantum) 0;
+            SetRedPixelComponent(q,0);
             if (quantum == 1)
               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
             else
               {
-                q->green=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+                SetGreenPixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+                  *(p+1)));
                 p+=2;
               }
-            q->blue=(Quantum) 0;
+            SetBluePixelComponent(q,0);
             q++;
           }
           if (SyncAuthenticPixels(chroma_image,exception) == MagickFalse)
@@ -377,7 +376,8 @@
             SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
           else
             {
-              q->blue=ScaleShortToQuantum(((*p) << 8) | *(p+1));
+              SetBluePixelComponent(q,ScaleShortToQuantum(((*p) << 8) |
+                *(p+1)));
               p+=2;
             }
           q++;
@@ -404,8 +404,8 @@
         break;
       for (x=0; x < (ssize_t) image->columns; x++)
       {
-        q->green=chroma_pixels->green;
-        q->blue=chroma_pixels->blue;
+        SetGreenPixelComponent(q,chroma_pixels->green);
+        SetBluePixelComponent(q,chroma_pixels->blue);
         chroma_pixels++;
         q++;
       }
@@ -554,11 +554,6 @@
   InterlaceType
     interlace;
 
-  ssize_t
-    horizontal_factor,
-    vertical_factor,
-    y;
-
   MagickBooleanType
     status;
 
@@ -577,6 +572,11 @@
     quantum,
     width;
 
+  ssize_t
+    horizontal_factor,
+    vertical_factor,
+    y;
+
   assert(image_info != (const ImageInfo *) NULL);
   assert(image_info->signature == MagickSignature);
   assert(image != (Image *) NULL);
@@ -668,21 +668,25 @@
           {
             if (quantum == 1)
               {
-                (void) WriteBlobByte(image,ScaleQuantumToChar(s->green));
+                (void) WriteBlobByte(image,ScaleQuantumToChar(
+                  GetGreenPixelComponent(s)));
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
                   GetRedPixelComponent(p)));
                 p++;
-                (void) WriteBlobByte(image,ScaleQuantumToChar(s->blue));
+                (void) WriteBlobByte(image,ScaleQuantumToChar(
+                  GetBluePixelComponent(s)));
                 (void) WriteBlobByte(image,ScaleQuantumToChar(
                   GetRedPixelComponent(p)));
               }
             else
               {
-                (void) WriteBlobShort(image,ScaleQuantumToShort(s->green));
+                (void) WriteBlobByte(image,ScaleQuantumToChar(
+                  GetGreenPixelComponent(s)));
                 (void) WriteBlobShort(image,ScaleQuantumToShort(
                   GetRedPixelComponent(p)));
                 p++;
-                (void) WriteBlobShort(image,ScaleQuantumToShort(s->blue));
+                (void) WriteBlobByte(image,ScaleQuantumToChar(
+                  GetBluePixelComponent(s)));
                 (void) WriteBlobShort(image,ScaleQuantumToShort(
                   GetRedPixelComponent(p)));
               }