(no commit message)

[imagemagick] / magick / quantum-import.c

diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index a7f35a954d0ec943c6c80aaaa2763b69674e2193..80602b0047976bf28e311b284a3c10289ba71b2a 100644 (file)
--- a/magick/quantum-import.c
+++ b/magick/quantum-import.c
@@ -111,7 +111,7 @@
 */
 
 static inline IndexPacket PushColormapIndex(Image *image,
-  const unsigned long index,MagickBooleanType *range_exception)
+  const size_t index,MagickBooleanType *range_exception)
 {
   if (index < image->colors)
     return((IndexPacket) index);
@@ -192,59 +192,60 @@ static inline const unsigned char *PushFloatPixel(
 }
 
 static inline const unsigned char *PushQuantumPixel(
-  QuantumState *quantum_state,const unsigned long depth,
-  const unsigned char *pixels,unsigned long *quantum)
+  QuantumState *quantum_state,const size_t depth,
+  const unsigned char *pixels,unsigned int *quantum)
 {
-  register long
+  register ssize_t
     i;
 
-  register unsigned long
+  register size_t
     quantum_bits;
 
   *quantum=(QuantumAny) 0;
-  for (i=(long) depth; i > 0L; )
+  for (i=(ssize_t) depth; i > 0L; )
   {
     if (quantum_state->bits == 0UL)
       {
         quantum_state->pixel=(*pixels++);
         quantum_state->bits=8UL;
       }
-    quantum_bits=(unsigned long) i;
+    quantum_bits=(size_t) i;
     if (quantum_bits > quantum_state->bits)
       quantum_bits=quantum_state->bits;
-    i-=quantum_bits;
+    i-=(ssize_t) quantum_bits;
     quantum_state->bits-=quantum_bits;
-    *quantum=(*quantum << quantum_bits) | ((quantum_state->pixel >>
-      quantum_state->bits) &~ ((~0UL) << quantum_bits));
+    *quantum=(unsigned int) ((*quantum << quantum_bits) |
+      ((quantum_state->pixel >> quantum_state->bits) &~ ((~0UL) <<
+      quantum_bits)));
   }
   return(pixels);
 }
 
 static inline const unsigned char *PushQuantumLongPixel(
-  QuantumState *quantum_state,const unsigned long depth,
-  const unsigned char *pixels,unsigned long *quantum)
+  QuantumState *quantum_state,const size_t depth,
+  const unsigned char *pixels,unsigned int *quantum)
 {
-  register long
+  register ssize_t
     i;
 
-  register unsigned long
+  register size_t
     quantum_bits;
 
   *quantum=0UL;
-  for (i=(long) depth; i > 0; )
+  for (i=(ssize_t) depth; i > 0; )
   {
     if (quantum_state->bits == 0)
       {
         pixels=PushLongPixel(quantum_state->endian,pixels,
           &quantum_state->pixel);
-        quantum_state->bits=32UL;
+        quantum_state->bits=32U;
       }
-    quantum_bits=(unsigned long) i;
+    quantum_bits=(size_t) i;
     if (quantum_bits > quantum_state->bits)
       quantum_bits=quantum_state->bits;
-    *quantum|=(((quantum_state->pixel >> (32UL-quantum_state->bits)) &
+    *quantum|=(((quantum_state->pixel >> (32U-quantum_state->bits)) &
       quantum_state->mask[quantum_bits]) << (depth-i));
-    i-=quantum_bits;
+    i-=(ssize_t) quantum_bits;
     quantum_state->bits-=quantum_bits;
   }
   return(pixels);
@@ -257,9 +258,6 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
   EndianType
     endian;
 
-  long
-    bit;
-
   MagickSizeType
     number_pixels;
 
@@ -275,7 +273,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
   register IndexPacket
     *restrict indexes;
 
-  register long
+  register ssize_t
     x;
 
   register PixelPacket
@@ -284,7 +282,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
   size_t
     extent;
 
-  unsigned long
+  ssize_t
+    bit;
+
+  unsigned int
     pixel;
 
   assert(image != (Image *) NULL);
@@ -333,7 +334,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           register unsigned char
             pixel;
 
-          for (x=0; x < ((long) number_pixels-7); x+=8)
+          for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
           {
             for (bit=0; bit < 8; bit++)
             {
@@ -343,13 +344,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               else
                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                   0x00 : 0x01);
-              indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
-              *q=image->colormap[(long) indexes[x+bit]];
+              SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,
+                pixel,&range_exception));
+              SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                GetIndexPixelComponent(indexes+x+bit));
               q++;
             }
             p++;
           }
