]> granicus.if.org Git - imagemagick/blobdiff - magick/quantum-export.c
projects / imagemagick / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[imagemagick] / magick / quantum-export.c
diff --git a/magick/quantum-export.c b/magick/quantum-export.c
index 3653f0551cba4471faaac97721a6ada52776616f..a3785592b06f81feeca146beae0071cce4b12883 100644 (file)
--- a/magick/quantum-export.c
+++ b/magick/quantum-export.c
@@ -240,9 +240,6 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
   EndianType
     endian;
 
-  ssize_t
-    bit;
-
   MagickRealType
     alpha;
 
@@ -270,6 +267,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
   size_t
     extent;
 
+  ssize_t
+    bit;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -310,7 +310,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         q++;
       }
     }
-  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+      (quantum_type == BGROQuantum))
     {
       register PixelPacket
         *restrict q;
@@ -482,7 +483,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,indexes[x],q);
             p++;
             q+=quantum_info->pad;
           }
@@ -510,25 +511,25 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           {
             pixel=(unsigned char) *indexes++;
             *q=((pixel & 0x01) << 7);
-            pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
               1 : 0);
             *q|=((pixel & 0x01) << 6);
             p++;
             pixel=(unsigned char) *indexes++;
             *q|=((pixel & 0x01) << 5);
-            pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
               1 : 0);
             *q|=((pixel & 0x01) << 4);
             p++;
             pixel=(unsigned char) *indexes++;
             *q|=((pixel & 0x01) << 3);
-            pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
               1 : 0);
             *q|=((pixel & 0x01) << 2);
             p++;
             pixel=(unsigned char) *indexes++;
             *q|=((pixel & 0x01) << 1);
-            pixel=(unsigned char) (p->opacity == (Quantum) TransparentOpacity ?
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum) TransparentOpacity ?
               1 : 0);
             *q|=((pixel & 0x01) << 0);
             p++;
