(no commit message)

[imagemagick] / magick / quantum-import.c

diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index 06a0097b3ad2802ae6d8a2f992a5045c37afaa2c..80602b0047976bf28e311b284a3c10289ba71b2a 100644 (file)
--- a/magick/quantum-import.c
+++ b/magick/quantum-import.c
@@ -193,7 +193,7 @@ static inline const unsigned char *PushFloatPixel(
 
 static inline const unsigned char *PushQuantumPixel(
   QuantumState *quantum_state,const size_t depth,
-  const unsigned char *pixels,size_t *quantum)
+  const unsigned char *pixels,unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -212,17 +212,18 @@ static inline const unsigned char *PushQuantumPixel(
     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 size_t depth,
-  const unsigned char *pixels,size_t *quantum)
+  const unsigned char *pixels,unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -237,14 +238,14 @@ static inline const unsigned char *PushQuantumLongPixel(
       {
         pixels=PushLongPixel(quantum_state->endian,pixels,
           &quantum_state->pixel);
-        quantum_state->bits=32UL;
+        quantum_state->bits=32U;
       }
     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;
 
-  ssize_t
-    bit;
-
   MagickSizeType
     number_pixels;
 
@@ -284,7 +282,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
   size_t
     extent;
 
-  size_t
+  ssize_t
+    bit;
+
+  unsigned int
     pixel;
 
   assert(image != (Image *) NULL);
@@ -343,8 +344,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[(ssize_t) indexes[x+bit]];
+              SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,
+                pixel,&range_exception));
+              SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                GetIndexPixelComponent(indexes+x+bit));
               q++;
             }
             p++;
@@ -357,8 +360,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             else
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                 0x00 : 0x01);
-            indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x+bit]];
+            SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x+bit));
             q++;
           }
           break;
@@ -371,20 +376,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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[(ssize_t) 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[(ssize_t) 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 < (ssize_t) (number_pixels % 2); bit++)
           {
             pixel=(unsigned char) ((*p++ >> 4) & 0xf);
-            indexes[x+bit]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x+bit]];
+            SetIndexPixelComponent(indexes+x+bit,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x+bit));
             q++;
           }
           break;
@@ -397,8 +408,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -414,10 +427,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) 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++;
               }
@@ -426,8 +440,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -435,7 +451,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -446,9 +462,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) 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++;
               }
@@ -457,8 +474,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -474,9 +493,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) 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++;
               }
@@ -488,8 +508,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p+=quantum_info->pad;
             q++;
           }
@@ -530,12 +552,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++;
             }
           }
@@ -547,12 +569,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             else
               pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ?
                 0x00 : 0x01);
-            indexes[x+bit/2]=(IndexPacket) (pixel == 0 ? 0 : 1);
-            q->red=(Quantum) (pixel == 0 ? 0 : QuantumRange);
-            q->green=q->red;
-            q->blue=q->red;
-            q->opacity=(Quantum) (((*p) & (1UL << (unsigned char) (6-bit))) ==
-              0 ? TransparentOpacity : OpaqueOpacity);
+            SetIndexPixelComponent(indexes+x+bit/2,pixel == 0 ? 0 : 1);
+            SetRedPixelComponent(q,pixel == 0 ? 0 : QuantumRange);
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
+            SetOpacityPixelComponent(q,((*p) & (1UL << (unsigned char)
+              (6-bit))) == 0 ? TransparentOpacity : OpaqueOpacity);
             q++;
           }
           break;
@@ -566,10 +588,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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[(ssize_t) 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++;
           }
@@ -583,10 +607,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushCharPixel(p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) 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++;
           }
@@ -602,13 +628,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel)),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -617,10 +644,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -628,7 +657,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -639,11 +668,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -652,10 +682,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=PushColormapIndex(image,pixel,&range_exception);
-            *q=image->colormap[(ssize_t) 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++;
           }
@@ -671,11 +703,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=PushColormapIndex(image,ClampToQuantum(pixel),
-                  &range_exception);
-                *q=image->colormap[(ssize_t) indexes[x]];
+                SetIndexPixelComponent(indexes+x,PushColormapIndex(image,
+                  ClampToQuantum(pixel),&range_exception));
+                SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+                  GetIndexPixelComponent(indexes+x));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -688,10 +721,12 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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[(ssize_t) indexes[x]];
+            SetIndexPixelComponent(indexes+x,PushColormapIndex(image,pixel,
+              &range_exception));
+            SetRGBOPixelComponents(q,image->colormap+(ssize_t)
+              GetIndexPixelComponent(indexes+x));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -703,6 +738,526 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
       break;
     }