-          for (bit=0; bit < (long) (number_pixels % 8); bit++)
+          for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
           {
             if (quantum_info->min_is_white == MagickFalse)
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
@@ -357,8 +360,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             else
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                 0x00 : 0x01);
-            indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x+bit]];
+            SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x+bit));
             q++;
           }
           break;
@@ -368,23 +373,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           register unsigned char
             pixel;
 
-          for (x=0; x < ((long) number_pixels-1); x+=2)
+          for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             q++;
             pixel=(unsigned char) ((*p) & 0xf);
-            indexes[x+1]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x+1]];
+            SetIndexPixelComponent(indexes+x+1,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x+1));
             p++;
             q++;
           }
-          for (bit=0; bit < (long) (number_pixels % 2); bit++)
+          for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
           {
             pixel=(unsigned char) ((*p++ >> 4) & 0xf);
-            indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x+bit]];
+            SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x+bit));
             q++;
           }
           break;
@@ -394,11 +405,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -411,23 +424,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel)),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -435,7 +451,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -443,22 +459,25 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -471,12 +490,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -485,11 +505,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         default:
         {
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -520,7 +542,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           register unsigned char
             pixel;
 
-          for (x=0; x < ((long) number_pixels-3); x+=4)
+          for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
           {
             for (bit=0; bit < 8; bit+=2)
             {
@@ -530,16 +552,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               else
                 pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                   0x00 : 0x01);
-              indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
-              q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
-              q->green=q->red;
-              q->blue=q->red;
-              q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
-                == 0 ? TransparentOpacity : OpaqueOpacity);
+              SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
+              SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+              SetGreenPixelComponent(q,GetRedPixelComponent(q));
+              SetBluePixelComponent(q,GetRedPixelComponent(q));
+              SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+                (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
               q++;
             }
           }
-          for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
+          for (bit=0; bit < (ssize_t) (number_pixels % 4); bit+=2)
           {
             if (quantum_info->min_is_white == MagickFalse)
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) == 0 ?
@@ -547,12 +569,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             else
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                 0x00 : 0x01);
-            indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
-            q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
-            q->green=q->red;
-            q->blue=q->red;
-            q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) ==
-              0 ? TransparentOpacity : OpaqueOpacity);
+            SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
+            SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
+            SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+              (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
             q++;
           }
           break;
@@ -563,13 +585,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             pixel;
 
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             pixel=(unsigned char) ((*p) & 0xf);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p++;
             q++;
           }
@@ -580,13 +604,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -599,28 +625,31 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel)),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -628,7 +657,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -636,26 +665,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -668,14 +700,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(long) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -685,13 +718,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(long) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -703,6 +738,526 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
       break;
     }