@@ -541,7 +542,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
               {
                 pixel=(unsigned char) *indexes++;
                 *q|=((pixel & 0x01) << (unsigned char) (bit+4));
-                pixel=(unsigned char) (p->opacity == (Quantum)
+                pixel=(unsigned char) (GetOpacityPixelComponent(p) == (Quantum)
                   TransparentOpacity ? 1 : 0);
                 *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
                 p++;
@@ -663,12 +664,535 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,indexes[x],q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 10:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
+                  ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
+                  ScaleQuantumToAny(GetBluePixelComponent(p),range) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 12:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+              {
+                switch (x % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=quantum_info->pad;
+              }
+              for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+              {
+                switch ((x+bit) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p++;
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetBluePixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetGreenPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetRedPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRAQuantum:
+    case BGROQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 10:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              register ssize_t
+                i;
+
+              size_t
+                quantum;
+
+              ssize_t
+                n;
+
+              n=0;
+              quantum=0;
+              pixel=0;
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                for (i=0; i < 4; i++)
+                {
+                  switch (i)
+                  {
+                    case 0: quantum=GetRedPixelComponent(p); break;
+                    case 1: quantum=GetGreenPixelComponent(p); break;
+                    case 2: quantum=GetBluePixelComponent(p); break;
+                    case 3: quantum=(Quantum) (QuantumRange-GetOpacityPixelComponent(p)); break;
+                  }
+                  switch (n % 3)
+                  {
+                    case 0:
+                    {
+                      pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+                        range) << 22);
+                      break;
+                    }
+                    case 1:
+                    {
+                      pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+                        range) << 12);
+                      break;
+                    }
+                    case 2:
+                    {
+                      pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+                        range) << 2);
+                      q=PopLongPixel(endian,pixel,q);
+                      pixel=0;
+                      break;
+                    }
+                  }
+                  n++;
+                }
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+                  GetOpacityPixelComponent(p)),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+              GetOpacityPixelComponent(p)),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetBluePixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetGreenPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetRedPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetAlphaPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
+                pixel=(float) GetAlphaPixelComponent(p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
+                pixel=(double) GetAlphaPixelComponent(p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,indexes[x],q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              (Quantum) (GetAlphaPixelComponent(p)),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -772,7 +1296,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         case 10:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           if (quantum_info->pack == MagickFalse)
             {
               register unsigned int
@@ -800,8 +1324,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              PixelIntensityToQuantum(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -812,7 +1336,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           register unsigned short
             pixel;
 
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           if (quantum_info->pack == MagickFalse)
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
@@ -826,8 +1350,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              PixelIntensityToQuantum(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -906,11 +1430,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              PixelIntensityToQuantum(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -945,20 +1469,20 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           {
             *q='\0';
             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 7;
-            pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
-            *q|=(((int) pixel != 0 ? black : white) << 6);
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
             p++;
             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 5;
-            pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
-            *q|=(((int) pixel != 0 ? black : white) << 4);
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
             p++;
             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 3;
-            pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
-            *q|=(((int) pixel != 0 ? black : white) << 2);
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
             p++;
             *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) << 1;
-            pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 : 0x01);
-            *q|=(((int) pixel != 0 ? black : white) << 0);
+            pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
             p++;
             q++;
           }
@@ -969,9 +1493,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
               {
                 *q|=(PixelIntensityToQuantum(p) > threshold ? black : white) <<
                   (7-bit);
-                pixel=(unsigned char) (p->opacity == OpaqueOpacity ? 0x00 :
+                pixel=(unsigned char) (GetOpacityPixelComponent(p) == OpaqueOpacity ? 0x00 :
                   0x01);
-                *q|=(((int) pixel != 0 ? black : white) << (unsigned char)
+                *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
                   (7-bit-1));
                 p++;
               }
@@ -1099,13 +1623,13 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              PixelIntensityToQuantum(p),range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              (Quantum) (GetAlphaPixelComponent(p)),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(PixelIntensityToQuantum(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1168,7 +1692,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->red,q);
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1189,7 +1713,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->red,q);
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1198,11 +1722,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->red,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1265,7 +1789,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->green,q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1286,7 +1810,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->green,q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1295,11 +1819,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->green,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1362,7 +1886,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1383,7 +1907,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1392,11 +1916,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->blue,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1499,11 +2023,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              (Quantum) (GetAlphaPixelComponent(p)),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) (GetAlphaPixelComponent(p)),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1565,7 +2089,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->opacity,q);
+                q=PopFloatPixel(&quantum_state,(float) GetOpacityPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1586,7 +2110,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->opacity,q);
+                q=PopDoublePixel(&quantum_state,(double) GetOpacityPixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1595,11 +2119,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->opacity,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1696,11 +2220,11 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              (Quantum) indexes[x],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) indexes[x],range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1731,14 +2255,14 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           register unsigned int
             pixel;
 
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           if (quantum_info->pack == MagickFalse)
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
-                  ScaleQuantumToAny(p->green,range) << 12 |
-                  ScaleQuantumToAny(p->blue,range) << 2);
+                pixel=(unsigned int) (ScaleQuantumToAny(GetRedPixelComponent(p),range) << 22 |
+                  ScaleQuantumToAny(GetGreenPixelComponent(p),range) << 12 |
+                  ScaleQuantumToAny(GetBluePixelComponent(p),range) << 2);
                 q=PopLongPixel(endian,pixel,q);
                 p++;
                 q+=quantum_info->pad;
@@ -1749,12 +2273,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1762,12 +2289,12 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1778,7 +2305,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           register unsigned int
             pixel;
 
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           if (quantum_info->pack == MagickFalse)
             {
               for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
@@ -1788,17 +2315,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
                     p++;
                     break;
                   }
@@ -1809,17 +2336,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
                     p++;
                     break;
                   }
@@ -1834,17 +2361,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                   default:
                   case 0:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
                     break;
                   }
                   case 1:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
                     break;
                   }
                   case 2:
                   {
-                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
                     p++;
                     break;
                   }
@@ -1860,12 +2387,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1873,12 +2403,12 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             p++;
             q+=quantum_info->pad;
           }
@@ -1929,9 +2459,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->red,q);
-                q=PopFloatPixel(&quantum_state,(float) p->green,q);
-                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1956,9 +2486,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->red,q);
-                q=PopDoublePixel(&quantum_state,(double) p->green,q);
-                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -1967,15 +2497,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->red,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->green,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->blue,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2015,18 +2545,18 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
           register unsigned int
             pixel;
 
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           if (quantum_info->pack == MagickFalse)
             {
-              ssize_t
-                n;
-
               register ssize_t
                 i;
 
               size_t
                 quantum;
 
+              ssize_t
+                n;
+
               n=0;
               quantum=0;
               pixel=0;
@@ -2036,10 +2566,10 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                 {
                   switch (i)
                   {
-                    case 0: quantum=p->red; break;
-                    case 1: quantum=p->green; break;
-                    case 2: quantum=p->blue; break;
-                    case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
+                    case 0: quantum=GetRedPixelComponent(p); break;
+                    case 1: quantum=GetGreenPixelComponent(p); break;
+                    case 2: quantum=GetBluePixelComponent(p); break;
+                    case 3: quantum=(Quantum) (QuantumRange-GetOpacityPixelComponent(p)); break;
                   }
                   switch (n % 3)
                   {
@@ -2075,15 +2605,19 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
-                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
-                  p->opacity),range);
-                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                  GetOpacityPixelComponent(p)),range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 p++;
                 q+=quantum_info->pad;
               }