+    case BGRQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            SetOpacityPixelComponent(q,OpaqueOpacity);
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushLongPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+                  range));
+                SetGreenPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                  0x3ff,range));
+                SetBluePixelComponent(q,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+                  range));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 12:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              unsigned short
+                pixel;
+
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch (x % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+bit) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 1:
+                  {
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    break;
+                  }
+                  case 2:
+                  {
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p++;
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRAQuantum:
+    case BGROQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          pixel=0;
+          if (quantum_info->pack == MagickFalse)
+            {
+              register ssize_t
+                i;
+
+              size_t
+                quantum;
+
+              ssize_t
+                n;
+
+              n=0;
+              quantum=0;
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                for (i=0; i < 4; i++)
+                {
+                  switch (n % 3)
+                  {
+                    case 0:
+                    {
+                      p=PushLongPixel(endian,p,&pixel);
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      break;
+                    }
+                    case 1:
+                    {
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      break;
+                    }
+                    case 2:
+                    {
+                      quantum=(size_t) (ScaleShortToQuantum(
+                        (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+                      break;
+                    }
+                  }
+                  switch (i)
+                  {
+                    case 0: SetRedPixelComponent(q,quantum); break;
+                    case 1: SetGreenPixelComponent(q,quantum); break;
+                    case 2: SetBluePixelComponent(q,quantum); break;
+                    case 3: SetAlphaPixelComponent(q,quantum); break;
+                  }
+                  n++;
+                }
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleShortToQuantum((unsigned short)
+              (pixel << 6)));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
     case GrayQuantum:
     {
       switch (quantum_info->depth)
@@ -724,18 +1279,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             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 < (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)
@@ -752,13 +1309,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
             pixel=(unsigned char) ((*p) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p++;
             q++;
           }
@@ -766,8 +1323,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             pixel=(unsigned char) (*p++ >> 4);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             q++;
           }
           break;
@@ -782,9 +1339,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushCharPixel(p,&pixel);
-                q->red=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,QuantumRange-ScaleCharToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 SetOpacityPixelComponent(q,OpaqueOpacity);
                 p+=quantum_info->pad;
                 q++;
@@ -795,8 +1352,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             SetOpacityPixelComponent(q,OpaqueOpacity);
             p+=quantum_info->pad;
             q++;
@@ -813,33 +1370,38 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
                   {
                     p=PushLongPixel(endian,p,&pixel);
-                    q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     q++;
-                    q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     q++;
-                    q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                    q->green=q->red;
-                    q->blue=q->red;
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                      0x3ff,range));
+                    SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                    SetBluePixelComponent(q,GetRedPixelComponent(q));
                     p+=quantum_info->pad;
                     q++;
                   }
                   p=PushLongPixel(endian,p,&pixel);
                   if (x++ < (ssize_t) (number_pixels-1))
                     {
-                      q->red=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
-                      q->green=q->red;
-                      q->blue=q->red;
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 2) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
                       q++;
                     }
                   if (x++ < (ssize_t) number_pixels)
                     {
-                      q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                      q->green=q->red;
-                      q->blue=q->red;
+                      SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                        0x3ff,range));
+                      SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                      SetBluePixelComponent(q,GetRedPixelComponent(q));
                       q++;
                     }
                   break;
@@ -847,33 +1409,38 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               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))
                 {
-                  q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
-                  q->green=q->red;
-                  q->blue=q->red;
+                  SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 22) &
+                    0x3ff,range));
+                  SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                  SetBluePixelComponent(q,GetRedPixelComponent(q));
                   q++;
                 }
               if (x++ < (ssize_t) number_pixels)
                 {
-                  q->red=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
-                  q->green=q->red;
-                  q->blue=q->red;
+                  SetRedPixelComponent(q,ScaleAnyToQuantum((pixel >> 12) &
+                    0x3ff,range));
+                  SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                  SetBluePixelComponent(q,GetRedPixelComponent(q));
                   q++;
                 }
               break;
@@ -882,8 +1449,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -900,23 +1467,26 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               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 < (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++;
               }
@@ -928,8 +1498,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -945,9 +1515,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               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++;
               }
@@ -958,10 +1528,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -971,8 +1541,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -980,7 +1550,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -991,9 +1561,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1003,8 +1573,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -1020,9 +1590,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1036,8 +1606,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p+=quantum_info->pad;
             q++;
           }
@@ -1061,23 +1631,23 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             {
               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 < (ssize_t) (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)
@@ -1094,10 +1664,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             pixel=(unsigned char) ((*p >> 4) & 0xf);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             pixel=(unsigned char) ((*p) & 0xf);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p++;
             q++;
           }