+    case BGRQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            SetOpacityPixelComponent(q,OpaqueOpacity);
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushLongPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+                  range));
+                SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                  0x3ff,range));
+                SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+                  range));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 12:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              unsigned short
+                pixel;
+
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch (x % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+bit) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p++;
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRAQuantum:
+    case BGROQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          pixel=0;
+          if (quantum_info->pack == MagickFalse)
+            {
+              register ssize_t
+                i;
+
+              size_t
+                quantum;
+
+              ssize_t
+                n;
+
+              n=0;
+              quantum=0;
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                for (i=0; i < 4; i++)
+                {
+                  switch (n % 3)
+                  {
+                    case 0:
+                    {
+                      p=PushLongPixel(endian,p,&pixel);
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      break;
+                    }
+                    case 1:
+                    {
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      break;
+                    }
+                    case 2:
+                    {
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+                      break;
+                    }
+                  }
+                  switch (i)
+                  {
+                    case 0: SetRedPixelComponent(q,quantum); break;
+                    case 1: SetGreenPixelComponent(q,quantum); break;
+                    case 2: SetBluePixelComponent(q,quantum); break;
+                    case 3: SetAlphaPixelComponent(q,quantum); break;
+                  }
+                  n++;
+                }
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
     case GrayQuantum:
     {
       switch (quantum_info->depth)
@@ -720,22 +1275,24 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               black=(Quantum) QuantumRange;
               white=0;
             }
-          for (x=0; x < ((long) number_pixels-7); x+=8)
+          for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
           {
             for (bit=0; bit < 8; bit++)
             {
-              q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
-              q->green=q->red;
-              q->blue=q->red;
+              SetRedPixelComponent(q,((*p) & (1 << (7-bit))) == 0 ?
+                black : white);
+              SetGreenPixelComponent(q,GetRedPixelComponent(q));
+              SetBluePixelComponent(q,GetRedPixelComponent(q));
               q++;
             }
             p++;
           }
-          for (bit=0; bit < (long) (number_pixels % 8); bit++)
+          for (bit=0; bit < (ssize_t) (number_pixels % 8); bit++)
           {
-            q->red=(((*p) & (1 << (7-bit))) == 0 ? black : white);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,((*p) & (0x01 << (7-bit))) == 0 ?
+              black : white);
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
           }
           if (bit != 0)
@@ -748,26 +1305,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             pixel;
 
           range=GetQuantumRange(image->depth);
-          for (x=0; x < ((long) number_pixels-1); x+=2)
+          for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
             pixel=(unsigned char) ((*p) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p++;
             q++;
           }
-          for (bit=0; bit < (long) (number_pixels % 2); bit++)
+          for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
           {
             pixel=(unsigned char) (*p++ >> 4);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
           }
           break;
@@ -779,24 +1336,24 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->min_is_white != MagickFalse)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushCharPixel(p,&pixel);
-                q->red=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 SetOpacityPixelComponent(q,OpaqueOpacity);
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             SetOpacityPixelComponent(q,OpaqueOpacity);
             p+=quantum_info->pad;
             q++;
@@ -810,80 +1367,90 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             {
               if (image->endian != LSBEndian)
                 {
-                  for (x=0; x < (long) (number_pixels-2); x+=3)
+                  for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
                   {
                     p=PushLongPixel(endian,p,&pixel);
-                    q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     q++;
-                    q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     q++;
-                    q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     p+=quantum_info->pad;
                     q++;
                   }
                   p=PushLongPixel(endian,p,&pixel);
-                  if (x++ < (long) (number_pixels-1))
+                  if (x++ < (ssize_t) (number_pixels-1))
                     {
-                      q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
-                      q->green=q->red;
-                      q->blue=q->red;
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
                       q++;
                     }
-                  if (x++ < (long) number_pixels)
+                  if (x++ < (ssize_t) number_pixels)
                     {
-                      q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                      q->green=q->red;
-                      q->blue=q->red;
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
                       q++;
                     }
                   break;
                 }
-              for (x=0; x < (long) (number_pixels-2); x+=3)
+              for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
               {
                 p=PushLongPixel(endian,p,&pixel);
-                q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                  0x3ff,range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 q++;
-                q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                  0x3ff,range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 q++;
-                q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                  0x3ff,range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
               p=PushLongPixel(endian,p,&pixel);
-              if (x++ < (long) (number_pixels-1))
+              if (x++ < (ssize_t) (number_pixels-1))
                 {
-                  q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                  q->green=q->red;
-                  q->blue=q->red;
+                  SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                    0x3ff,range));
+                  SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                  SetBluePixelComponent(q,GetRedPixelComponent(q));
                   q++;
                 }
