(no commit message)

[imagemagick] / magick / quantum-import.c

diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index 24663c66e84710e34bc60b67092021ff0abfddf6..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);
@@ -297,10 +298,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
     pixels=GetQuantumPixels(quantum_info);
   x=0;
   p=pixels;
-  number_pixels=GetImageExtent(image);
-  q=GetAuthenticPixelQueue(image);
-  indexes=GetAuthenticIndexQueue(image);
-  if (image_view != (CacheView *) NULL)
+  if (image_view == (CacheView *) NULL)
+    {
+      number_pixels=GetImageExtent(image);
+      q=GetAuthenticPixelQueue(image);
+      indexes=GetAuthenticIndexQueue(image);
+    }
+  else
     {
       number_pixels=GetCacheViewExtent(image_view);
       q=GetCacheViewAuthenticPixelQueue(image_view);
@@ -330,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++)
             {
@@ -340,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 ?
@@ -354,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;
@@ -365,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;
@@ -391,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++;
           }
@@ -408,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,RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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++;
           }
@@ -432,7 +451,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -440,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,RoundToQuantum(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++;
           }
@@ -468,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,RoundToQuantum(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++;
               }
@@ -482,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++;
           }
@@ -517,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)
             {
@@ -527,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 ?
@@ -544,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;
@@ -560,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++;
           }
@@ -577,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++;
           }
@@ -596,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,RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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-RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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++;
           }
@@ -625,7 +657,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -633,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,RoundToQuantum(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-RoundToQuantum(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++;
           }
@@ -665,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,RoundToQuantum(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-RoundToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -682,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++;
           }
@@ -700,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)
@@ -717,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)
@@ -745,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
             pixel=(unsigned char) ((*p) & 0xf);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
           }
           break;
@@ -776,25 +1336,25 @@ 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;
-                q->opacity=OpaqueOpacity;
+                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);
-            q->red=ScaleCharToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
-            q->opacity=OpaqueOpacity;
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
+            SetOpacityPixelComponent(q,OpaqueOpacity);
             p+=quantum_info->pad;
             q++;
           }
@@ -807,50 +1367,90 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             {
               if (image->endian != LSBEndian)
                 {
-                  for (x=0; x < (long) number_pixels/3; x++)
+                  for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
                   {
                     p=PushLongPixel(endian,p,&pixel);
-                    q->red=ScaleAnyToQuantum((pixel >> 0) & 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 >> 10) & 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 >> 20) & 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++ < (ssize_t) (number_pixels-1))
+                    {
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
+                      q++;
+                    }
+                  if (x++ < (ssize_t) number_pixels)
+                    {
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
+                      q++;
+                    }
                   break;
                 }
-              for (x=0; x < (long) number_pixels/3; x++)
+              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++ < (ssize_t) (number_pixels-1))
+                {
+                  SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                    0x3ff,range));
+                  SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                  SetBluePixelComponent(q,GetRedPixelComponent(q));
+                  q++;
+                }
+              if (x++ < (ssize_t) number_pixels)
+                {
+                  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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -864,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++;
               }
@@ -891,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -909,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++;
               }
@@ -922,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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->red=ScaleShortToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -947,7 +1550,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -955,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=RoundToQuantum(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);
-            q->red=ScaleLongToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -984,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=RoundToQuantum(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++;
               }
@@ -999,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -1022,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)
@@ -1057,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            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++;
           }
@@ -1075,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);
-            q->red=ScaleCharToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            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++;
           }
@@ -1091,14 +1694,14 @@ 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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=ScaleAnyToQuantum(pixel,range);
+            SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1107,14 +1710,14 @@ 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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=ScaleAnyToQuantum(pixel,range);
+            SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1127,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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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-RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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->red=ScaleShortToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            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++;
           }
@@ -1157,7 +1760,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1165,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=RoundToQuantum(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-RoundToQuantum(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->red=ScaleLongToQuantum(pixel);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            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++;
           }
@@ -1198,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=RoundToQuantum(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-RoundToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1215,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
-            q->green=q->red;
-            q->blue=q->red;
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            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++;
           }
@@ -1241,10 +1844,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->red=ScaleCharToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1257,20 +1860,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->red=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->red=ScaleShortToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1278,7 +1881,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1286,19 +1889,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->red=RoundToQuantum(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);
-            q->red=ScaleLongToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1311,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1324,10 +1927,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->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1346,10 +1949,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->green=ScaleCharToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1362,20 +1965,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->green=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->green=ScaleShortToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1383,7 +1986,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1391,19 +1994,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->green=RoundToQuantum(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);
-            q->green=ScaleLongToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1416,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=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1429,10 +2032,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->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1451,10 +2054,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->blue=ScaleCharToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1467,20 +2070,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->blue=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->blue=ScaleShortToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1488,7 +2091,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1496,19 +2099,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->blue=RoundToQuantum(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);
-            q->blue=ScaleLongToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1521,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=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1534,10 +2137,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->blue=ScaleAnyToQuantum(pixel,range);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1555,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++;
           }