@@ -1112,10 +1682,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushCharPixel(p,&pixel);
             SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1128,8 +1698,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
@@ -1144,8 +1714,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetOpacityPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
@@ -1163,13 +1733,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1179,10 +1749,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushShortPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1190,7 +1760,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1201,11 +1771,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1215,10 +1785,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushLongPixel(endian,p,&pixel);
             SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1234,11 +1804,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
-                q->green=q->red;
-                q->blue=q->red;
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
+                SetGreenPixelComponent(q,GetRedPixelComponent(q));
+                SetBluePixelComponent(q,GetRedPixelComponent(q));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1252,10 +1822,10 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           {
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
-            q->green=q->red;
-            q->blue=q->red;
+            SetGreenPixelComponent(q,GetRedPixelComponent(q));
+            SetBluePixelComponent(q,GetRedPixelComponent(q));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p+=quantum_info->pad;
             q++;
           }
@@ -1293,8 +1863,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1311,7 +1881,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1322,7 +1892,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1347,7 +1917,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1398,8 +1968,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1416,7 +1986,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1427,7 +1997,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1452,7 +2022,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1503,8 +2073,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1521,7 +2091,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1532,7 +2102,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1557,7 +2127,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1591,7 +2161,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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++;
           }
@@ -1607,8 +2177,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1617,7 +2187,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -1625,7 +2195,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1636,7 +2206,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1645,7 +2215,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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++;
           }
@@ -1661,7 +2231,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1674,7 +2244,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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++;
           }
@@ -1701,7 +2271,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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;
@@ -1716,8 +2286,8 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
               }
               break;
@@ -1725,14 +2295,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -1743,7 +2313,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1752,7 +2322,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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++;
           }
@@ -1768,7 +2338,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -1781,7 +2351,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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++;
           }
@@ -1822,15 +2392,18 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               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 < (ssize_t) number_pixels; x++)
               {
@@ -1872,17 +2445,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   default:
                   case 0:
                   {
-                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 1:
                   {
-                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 2:
                   {
-                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     q++;
                     break;
                   }
@@ -1893,17 +2469,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;
                   }
@@ -1918,17 +2497,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   default:
                   case 0:
                   {
-                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 1:
                   {
-                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     break;
                   }
                   case 2:
                   {
-                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny)
+                      (pixel >> 4),range));
                     q++;
                     break;
                   }
@@ -1939,7 +2521,7 @@ 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 < (ssize_t) number_pixels; x++)
               {
@@ -1975,14 +2557,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2003,7 +2585,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2014,11 +2596,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2047,11 +2629,11 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2096,7 +2678,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2107,15 +2689,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           pixel=0;
           if (quantum_info->pack == MagickFalse)
             {
-              ssize_t
-                n;
-
               register ssize_t
                 i;
 
               size_t
                 quantum;
 
+              ssize_t
+                n;
+
               n=0;
               quantum=0;
               for (x=0; x < (ssize_t) number_pixels; x++)
@@ -2127,29 +2709,29 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                     case 0:
                     {
                       p=PushLongPixel(endian,p,&pixel);
-                      quantum=(size_t) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 22) & 0x3ff) << 6)));
                       break;
                     }
                     case 1:
                     {
-                      quantum=(size_t) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 12) & 0x3ff) << 6)));
                       break;
                     }
                     case 2:
                     {
-                      quantum=(size_t) (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++;
                 }
@@ -2161,14 +2743,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           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;
@@ -2183,17 +2768,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
-                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2208,7 +2793,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2216,7 +2801,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2227,13 +2812,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2248,7 +2833,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2264,13 +2849,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2289,7 +2874,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2321,7 +2906,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2337,17 +2922,17 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
+                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2362,7 +2947,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2370,7 +2955,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2381,13 +2966,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2402,7 +2987,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2418,13 +3003,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2443,7 +3028,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=ScaleAnyToQuantum(pixel,range);
+            SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2476,9 +3061,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushCharPixel(p,&pixel);
             SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            indexes[x]=ScaleCharToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(pixel));
             p=PushCharPixel(p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleCharToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2494,20 +3079,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushShortPixel(endian,p,&pixel);
-                q->red=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
-                p=PushShortPixel(endian,p,&pixel);
-                q->green=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*
-                  HalfToSinglePrecision(pixel));
+                SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p=PushShortPixel(endian,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(
                   (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                p=PushShortPixel(endian,p,&pixel);
+                SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+                  QuantumRange*HalfToSinglePrecision(pixel)));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2522,9 +3107,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushShortPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            indexes[x]=ScaleShortToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(pixel));
             p=PushShortPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleShortToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2532,7 +3117,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         }
         case 32:
         {
-          size_t
+          unsigned int
             pixel;
 
           if (quantum_info->format == FloatingPointQuantumFormat)
@@ -2543,15 +3128,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushFloatPixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p+=quantum_info->pad;
                 q++;
               }