-              if (x++ < (long) number_pixels)
+              if (x++ < (ssize_t) number_pixels)
                 {
-                  q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                  q->green=q->red;
-                  q->blue=q->red;
+                  SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                    0x3ff,range));
+                  SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                  SetBluePixelComponent(q,GetRedPixelComponent(q));
                   q++;
                 }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -897,26 +1464,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               unsigned short
                 pixel;
 
-              for (x=0; x < (long) (number_pixels-1); x+=2)
+              for (x=0; x < (ssize_t) (number_pixels-1); x+=2)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                  (pixel >> 4),range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 q++;
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                  (pixel >> 4),range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
-              for (bit=0; bit < (long) (number_pixels % 2); bit++)
+              for (bit=0; bit < (ssize_t) (number_pixels % 2); bit++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                  (pixel >> 4),range));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -924,12 +1494,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                 p++;
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -942,12 +1512,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->min_is_white != MagickFalse)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,QuantumRange-ScaleShortToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -955,24 +1525,24 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             }
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -980,7 +1550,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -988,23 +1558,23 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -1017,12 +1587,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1032,12 +1602,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -1055,29 +1625,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           register unsigned char
             pixel;
 
-          for (x=0; x < ((long) number_pixels-3); x+=4)
+          for (x=0; x < ((ssize_t) number_pixels-3); x+=4)
           {
             for (bit=0; bit < 8; bit+=2)
             {
               pixel=(unsigned char)
                 (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
-              q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
-              q->green=q->red;
-              q->blue=q->red;
-              q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit)))
-                == 0 ? TransparentOpacity : OpaqueOpacity);
+              SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+              SetGreenPixelComponent(q,GetRedPixelComponent(q));
+              SetBluePixelComponent(q,GetRedPixelComponent(q));
+              SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+                (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
               q++;
             }
             p++;
           }
-          for (bit=0; bit < (long) (number_pixels % 4); bit+=2)
+          for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
           {
             pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
-            q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
-            q->green=q->red;
-            q->blue=q->red;
-            q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) == 0
-              ? TransparentOpacity : OpaqueOpacity);
+            SetRedPixelComponent(q,pixel != 0 ? 0 : QuantumRange);
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
+            SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+              (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
             q++;
           }
           if (bit != 0)
@@ -1090,14 +1660,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             pixel;
 
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             pixel=(unsigned char) ((*p) & 0xf);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p++;
             q++;
           }
@@ -1108,14 +1678,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1124,12 +1694,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         case 10:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
@@ -1140,12 +1710,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         case 12:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
@@ -1160,29 +1730,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1190,7 +1760,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1198,27 +1768,27 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1231,14 +1801,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1248,14 +1818,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1274,7 +1844,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -1290,17 +1860,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -1311,7 +1881,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1319,16 +1889,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -1344,10 +1914,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1357,7 +1927,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1379,7 +1949,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -1395,17 +1965,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -1416,7 +1986,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1424,16 +1994,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -1449,10 +2019,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1462,7 +2032,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1484,7 +2054,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
@@ -1500,17 +2070,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
@@ -1521,7 +2091,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1529,16 +2099,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
@@ -1554,10 +2124,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1567,7 +2137,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1588,10 +2158,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1604,20 +2174,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1625,7 +2195,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1633,19 +2203,19 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1658,10 +2228,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1671,10 +2241,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1698,10 +2268,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
           }
           break;
@@ -1713,26 +2283,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
           }
           break;
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1740,19 +2310,19 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1765,10 +2335,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1778,10 +2348,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=ScaleAnyToQuantum(pixel,range);
+            SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1800,7 +2370,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -1819,20 +2389,23 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           range=GetQuantumRange(image->depth);
           if (quantum_info->pack == MagickFalse)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushLongPixel(endian,p,&pixel);
-                q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                q->green=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                q->blue=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                  0x3ff,range));
+                SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                  0x3ff,range));
+                SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                  0x3ff,range));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          if (quantum_info->quantum == 32UL)
+          if (quantum_info->quantum == 32U)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1844,7 +2417,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1864,7 +2437,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               unsigned short
                 pixel;
 