@@ -1571,21 +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-RoundToQuantum(
-                  (MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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++;
           }
@@ -1593,7 +2195,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1601,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-RoundToQuantum(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++;
           }
@@ -1626,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-RoundToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1639,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++;
           }
@@ -1666,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;
@@ -1681,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]=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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)
@@ -1708,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]=RoundToQuantum(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++;
           }
@@ -1733,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]=RoundToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1746,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++;
           }
@@ -1768,15 +2370,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);
-            q->red=ScaleCharToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->green=ScaleCharToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->blue=ScaleCharToQuantum(pixel);
-            q->opacity=OpaqueOpacity;
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            SetOpacityPixelComponent(q,OpaqueOpacity);
             p+=quantum_info->pad;
             q++;
           }
@@ -1787,39 +2389,42 @@ 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);
-                q->red=ScaleAnyToQuantum(pixel,range);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
-                q->green=ScaleAnyToQuantum(pixel,range);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
-                q->blue=ScaleAnyToQuantum(pixel,range);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 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);
-            q->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -1832,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)
@@ -1840,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;
                   }
@@ -1861,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)
@@ -1886,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;
                   }
@@ -1907,28 +2521,28 @@ 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);
-                q->red=ScaleAnyToQuantum(pixel,range);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
-                q->green=ScaleAnyToQuantum(pixel,range);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
-                q->blue=ScaleAnyToQuantum(pixel,range);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
                 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);
-            q->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -1940,30 +2554,30 @@ 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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->red=ScaleShortToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->green=ScaleShortToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->blue=ScaleShortToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1971,7 +2585,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1979,27 +2593,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(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);
-            q->red=ScaleLongToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->green=ScaleLongToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->blue=ScaleLongToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2012,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2029,14 +2643,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2055,16 +2669,16 @@ 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->red=ScaleCharToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->green=ScaleCharToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->blue=ScaleCharToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2075,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++)
                 {
@@ -2095,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++;
                 }
@@ -2126,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;
@@ -2148,35 +2765,35 @@ 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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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->red=ScaleShortToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->green=ScaleShortToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->blue=ScaleShortToQuantum(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++;
           }
@@ -2184,7 +2801,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2192,31 +2809,31 @@ 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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(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->red=ScaleLongToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->green=ScaleLongToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->blue=ScaleLongToQuantum(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++;
           }
@@ -2229,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2248,16 +2865,16 @@ 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->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            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;
@@ -2280,16 +2897,16 @@ 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->red=ScaleCharToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->green=ScaleCharToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->blue=ScaleCharToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2302,35 +2919,35 @@ 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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(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);
-            q->red=ScaleShortToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->green=ScaleShortToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->blue=ScaleShortToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2338,7 +2955,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2346,31 +2963,31 @@ 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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) RoundToQuantum(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);
-            q->red=ScaleLongToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->green=ScaleLongToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->blue=ScaleLongToQuantum(pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2383,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2402,16 +3019,16 @@ 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->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            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;
@@ -2435,18 +3052,18 @@ 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->red=ScaleCharToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->green=ScaleCharToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->blue=ScaleCharToQuantum(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++;
           }
@@ -2459,40 +3076,40 @@ 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=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*
-                  ScaleHalfToFloat(pixel));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
+                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(
-                  (MagickRealType) QuantumRange*ScaleHalfToFloat(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->red=ScaleShortToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->green=ScaleShortToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->blue=ScaleShortToQuantum(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++;
           }
@@ -2500,7 +3117,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          unsigned long
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2508,35 +3125,35 @@ 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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(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->red=ScaleLongToQuantum(pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->green=ScaleLongToQuantum(pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->blue=ScaleLongToQuantum(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++;
           }
@@ -2549,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=RoundToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=RoundToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=RoundToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) RoundToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-RoundToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
                 p+=quantum_info->pad;
                 q++;
@@ -2571,18 +3188,18 @@ 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->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->blue=ScaleAnyToQuantum(pixel,range);
+            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;
@@ -2602,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++)
                 {
@@ -2622,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;
                     }
                   }
@@ -2643,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;
@@ -2658,12 +3275,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);
-            q->red=ScaleAnyToQuantum(pixel,range);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->green=ScaleAnyToQuantum(pixel,range);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2685,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++;
       }
     }
@@ -2701,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) (QuantumRange-q->opacity);
+        SetOpacityPixelComponent(q,GetAlphaPixelComponent(q));
         q++;
       }
     }
@@ -2721,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=RoundToQuantum(alpha*q->red);
-        q->green=RoundToQuantum(alpha*q->green);
-        q->blue=RoundToQuantum(alpha*q->blue);
+        SetRedPixelComponent(q,ClampToQuantum(alpha*
+          GetRedPixelComponent(q)));
+        SetGreenPixelComponent(q,ClampToQuantum(alpha*
+          GetGreenPixelComponent(q)));
+        SetBluePixelComponent(q,ClampToQuantum(alpha*
+          GetBluePixelComponent(q)));
         q++;
       }
     }