@@ -2566,9 +3151,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushLongPixel(endian,p,&pixel);
             SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            indexes[x]=ScaleLongToQuantum(pixel);
+            SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(pixel));
             p=PushLongPixel(endian,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            SetAlphaPixelComponent(q,ScaleLongToQuantum(pixel));
             p+=quantum_info->pad;
             q++;
           }
@@ -2584,15 +3169,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->red=ClampToQuantum(pixel);
+                SetRedPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->green=ClampToQuantum(pixel);
+                SetGreenPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->blue=ClampToQuantum(pixel);
+                SetBluePixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                indexes[x]=(IndexPacket) ClampToQuantum(pixel);
+                SetIndexPixelComponent(indexes+x,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
-                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                SetAlphaPixelComponent(q,ClampToQuantum(pixel));
                 p=PushDoublePixel(&quantum_state,p,&pixel);
                 p+=quantum_info->pad;
                 q++;
@@ -2612,9 +3197,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
             SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            indexes[x]=ScaleAnyToQuantum(pixel,range);
+            SetIndexPixelComponent(indexes+x,ScaleAnyToQuantum(pixel,range));
             p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
-            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            SetAlphaPixelComponent(q,ScaleAnyToQuantum(pixel,range));
             q++;
           }
           break;
@@ -2634,15 +3219,15 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           pixel=0;
           if (quantum_info->pack == MagickFalse)
             {
-              ssize_t
-                n;
-
               register ssize_t
                 i;
 
               size_t
                 quantum;
 
+              ssize_t
+                n;
+
               n=0;
               quantum=0;
               for (x=0; x < (ssize_t) number_pixels; x+=2)
@@ -2654,20 +3239,20 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                     case 0:
                     {
                       p=PushLongPixel(endian,p,&pixel);
-                      quantum=(size_t) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 22) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 22) & 0x3ff) << 6)));
                       break;
                     }
                     case 1:
                     {
-                      quantum=(size_t) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 12) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 12) & 0x3ff) << 6)));
                       break;
                     }
                     case 2:
                     {
-                      quantum=(size_t) (ScaleShortToQuantum(
-                        (unsigned short) (((pixel >> 2) & 0x3ff) << 6)));
+                      quantum=(size_t) (ScaleShortToQuantum((unsigned short)
+                        (((pixel >> 2) & 0x3ff) << 6)));
                       break;
                     }
                   }
@@ -2675,13 +3260,13 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
                   n++;
                 }
                 p+=quantum_info->pad;
-                q->red=cbcr[1];
-                q->green=cbcr[0];
-                q->blue=cbcr[2];
+                SetRedPixelComponent(q,cbcr[1]);
+                SetGreenPixelComponent(q,cbcr[0]);
+                SetBluePixelComponent(q,cbcr[2]);
                 q++;
-                q->red=cbcr[3];
-                q->green=cbcr[0];
-                q->blue=cbcr[2];
+                SetRedPixelComponent(q,cbcr[3]);
+                SetGreenPixelComponent(q,cbcr[0]);
+                SetBluePixelComponent(q,cbcr[2]);
                 q++;
               }
               break;
@@ -2719,9 +3304,9 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         q=GetCacheViewAuthenticPixelQueue(image_view);
       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++;
       }
     }
@@ -2735,7 +3320,7 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         q=GetCacheViewAuthenticPixelQueue(image_view);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q->opacity=(Quantum) GetAlphaPixelComponent(q);
+        SetOpacityPixelComponent(q,GetAlphaPixelComponent(q));
         q++;
       }
     }
@@ -2755,11 +3340,14 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
         q=GetCacheViewAuthenticPixelQueue(image_view);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        alpha=QuantumScale*((MagickRealType) QuantumRange-q->opacity);
+        alpha=QuantumScale*GetAlphaPixelComponent(q);
         alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
-        q->red=ClampToQuantum(alpha*q->red);
-        q->green=ClampToQuantum(alpha*q->green);
-        q->blue=ClampToQuantum(alpha*q->blue);
+        SetRedPixelComponent(q,ClampToQuantum(alpha*
+          GetRedPixelComponent(q)));
+        SetGreenPixelComponent(q,ClampToQuantum(alpha*
+          GetGreenPixelComponent(q)));
+        SetBluePixelComponent(q,ClampToQuantum(alpha*
+          GetBluePixelComponent(q)));
         q++;
       }
     }