-              for (x=0; x < (long) (3*number_pixels-1); x+=2)
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
               {
                 p=PushShortPixel(endian,p,&pixel);
                 switch (x % 3)
@@ -1872,17 +2445,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   default:
                   case 0:
                   {
-                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 1:
                   {
-                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 2:
                   {
-                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     q++;
                     break;
                   }
@@ -1893,24 +2469,27 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   default:
                   case 0:
                   {
-                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 1:
                   {
-                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 2:
                   {
-                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     q++;
                     break;
                   }
                 }
                 p+=quantum_info->pad;
               }
-              for (bit=0; bit < (long) (3*number_pixels % 2); bit++)
+              for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
               {
                 p=PushShortPixel(endian,p,&pixel);
                 switch ((x+bit) % 3)
@@ -1918,17 +2497,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   default:
                   case 0:
                   {
-                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 1:
                   {
-                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 2:
                   {
-                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     q++;
                     break;
                   }
@@ -1939,9 +2521,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                 p++;
               break;
             }
-          if (quantum_info->quantum == 32UL)
+          if (quantum_info->quantum == 32U)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
                 SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1953,7 +2535,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -1972,23 +2554,23 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -2003,7 +2585,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2011,20 +2593,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -2044,14 +2626,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2061,7 +2643,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -2087,7 +2669,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -2096,7 +2678,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2107,18 +2689,18 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           pixel=0;
           if (quantum_info->pack == MagickFalse)
             {
-              long
-                n;
-
-              register long
+              register ssize_t
                 i;
 
-              unsigned long
+              size_t
                 quantum;
 
+              ssize_t
+                n;
+
               n=0;
               quantum=0;
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 for (i=0; i < 4; i++)
                 {
@@ -2127,29 +2709,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                     case 0:
                     {
                       p=PushLongPixel(endian,p,&pixel);
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 22) & 0x3ff) << 6)));
                       break;
                     }
                     case 1:
                     {
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 12) & 0x3ff) << 6)));
                       break;
                     }
                     case 2:
                     {
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 2) & 0x3ff) << 6)));
                       break;
                     }
                   }
                   switch (i)
                   {
-                    case 0: q->red=(Quantum) (quantum); break;
-                    case 1: q->green=(Quantum) (quantum); break;
-                    case 2: q->blue=(Quantum) (quantum); break;
-                    case 3: q->opacity=(Quantum) (QuantumRange-quantum); break;
+                    case 0: SetRedPixelComponent(q,quantum); break;
+                    case 1: SetGreenPixelComponent(q,quantum); break;
+                    case 2: SetBluePixelComponent(q,quantum); break;
+                    case 3: SetAlphaPixelComponent(q,quantum); break;
                   }
                   n++;
                 }
@@ -2158,17 +2740,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->red=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
-              (unsigned short) (pixel << 6)));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
             q++;
           }
           break;
@@ -2180,26 +2765,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -2208,7 +2793,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2216,7 +2801,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2224,22 +2809,22 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -2248,7 +2833,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2261,16 +2846,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2280,7 +2865,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -2289,7 +2874,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2312,7 +2897,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -2321,7 +2906,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2334,26 +2919,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
+                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -2362,7 +2947,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2370,7 +2955,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2378,22 +2963,22 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -2402,7 +2987,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2415,16 +3000,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2434,7 +3019,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -2443,7 +3028,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=ScaleAnyToQuantum(pixel,range);
+            SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2467,7 +3052,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           unsigned char
             pixel;
 
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
@@ -2476,9 +3061,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2491,29 +3076,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
 
           if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
@@ -2522,9 +3107,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2532,7 +3117,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2540,24 +3125,24 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               float
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
               break;
             }
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
@@ -2566,9 +3151,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2581,18 +3166,18 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               double
                 pixel;
 
-              for (x=0; x < (long) number_pixels; x++)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
                 p+=quantum_info->pad;
                 q++;