@@ -2091,15 +2625,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetRedPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetGreenPixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetBluePixelComponent(p),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
-              p->opacity),range);
-            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+              GetOpacityPixelComponent(p)),range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2158,9 +2692,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                 float
                   pixel;
 
-                q=PopFloatPixel(&quantum_state,(float) p->red,q);
-                q=PopFloatPixel(&quantum_state,(float) p->green,q);
-                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
                 pixel=(float) GetAlphaPixelComponent(p);
                 q=PopFloatPixel(&quantum_state,pixel,q);
                 p++;
@@ -2192,9 +2726,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
 
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->red,q);
-                q=PopDoublePixel(&quantum_state,(double) p->green,q);
-                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
                 pixel=(double) GetAlphaPixelComponent(p);
                 q=PopDoublePixel(&quantum_state,pixel,q);
                 p++;
@@ -2205,17 +2739,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              GetRedPixelComponent(p),range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              GetGreenPixelComponent(p),range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              GetBluePixelComponent(p),range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              (Quantum) GetAlphaPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) GetAlphaPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2303,9 +2837,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopFloatPixel(&quantum_state,(float) p->red,q);
-                q=PopFloatPixel(&quantum_state,(float) p->green,q);
-                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
                 p++;
                 q+=quantum_info->pad;
@@ -2333,9 +2867,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
             {
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->red,q);
-                q=PopDoublePixel(&quantum_state,(double) p->green,q);
-                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
                 p++;
                 q+=quantum_info->pad;
@@ -2345,17 +2879,17 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->red,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->green,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->blue,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              indexes[x],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2456,9 +2990,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
                 float
                   pixel;
 
-                q=PopFloatPixel(&quantum_state,(float) p->red,q);
-                q=PopFloatPixel(&quantum_state,(float) p->green,q);
-                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                q=PopFloatPixel(&quantum_state,(float) GetRedPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetGreenPixelComponent(p),q);
+                q=PopFloatPixel(&quantum_state,(float) GetBluePixelComponent(p),q);
                 q=PopFloatPixel(&quantum_state,(float) indexes[x],q);
                 pixel=(float) (GetAlphaPixelComponent(p));
                 q=PopFloatPixel(&quantum_state,pixel,q);
@@ -2494,9 +3028,9 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
 
               for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                q=PopDoublePixel(&quantum_state,(double) p->red,q);
-                q=PopDoublePixel(&quantum_state,(double) p->green,q);
-                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                q=PopDoublePixel(&quantum_state,(double) GetRedPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetGreenPixelComponent(p),q);
+                q=PopDoublePixel(&quantum_state,(double) GetBluePixelComponent(p),q);
                 q=PopDoublePixel(&quantum_state,(double) indexes[x],q);
                 pixel=(double) (GetAlphaPixelComponent(p));
                 q=PopDoublePixel(&quantum_state,pixel,q);
@@ -2508,19 +3042,19 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         }
         default:
         {
-          range=GetQuantumRange(image->depth);
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->red,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->green,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->blue,range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              indexes[x],range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              p->opacity,range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetBluePixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetIndexPixelComponent(indexes+x),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetOpacityPixelComponent(p),range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2531,9 +3065,6 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
     }
     case CbYCrYQuantum:
     {
-     ssize_t
-        n;
-
       Quantum
         cbcr[4];
 
@@ -2546,9 +3077,12 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
       size_t
         quantum;
 
+     ssize_t
+        n;
+
       n=0;
       quantum=0;
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       switch (quantum_info->depth)
       {
         case 10:
@@ -2623,19 +3157,19 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
               cbcr[i]=(Quantum) quantum;
               n++;
             }
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[1],range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[0],range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[2],range),q);
-            p++;
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[3],range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[0],range),q);
-            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
-              cbcr[2],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[1],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[0],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[2],range),q);
+            p++;
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[3],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[0],range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(cbcr[2],range),q);
             p++;
             q+=quantum_info->pad;
           }
@@ -2666,7 +3200,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         q++;
       }
     }
-  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+      (quantum_type == BGROQuantum))
     {
       register PixelPacket
         *restrict q;
Unnamed repository; edit this file 'description' to name the repository.