@@ -2603,7 +3188,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -2612,9 +3197,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=ScaleAnyToQuantum(pixel,range);
+            SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2634,18 +3219,18 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           pixel=0;
           if (quantum_info->pack == MagickFalse)
             {
-              long
-                n;
-
-              register long
+              register ssize_t
                 i;
 
-              unsigned long
+              size_t
                 quantum;
 
+              ssize_t
+                n;
+
               n=0;
               quantum=0;
-              for (x=0; x < (long) number_pixels; x+=2)
+              for (x=0; x < (ssize_t) number_pixels; x+=2)
               {
                 for (i=0; i < 4; i++)
                 {
@@ -2654,20 +3239,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                     case 0:
                     {
                       p=PushLongPixel(endian,p,&pixel);
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 22) & 0x3ff) << 6)));
                       break;
                     }
                     case 1:
                     {
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 12) & 0x3ff) << 6)));
                       break;
                     }
                     case 2:
                     {
-                      quantum=(unsigned long) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 2) & 0x3ff) << 6)));
                       break;
                     }
                   }
@@ -2675,13 +3260,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   n++;
                 }
                 p+=quantum_info->pad;
-                q->red=cbcr[1];
-                q->green=cbcr[0];
-                q->blue=cbcr[2];
+                SetRedPixelComponent(q,cbcr[1]);
+                SetGreenPixelComponent(q,cbcr[0]);
+                SetBluePixelComponent(q,cbcr[2]);
                 q++;
-                q->red=cbcr[3];
-                q->green=cbcr[0];
-                q->blue=cbcr[2];
+                SetRedPixelComponent(q,cbcr[3]);
+                SetGreenPixelComponent(q,cbcr[0]);
+                SetBluePixelComponent(q,cbcr[2]);
                 q++;
               }
               break;
@@ -2690,7 +3275,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         default:
         {
           range=GetQuantumRange(image->depth);
-          for (x=0; x < (long) number_pixels; x++)
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
@@ -2717,11 +3302,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
       q=GetAuthenticPixelQueue(image);
       if (image_view != (CacheView *) NULL)
         q=GetCacheViewAuthenticPixelQueue(image_view);
-      for (x=0; x < (long) number_pixels; x++)
+      for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        quantum=q->red;
-        q->red=q->green;
-        q->green=quantum;
+        quantum=GetRedPixelComponent(q);
+        SetRedPixelComponent(q,GetGreenPixelComponent(q));
+        SetGreenPixelComponent(q,quantum);
         q++;
       }
     }
@@ -2733,9 +3318,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
       q=GetAuthenticPixelQueue(image);
       if (image_view != (CacheView *) NULL)
         q=GetCacheViewAuthenticPixelQueue(image_view);
-      for (x=0; x < (long) number_pixels; x++)
+      for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q->opacity=(Quantum) GetAlphaPixelComponent(q);
+        SetOpacityPixelComponent(q,GetAlphaPixelComponent(q));
         q++;
       }
     }
@@ -2753,13 +3338,16 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
       q=GetAuthenticPixelQueue(image);
       if (image_view != (CacheView *) NULL)
         q=GetCacheViewAuthenticPixelQueue(image_view);
-      for (x=0; x < (long) number_pixels; x++)
+      for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        alpha=QuantumScale*((MagickRealType) QuantumRange-q->opacity);
+        alpha=QuantumScale*GetAlphaPixelComponent(q);
         alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
-        q->red=ClampToQuantum(alpha*q->red);
-        q->green=ClampToQuantum(alpha*q->green);
-        q->blue=ClampToQuantum(alpha*q->blue);
+        SetRedPixelComponent(q,ClampToQuantum(alpha*
+          GetRedPixelComponent(q)));
+        SetGreenPixelComponent(q,ClampToQuantum(alpha*
+          GetGreenPixelComponent(q)));
+        SetBluePixelComponent(q,ClampToQuantum(alpha*
+          GetBluePixelComponent(q)));
         q++;
       }
     }