From: cristy <urban-warrior@git.imagemagick.org>
Date: Fri, 6 Jan 2012 01:35:00 +0000 (+0000)
Subject: (no commit message)
X-Git-Tag: 7.0.1-0~6451
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=40ae80f228afbc5b9b7693135723e47bbb088ace;p=imagemagick

---

diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c
index 46c68be8f..fd8a70fce 100644
--- a/MagickCore/quantum-export.c
+++ b/MagickCore/quantum-export.c
@@ -233,3257 +233,3068 @@ static inline unsigned char *PopQuantumLongPixel(QuantumState *quantum_state,
   return(pixels);
 }
 
-static void ExportAlphaQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
+MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
+  const QuantumInfo *quantum_info,const QuantumType quantum_type,
+  unsigned char *pixels,ExceptionInfo *exception)
 {
   EndianType
     endian;
 
+  MagickRealType
+    alpha;
+
+  MagickSizeType
+    number_pixels;
+
   QuantumAny
     range;
 
+  QuantumState
+    quantum_state;
+
+  register const Quantum
+    *restrict p;
+
   register ssize_t
     x;
 
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
+  register unsigned char
+    *restrict q;
 
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
+  size_t
+    channels,
+    extent;
+
+  ssize_t
+    bit;
+
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  assert(quantum_info != (QuantumInfo *) NULL);
+  assert(quantum_info->signature == MagickSignature);
+  if (pixels == (unsigned char *) NULL)
+    pixels=GetQuantumPixels(quantum_info);
+  if (image_view == (CacheView *) NULL)
+    {
+      number_pixels=GetImageExtent(image);
+      p=GetVirtualPixelQueue(image);
+      channels=GetPixelChannels(image);
     }
-    case 16:
+  else
     {
-      register unsigned short
-        pixel;
+      number_pixels=GetCacheViewExtent(image_view);
+      p=GetCacheViewVirtualPixelQueue(image_view);
+      channels=GetPixelChannels(image);
+    }
+  if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+    {
+      register Quantum
+        *restrict q;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
-        {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
-        }
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      /*
+        Associate alpha.
+      */
+      q=GetAuthenticPixelQueue(image);
+      if (image_view != (CacheView *) NULL)
+        q=GetCacheViewAuthenticPixelQueue(image_view);
+      for (x=0; x < (ssize_t) image->columns; x++)
       {
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
+        alpha=QuantumScale*GetPixelAlpha(image,q);
+        SetPixelRed(image,ClampToQuantum(alpha*GetPixelRed(image,q)),q);
+        SetPixelGreen(image,ClampToQuantum(alpha*GetPixelGreen(image,q)),q);
+        SetPixelBlue(image,ClampToQuantum(alpha*GetPixelBlue(image,q)),q);
+        q++;
       }
-      break;
     }
-    case 32:
+  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+      (quantum_type == BGROQuantum))
     {
-      register unsigned int
-        pixel;
+      register Quantum
+        *restrict q;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
-        {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelAlpha(image,p),q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
-        }
+      q=GetAuthenticPixelQueue(image);
+      if (image_view != (CacheView *) NULL)
+        q=GetCacheViewAuthenticPixelQueue(image_view);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
+        SetPixelAlpha(image,GetPixelAlpha(image,q),q);
+        q++;
       }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
-        {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelAlpha(image,p),q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
-        }
     }
-    default:
+  if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
     {
-      range=GetQuantumRange(quantum_info->depth);
+      Quantum
+        quantum;
+
+      register Quantum
+        *restrict q;
+
+      q=GetAuthenticPixelQueue(image);
+      if (image_view != (CacheView *) NULL)
+        q=GetAuthenticPixelQueue(image);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
+        quantum=GetPixelRed(image,q);
+        SetPixelRed(image,GetPixelGreen(image,q),q);
+        SetPixelGreen(image,quantum,q);
+        q+=channels;
       }
-      break;
     }
-  }
-}
-
-static void ExportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
-  QuantumState quantum_state,const MagickSizeType number_pixels,
-  const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  ssize_t
-    bit;
-
+  x=0;
+  q=pixels;
+  InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+  extent=GetQuantumExtent(image,quantum_info,quantum_type);
   endian=quantum_state.endian;
-  switch (quantum_info->depth)
+  switch (quantum_type)
   {
-    case 8:
+    case IndexQuantum:
     {
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      if (image->storage_class != PseudoClass)
+        {
+          (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+            "ColormappedImageRequired","`%s'",image->filename);
+          return(extent);
+        }
+      switch (quantum_info->depth)
       {
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 10:
-    {
-      register unsigned int
-        pixel;
+        case 1:
+        {
+          register unsigned char
+            pixel;
 
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+          for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+          {
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q=((pixel & 0x01) << 7);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 6);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 5);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 4);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 3);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 2);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 1);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 0);
+            p+=channels;
+            q++;
+          }
+          if ((number_pixels % 8) != 0)
+            {
+              *q='\0';
+              for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+              {
+                pixel=(unsigned char) GetPixelIndex(image,p);
+                *q|=((pixel & 0x01) << (unsigned char) bit);
+                p+=channels;
+              }
+              q++;
+            }
+          break;
+        }
+        case 4:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
           {
-            pixel=(unsigned int) (
-              ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
-              ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
-              ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
-            q=PopLongPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q=((pixel & 0xf) << 4);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0xf) << 0);
+            p+=channels;
+            q++;
           }
+          if ((number_pixels % 2) != 0)
+            {
+              pixel=(unsigned char) GetPixelIndex(image,p);
+              *q=((pixel & 0xf) << 4);
+              p+=channels;
+              q++;
+            }
           break;
         }
-      if (quantum_info->quantum == 32UL)
+        case 8:
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-              range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 12:
-    {
-      register unsigned int
-        pixel;
-
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+        case 16:
         {
-          for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
-          {
-            switch (x % 3)
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              default:
-              case 0:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
-                  range);
-                break;
-              }
-              case 1:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-                  range);
-                break;
-              }
-              case 2:
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
-                  range);
-                p+=GetPixelChannels(image);
-                break;
+                q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
+                  GetPixelIndex(image,p)),q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
+              break;
             }
-            q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
-            switch ((x+1) % 3)
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              default:
-              case 0:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
-                  range);
-                break;
-              }
-              case 1:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-                  range);
-                break;
-              }
-              case 2:
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
-                  range);
-                p+=GetPixelChannels(image);
-                break;
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelIndex(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
+              break;
             }
-            q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
-          for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
-          {
-            switch ((x+bit) % 3)
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              default:
-              case 0:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
-                  range);
-                break;
-              }
-              case 1:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-                  range);
-                break;
-              }
-              case 2:
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
-                  range);
-                p+=GetPixelChannels(image);
-                break;
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelIndex(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
+              break;
             }
-            q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
-            q+=quantum_info->pad;
-          }
-          if (bit != 0)
-            p+=GetPixelChannels(image);
-          break;
         }
-      if (quantum_info->quantum == 32UL)
+        default:
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-              range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              GetPixelIndex(image,p),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 16:
+    case IndexAlphaQuantum:
     {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+      if (image->storage_class != PseudoClass)
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
+          (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+            "ColormappedImageRequired","`%s'",image->filename);
+          return(extent);
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      switch (quantum_info->depth)
       {
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
+        case 1:
+        {
+          register unsigned char
+            pixel;
+
+          for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+          {
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q=((pixel & 0x01) << 7);
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+              TransparentAlpha ? 1 : 0);
+            *q|=((pixel & 0x01) << 6);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 5);
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+              TransparentAlpha ? 1 : 0);
+            *q|=((pixel & 0x01) << 4);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 3);
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+              TransparentAlpha ? 1 : 0);
+            *q|=((pixel & 0x01) << 2);
+            p+=channels;
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q|=((pixel & 0x01) << 1);
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+              TransparentAlpha ? 1 : 0);
+            *q|=((pixel & 0x01) << 0);
+            p+=channels;
+            q++;
+          }
+          if ((number_pixels % 4) != 0)
+            {
+              *q='\0';
+              for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+              {
+                pixel=(unsigned char) GetPixelIndex(image,p);
+                *q|=((pixel & 0x01) << (unsigned char) (bit+4));
+                pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+                  TransparentAlpha ? 1 : 0);
+                *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
+                p+=channels;
+              }
+              q++;
+            }
+          break;
+        }
+        case 4:
+        {
+          register unsigned char
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          for (x=0; x < (ssize_t) number_pixels ; x++)
+          {
+            pixel=(unsigned char) GetPixelIndex(image,p);
+            *q=((pixel & 0xf) << 4);
+            pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+            *q|=((pixel & 0xf) << 0);
+            p+=channels;
+            q++;
+          }
+          break;
+        }
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
+            q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopShortPixel(endian,(unsigned short)
+                  GetPixelIndex(image,p),q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
+            q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
             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(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportBGRAQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
+        case 32:
+        {
+          register unsigned int
+            pixel;
 
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelRed(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelIndex(image,p),q);
+                pixel=(float)  GetPixelAlpha(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                double
+                  pixel;
+
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelIndex(image,p),q);
+                pixel=(double) GetPixelAlpha(image,p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                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,
+              GetPixelIndex(image,p),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
       }
       break;
     }
-    case 10:
+    case BGRQuantum:
     {
-      register unsigned int
-        pixel;
-
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+      switch (quantum_info->depth)
+      {
+        case 8:
         {
-          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++)
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 10:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
             {
-              switch (i)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                case 0: quantum=GetPixelRed(image,p); break;
-                case 1: quantum=GetPixelGreen(image,p); break;
-                case 2: quantum=GetPixelBlue(image,p); break;
-                case 3: quantum=GetPixelAlpha(image,p); break;
+                pixel=(unsigned int) (
+                  ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+                  ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+                  ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
-              switch (n % 3)
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                case 0:
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
+            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)
                 {
-                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
-                    range) << 22);
-                  break;
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    break;
+                  }
                 }
-                case 1:
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                switch ((x+1) % 3)
                 {
-                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
-                    range) << 12);
-                  break;
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    break;
+                  }
                 }
-                case 2:
+                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)
                 {
-                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
-                    range) << 2);
-                  q=PopLongPixel(endian,pixel,q);
-                  pixel=0;
-                  break;
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    break;
+                  }
                 }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=quantum_info->pad;
               }
-              n++;
+              if (bit != 0)
+                p+=channels;
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
             }
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
-        }
-      if (quantum_info->quantum == 32UL)
-        {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
               range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
               range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
+        case 32:
+        {
+          register unsigned int
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
+            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)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            pixel=(float) GetPixelAlpha(image,p);
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 64:
+    case BGRAQuantum:
+    case BGROQuantum:
     {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+      switch (quantum_info->depth)
+      {
+        case 8:
         {
-          double
+          register unsigned char
             pixel;
 
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            pixel=(double) GetPixelAlpha(image,p);
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             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(GetPixelBlue(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
+        case 10:
+        {
+          register unsigned int
+            pixel;
 
-static void ExportBlackQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              register ssize_t
+                i;
 
-  if (image->colorspace != CMYKColorspace)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","`%s'",image->filename);
-      return;
-    }
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
+              size_t
+                quantum;
 
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+              ssize_t
+                n;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
-        {
+              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=GetPixelRed(image,p); break;
+                    case 1: quantum=GetPixelGreen(image,p); break;
+                    case 2: quantum=GetPixelBlue(image,p); break;
+                    case 3: quantum=GetPixelAlpha(image,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+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                pixel=(float) GetPixelAlpha(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             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(GetPixelBlack(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportBlueQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                pixel=(double) GetPixelAlpha(image,p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 32:
+    case GrayQuantum:
     {
-      register unsigned int
-        pixel;
+      switch (quantum_info->depth)
+      {
+        case 1:
+        {
+          register Quantum
+            threshold;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          register unsigned char
+            black,
+            white;
+
+          black=0x00;
+          white=0x01;
+          if (quantum_info->min_is_white != MagickFalse)
+            {
+              black=0x01;
+              white=0x00;
+            }
+          threshold=(Quantum) (QuantumRange/2);
+          for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+          {
+            *q='\0';
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
+            p+=channels;
+            q++;
+          }
+          if ((number_pixels % 8) != 0)
+            {
+              *q='\0';
+              for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+              {
+                *q|=(GetPixelIntensity(image,p) < threshold ? black : white) <<
+                  bit;
+                p+=channels;
+              }
+              q++;
+            }
+          break;
+        }
+        case 4:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
+            pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            *q=(((pixel >> 4) & 0xf) << 4);
+            p+=channels;
+            pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            *q|=pixel >> 4;
+            p+=channels;
+            q++;
           }
+          if ((number_pixels % 2) != 0)
+            {
+              pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+              *q=(((pixel >> 4) & 0xf) << 4);
+              p+=channels;
+              q++;
+            }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             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(GetPixelBlue(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportCbYCrYQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  Quantum
-    cbcr[4];
-
-  register ssize_t
-    i,
-    x;
-
-  register unsigned int
-    pixel;
-
-  size_t
-    quantum;
-
-  ssize_t
-    n;
-
-  endian=quantum_state.endian;
-  n=0;
-  quantum=0;
-  switch (quantum_info->depth)
-  {
-    case 10:
-    {
-      if (quantum_info->pack == MagickFalse)
+        case 10:
         {
-          for (x=0; x < (ssize_t) number_pixels; x+=2)
-          {
-            for (i=0; i < 4; i++)
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
             {
-              switch (n % 3)
+              register unsigned int
+                pixel;
+
+              for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
               {
-                case 0:
-                {
-                  quantum=GetPixelRed(image,p);
-                  break;
-                }
-                case 1:
-                {
-                  quantum=GetPixelGreen(image,p);
-                  break;
-                }
-                case 2:
+                pixel=(unsigned int) (
+                  ScaleQuantumToAny(GetPixelIntensity(image,p+2*channels),range) << 22 |
+                  ScaleQuantumToAny(GetPixelIntensity(image,p+channels),range) << 12 |
+                  ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p+=3*channels;
+                q+=quantum_info->pad;
+              }
+              if (x < (ssize_t) number_pixels)
                 {
-                  quantum=GetPixelBlue(image,p);
-                  break;
+                  pixel=0U;
+                  if (x++ < (ssize_t) (number_pixels-1))
+                    pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+channels),
+                  range) << 12;
+                  if (x++ < (ssize_t) number_pixels)
+                    pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),
+                      range) << 2;
+                  q=PopLongPixel(endian,pixel,q);
                 }
-              }
-              cbcr[i]=(Quantum) quantum;
-              n++;
+              break;
             }
-            pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
-              (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
-            q=PopLongPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
-            pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
-              (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
-            q=PopLongPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      break;
-    }
-    default:
-    {
-      QuantumAny
-        range;
-
-      for (x=0; x < (ssize_t) number_pixels; x+=2)
-      {
-        for (i=0; i < 4; i++)
+        case 12:
         {
-          switch (n % 3)
-          {
-            case 0:
+          register unsigned short
+            pixel;
+
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
             {
-              quantum=GetPixelRed(image,p);
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+                q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
               break;
             }
-            case 1:
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              quantum=GetPixelGreen(image,p);
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelIntensity(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
               break;
             }
-            case 2:
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              quantum=GetPixelBlue(image,p);
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                pixel=(float) GetPixelIntensity(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
               break;
             }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
           }
-          cbcr[i]=(Quantum) quantum;
-          n++;
-        }
-        range=GetQuantumRange(quantum_info->depth);
-        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+=GetPixelChannels(image);
-        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+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportCMYKQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  register ssize_t
-    x;
-
-  if (image->colorspace != CMYKColorspace)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","`%s'",image->filename);
-      return;
-    }
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelRed(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                double
+                  pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+                pixel=(double) GetPixelIntensity(image,p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 32:
+    case GrayAlphaQuantum:
     {
-      register unsigned int
-        pixel;
+      switch (quantum_info->depth)
+      {
+        case 1:
+        {
+          register Quantum
+            threshold;
+
+          register unsigned char
+            black,
+            pixel,
+            white;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          black=0x00;
+          white=0x01;
+          if (quantum_info->min_is_white == MagickFalse)
+            {
+              black=0x01;
+              white=0x00;
+            }
+          threshold=(Quantum) (QuantumRange/2);
+          for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+          {
+            *q='\0';
+            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+              0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+              0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+              0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
+            p+=channels;
+            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
+            pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+              0x00 : 0x01);
+            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
+            p+=channels;
+            q++;
+          }
+          if ((number_pixels % 4) != 0)
+            {
+              *q='\0';
+              for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
+              {
+                *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
+                  (7-bit);
+                pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+                  0x00 : 0x01);
+                *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
+                  (7-bit-1));
+                p+=channels;
+              }
+              q++;
+            }
+          break;
+        }
+        case 4:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels ; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
+            pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            *q=(((pixel >> 4) & 0xf) << 4);
+            pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+            *q|=pixel & 0xf;
+            p+=channels;
+            q++;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-    }
-    default:
-    {
-      QuantumAny
-        range;
-
-      range=GetQuantumRange(quantum_info->depth);
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportCMYKAQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  register ssize_t
-    x;
-
-  if (image->colorspace != CMYKColorspace)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","`%s'",image->filename);
-      return;
-    }
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelRed(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelIntensity(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+            pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 32:
         {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                pixel=(float) GetPixelIntensity(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                pixel=(float) (GetPixelAlpha(image,p));
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
-            pixel=(float) (GetPixelAlpha(image,p));
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
         {
-          double
-            pixel;
-
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                double
+                  pixel;
+
+                pixel=(double) GetPixelIntensity(image,p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                pixel=(double) (GetPixelAlpha(image,p));
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
-            pixel=(double) (GetPixelAlpha(image,p));
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-    }
-    default:
-    {
-      QuantumAny
-        range;
-
-      range=GetQuantumRange(quantum_info->depth);
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-static void ExportGrayQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 1:
+    case RedQuantum:
+    case CyanQuantum:
     {
-      register Quantum
-        threshold;
-
-      register unsigned char
-        black,
-        white;
-
-      ssize_t
-        bit;
-
-      black=0x00;
-      white=0x01;
-      if (quantum_info->min_is_white != MagickFalse)
-        {
-          black=0x01;
-          white=0x00;
-        }
-      threshold=(Quantum) (QuantumRange/2);
-      for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+      switch (quantum_info->depth)
       {
-        *q='\0';
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 8) != 0)
+        case 8:
         {
-          *q='\0';
-          for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit;
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
           }
-          q++;
+          break;
         }
-      break;
-    }
-    case 4:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
-      {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        *q=(((pixel >> 4) & 0xf) << 4);
-        p+=GetPixelChannels(image);
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        *q|=pixel >> 4;
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 2) != 0)
+        case 16:
         {
-          pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-          *q=(((pixel >> 4) & 0xf) << 4);
-          p+=GetPixelChannels(image);
-          q++;
-        }
-      break;
-    }
-    case 8:
-    {
-      register unsigned char
-        pixel;
+          register unsigned short
+            pixel;
 
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 10:
-    {
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
         {
           register unsigned int
             pixel;
 
-          for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelRed(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) (
-              ScaleQuantumToAny(GetPixelIntensity(image,p+2*GetPixelChannels(image)),range) << 22 |
-              ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),range) << 12 |
-              ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
             q=PopLongPixel(endian,pixel,q);
-            p+=3*GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
-          if (x < (ssize_t) number_pixels)
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              pixel=0U;
-              if (x++ < (ssize_t) (number_pixels-1))
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),
-              range) << 12;
-              if (x++ < (ssize_t) number_pixels)
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),
-                  range) << 2;
-              q=PopLongPixel(endian,pixel,q);
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                p+=channels;
+                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(GetPixelRed(image,p),range),q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 12:
+    case GreenQuantum:
+    case MagentaQuantum:
     {
-      register unsigned short
-        pixel;
-
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+      switch (quantum_info->depth)
+      {
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
-            q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*
-              GetPixelIntensity(image,p));
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelGreen(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            pixel=(float) GetPixelIntensity(image,p);
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
         {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            double
-              pixel;
-
-            pixel=(double) GetPixelIntensity(image,p);
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            p+=channels;
             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(GetPixelIntensity(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-static void ExportGrayAlphaQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 1:
+    case BlueQuantum:
+    case YellowQuantum:
     {
-      register Quantum
-        threshold;
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          register unsigned char
+            pixel;
 
-      register unsigned char
-        black,
-        pixel,
-        white;
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
 
-      ssize_t
-        bit;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
 
-      black=0x00;
-      white=0x01;
-      if (quantum_info->min_is_white == MagickFalse)
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
         {
-          black=0x01;
-          white=0x00;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
         }
-      threshold=(Quantum) (QuantumRange/2);
-      for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
-      {
-        *q='\0';
-        *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
-          0x00 : 0x01);
-        *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
-          0x00 : 0x01);
-        *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
-          0x00 : 0x01);
-        *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
-        p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
-          0x00 : 0x01);
-        *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 4) != 0)
+        default:
         {
-          *q='\0';
-          for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
+          range=GetQuantumRange(quantum_info->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
-              (7-bit);
-            pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
-              0x00 : 0x01);
-            *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
-              (7-bit-1));
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            p+=channels;
+            q+=quantum_info->pad;
           }
-          q++;
+          break;
         }
-      break;
-    }
-    case 4:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels ; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        *q=(((pixel >> 4) & 0xf) << 4);
-        pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
-        *q|=pixel & 0xf;
-        p+=GetPixelChannels(image);
-        q++;
       }
       break;
     }
-    case 8:
+    case AlphaQuantum:
     {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      switch (quantum_info->depth)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+        case 8:
+        {
+          register unsigned char
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
+            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*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*
-              GetPixelIntensity(image,p));
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 32:
         {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                pixel=(float) GetPixelAlpha(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            pixel=(float) GetPixelIntensity(image,p);
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            pixel=(float) (GetPixelAlpha(image,p));
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                double
+                  pixel;
+
+                pixel=(double) (GetPixelAlpha(image,p));
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            double
-              pixel;
-
-            pixel=(double) GetPixelIntensity(image,p);
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            pixel=(double) (GetPixelAlpha(image,p));
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             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(GetPixelIntensity(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-static void ExportGreenQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
+    case OpacityQuantum:
     {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      switch (quantum_info->depth)
       {
-        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelAlpha(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             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(GetPixelGreen(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportIndexQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  register ssize_t
-    x;
-
-  ssize_t
-    bit;
-
-  if (image->storage_class != PseudoClass)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColormappedImageRequired","`%s'",image->filename);
-      return;
-    }
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 1:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
-      {
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q=((pixel & 0x01) << 7);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 6);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 5);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 4);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 3);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 2);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 1);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 0);
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 8) != 0)
+        case 64:
         {
-          *q='\0';
-          for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
-          {
-            pixel=(unsigned char) GetPixelIndex(image,p);
-            *q|=((pixel & 0x01) << (unsigned char) bit);
-            p+=GetPixelChannels(image);
-          }
-          q++;
-        }
-      break;
-    }
-    case 4:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
-      {
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q=((pixel & 0xf) << 4);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0xf) << 0);
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 2) != 0)
-        {
-          pixel=(unsigned char) GetPixelIndex(image,p);
-          *q=((pixel & 0xf) << 4);
-          p+=GetPixelChannels(image);
-          q++;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelAlpha(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
         }
-      break;
-    }
-    case 8:
-    {
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
-              GetPixelIndex(image,p)),q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 32:
+    case BlackQuantum:
     {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+      if (image->colorspace != CMYKColorspace)
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
+          (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+            "ColorSeparatedImageRequired","`%s'",image->filename);
+          return(extent);
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      switch (quantum_info->depth)
       {
-        q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-    }
-    default:
-    {
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          GetPixelIndex(image,p),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportIndexAlphaQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  register ssize_t
-    x;
-
-  ssize_t
-    bit;
-
-  if (image->storage_class != PseudoClass)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColormappedImageRequired","`%s'",image->filename);
-      return;
-    }
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 1:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
-      {
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q=((pixel & 0x01) << 7);
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
-          TransparentAlpha ? 1 : 0);
-        *q|=((pixel & 0x01) << 6);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 5);
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
-          TransparentAlpha ? 1 : 0);
-        *q|=((pixel & 0x01) << 4);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 3);
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
-          TransparentAlpha ? 1 : 0);
-        *q|=((pixel & 0x01) << 2);
-        p+=GetPixelChannels(image);
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q|=((pixel & 0x01) << 1);
-        pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
-          TransparentAlpha ? 1 : 0);
-        *q|=((pixel & 0x01) << 0);
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      if ((number_pixels % 4) != 0)
+        case 16:
         {
-          *q='\0';
-          for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
-          {
-            pixel=(unsigned char) GetPixelIndex(image,p);
-            *q|=((pixel & 0x01) << (unsigned char) (bit+4));
-            pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
-              TransparentAlpha ? 1 : 0);
-            *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
-            p+=GetPixelChannels(image);
-          }
-          q++;
-        }
-      break;
-    }
-    case 4:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels ; x++)
-      {
-        pixel=(unsigned char) GetPixelIndex(image,p);
-        *q=((pixel & 0xf) << 4);
-        pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
-        *q|=((pixel & 0xf) << 0);
-        p+=GetPixelChannels(image);
-        q++;
-      }
-      break;
-    }
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+          register unsigned short
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
-        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlack(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+            pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelBlack(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
-            pixel=(float)  GetPixelAlpha(image,p);
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            double
-              pixel;
-
-            q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
-            pixel=(double) GetPixelAlpha(image,p);
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlack(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
         }
-    }
-    default:
-    {
-      QuantumAny
-        range;
-
-      range=GetQuantumRange(quantum_info->depth);
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          GetPixelIndex(image,p),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportOpacityQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
-            q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny((Quantum) GetPixelBlack(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 32:
+    case RGBQuantum:
+    case CbYCrQuantum:
     {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+      switch (quantum_info->depth)
+      {
+        case 8:
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelOpacity(image,p),q);
-            p+=GetPixelChannels(image);
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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(GetPixelRed(image,p),range) << 22 |
+                  ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+                  ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelOpacity(image,p),
-              q);
-            p+=GetPixelChannels(image);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
             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(GetPixelOpacity(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-  }
-}
-
-static void ExportRedQuantum(const Image *image,const QuantumInfo *quantum_info,
-  QuantumState quantum_state,const MagickSizeType number_pixels,
-  const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
-    {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToChar(GetPixelRed(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
+        case 12:
+        {
+          register unsigned int
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          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(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    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(
+                      GetPixelRed(image,p),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelGreen(image,p),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(
+                      GetPixelBlue(image,p),range);
+                    p+=channels;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p+=channels;
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                  range);
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
+            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*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
         {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            p+=channels;
             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(GetPixelRed(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-static void ExportRGBQuantum(const Image *image,const QuantumInfo *quantum_info,
-  QuantumState quantum_state,const MagickSizeType number_pixels,
-  const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  ssize_t
-    bit;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
+    case RGBAQuantum:
+    case RGBOQuantum:
+    case CbYCrAQuantum:
     {
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      switch (quantum_info->depth)
       {
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
-        q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 10:
-    {
-      register unsigned int
-        pixel;
-
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+        case 8:
         {
+          register unsigned char
+            pixel;
+
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) (
-              ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
-              ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
-              ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
-            q=PopLongPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      if (quantum_info->quantum == 32UL)
+        case 10:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
-          {
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-              range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
-            q+=quantum_info->pad;
-          }
-          break;
-        }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 12:
-    {
-      register unsigned int
-        pixel;
+          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)
+          range=GetQuantumRange(quantum_info->depth);
+          if (quantum_info->pack == MagickFalse)
             {
-              default:
-              case 0:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
-                  range);
-                break;
-              }
-              case 1:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-                  range);
-                break;
-              }
-              case 2:
+              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++)
               {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
-                  range);
-                p+=GetPixelChannels(image);
-                break;
+                for (i=0; i < 4; i++)
+                {
+                  switch (i)
+                  {
+                    case 0: quantum=GetPixelRed(image,p); break;
+                    case 1: quantum=GetPixelGreen(image,p); break;
+                    case 2: quantum=GetPixelBlue(image,p); break;
+                    case 3: quantum=GetPixelAlpha(image,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+=channels;
+                q+=quantum_info->pad;
               }
+              break;
             }
-            q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
-            switch ((x+1) % 3)
+          if (quantum_info->quantum == 32UL)
             {
-              default:
-              case 0:
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
                 pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
                   range);
-                break;
-              }
-              case 1:
-              {
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
                   range);
-                break;
-              }
-              case 2:
-              {
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
                 pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
                   range);
-                p+=GetPixelChannels(image);
-                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(GetPixelRed(image,p),
-                  range);
-                break;
-              }
-              case 1:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-                  range);
-                break;
-              }
-              case 2:
-              {
-                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
                   range);
-                p+=GetPixelChannels(image);
-                break;
+                q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
+                  q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
+              break;
             }
-            q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
-            q+=quantum_info->pad;
-          }
-          if (bit != 0)
-            p+=GetPixelChannels(image);
-          break;
-        }
-      if (quantum_info->quantum == 32UL)
-        {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
               range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
             pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+              range);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 16:
-    {
-      register unsigned short
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 16:
         {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                pixel=(float) GetPixelAlpha(image,p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
         {
-          for (x=0; x < (ssize_t) number_pixels; x++)
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                pixel=(double) GetPixelAlpha(image,p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             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(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-static void ExportRGBAQuantum(const Image *image,
-  const QuantumInfo *quantum_info,QuantumState quantum_state,
-  const MagickSizeType number_pixels,const Quantum *restrict p,
-  unsigned char *restrict q,ExceptionInfo *exception)
-{
-  EndianType
-    endian;
-
-  QuantumAny
-    range;
-
-  register ssize_t
-    x;
-
-  endian=quantum_state.endian;
-  switch (quantum_info->depth)
-  {
-    case 8:
+    case CMYKQuantum:
     {
-      register unsigned char
-        pixel;
-
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      if (image->colorspace != CMYKColorspace)
+        {
+          (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+            "ColorSeparatedImageRequired","`%s'",image->filename);
+          return(extent);
+        }
+      switch (quantum_info->depth)
       {
-        pixel=ScaleQuantumToChar(GetPixelRed(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
-        q=PopCharPixel(pixel,q);
-        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
-        q=PopCharPixel(pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 10:
-    {
-      register unsigned int
-        pixel;
-
-      range=GetQuantumRange(quantum_info->depth);
-      if (quantum_info->pack == MagickFalse)
+        case 8:
         {
-          register ssize_t
-            i;
-
-          size_t
-            quantum;
-
-          ssize_t
-            n;
+          register unsigned char
+            pixel;
 
-          n=0;
-          quantum=0;
-          pixel=0;
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            for (i=0; i < 4; i++)
+            pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
             {
-              switch (i)
+              for (x=0; x < (ssize_t) number_pixels; x++)
               {
-                case 0: quantum=GetPixelRed(image,p); break;
-                case 1: quantum=GetPixelGreen(image,p); break;
-                case 2: quantum=GetPixelBlue(image,p); break;
-                case 3: quantum=GetPixelAlpha(image,p); break;
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlack(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
-              switch (n % 3)
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
+            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++)
               {
-                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;
-                }
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlack(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
               }
-              n++;
+              break;
             }
-            p+=GetPixelChannels(image);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      if (quantum_info->quantum == 32UL)
+        case 64:
         {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlack(image,p),q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
-              range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
-              range);
-            q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-    case 16:
+    case CMYKAQuantum:
+    case CMYKOQuantum:
     {
-      register unsigned short
-        pixel;
+      if (image->colorspace != CMYKColorspace)
+        {
+          (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+            "ColorSeparatedImageRequired","`%s'",image->filename);
+          return(extent);
+        }
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          register unsigned char
+            pixel;
 
-      if (quantum_info->format == FloatingPointQuantumFormat)
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+            q=PopCharPixel(pixel,q);
+            p+=channels;
+            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*
+                  GetPixelRed(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelGreen(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlue(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelBlack(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetPixelAlpha(image,p));
+                q=PopShortPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+            pixel=ScaleQuantumToShort(GetPixelRed(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+            pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+            pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
             q=PopShortPixel(endian,pixel,q);
-            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+            pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
             q=PopShortPixel(endian,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+            q=PopShortPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToShort(GetPixelRed(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
-        q=PopShortPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 32:
-    {
-      register unsigned int
-        pixel;
-
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        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)
+                  GetPixelRed(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelGreen(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlue(image,p),q);
+                q=PopFloatPixel(&quantum_state,(float)
+                  GetPixelBlack(image,p),q);
+                pixel=(float) (GetPixelAlpha(image,p));
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            float
-              pixel;
-
-            q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
-            q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
-            pixel=(float) GetPixelAlpha(image,p);
-            q=PopFloatPixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            q=PopLongPixel(endian,pixel,q);
+            p+=channels;
             q+=quantum_info->pad;
           }
           break;
         }
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        pixel=ScaleQuantumToLong(GetPixelRed(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
-        q=PopLongPixel(endian,pixel,q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
-      }
-      break;
-    }
-    case 64:
-    {
-      if (quantum_info->format == FloatingPointQuantumFormat)
+        case 64:
         {
-          double
-            pixel;
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
 
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelRed(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelGreen(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlue(image,p),q);
+                q=PopDoublePixel(&quantum_state,(double)
+                  GetPixelBlack(image,p),q);
+                pixel=(double) (GetPixelAlpha(image,p));
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(quantum_info->depth);
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
-            q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
-            pixel=(double) GetPixelAlpha(image,p);
-            q=PopDoublePixel(&quantum_state,pixel,q);
-            p+=GetPixelChannels(image);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+            q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+              ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+            p+=channels;
             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(GetPixelRed(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
-        q=PopQuantumPixel(&quantum_state,quantum_info->depth,
-          ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
-        p+=GetPixelChannels(image);
-        q+=quantum_info->pad;
       }
       break;
     }
-  }
-}
-
-MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
-  const QuantumInfo *quantum_info,const QuantumType quantum_type,
-  unsigned char *pixels,ExceptionInfo *exception)
-{
-  MagickSizeType
-    number_pixels;
-
-  QuantumState
-    quantum_state;
-
-  register const Quantum
-    *restrict p;
-
-  register ssize_t
-    x;
-
-  register unsigned char
-    *restrict q;
-
-  size_t
-    extent;
-
-  assert(image != (Image *) NULL);
-  assert(image->signature == MagickSignature);
-  if (image->debug != MagickFalse)
-    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  assert(quantum_info != (QuantumInfo *) NULL);
-  assert(quantum_info->signature == MagickSignature);
-  if (pixels == (unsigned char *) NULL)
-    pixels=GetQuantumPixels(quantum_info);
-  if (image_view == (CacheView *) NULL)
-    {
-      number_pixels=GetImageExtent(image);
-      p=GetVirtualPixelQueue(image);
-    }
-  else
-    {
-      number_pixels=GetCacheViewExtent(image_view);
-      p=GetCacheViewVirtualPixelQueue(image_view);
-    }
-  if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+    case CbYCrYQuantum:
     {
-      MagickRealType
-        Sa;
-
-      register Quantum
-        *restrict q;
-
-      /*
-        Associate alpha.
-      */
-      q=GetAuthenticPixelQueue(image);
-      if (image_view != (CacheView *) NULL)
-        q=GetCacheViewAuthenticPixelQueue(image_view);
-      for (x=0; x < (ssize_t) image->columns; x++)
-      {
-        register ssize_t
-          i;
-
-        Sa=QuantumScale*GetPixelAlpha(image,q);
-        for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
-        {
-          PixelChannel
-            channel;
+      Quantum
+        cbcr[4];
 
-          PixelTrait
-            traits;
+      register ssize_t
+        i;
 
-          channel=GetPixelChannelMapChannel(image,i);
-          traits=GetPixelChannelMapTraits(image,channel);
-          if ((traits & UpdatePixelTrait) != 0)
-            q[i]=ClampToQuantum(Sa*q[i]);
-        }
-        q+=GetPixelChannels(image);
-      }
-    }
-  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
-      (quantum_type == BGROQuantum))
-    {
-      register Quantum
-        *restrict q;
+      register unsigned int
+        pixel;
 
-      q=GetAuthenticPixelQueue(image);
-      if (image_view != (CacheView *) NULL)
-        q=GetCacheViewAuthenticPixelQueue(image_view);
-      for (x=0; x < (ssize_t) number_pixels; x++)
-      {
-        SetPixelAlpha(image,GetPixelAlpha(image,q),q);
-        q+=GetPixelChannels(image);
-      }
-    }
-  if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
-    {
-      Quantum
+      size_t
         quantum;
 
-      register Quantum
-        *restrict q;
+     ssize_t
+        n;
 
-      q=GetAuthenticPixelQueue(image);
-      if (image_view != (CacheView *) NULL)
-        q=GetAuthenticPixelQueue(image);
-      for (x=0; x < (ssize_t) number_pixels; x++)
+      n=0;
+      quantum=0;
+      range=GetQuantumRange(quantum_info->depth);
+      switch (quantum_info->depth)
       {
-        quantum=GetPixelRed(image,q);
-        SetPixelRed(image,GetPixelGreen(image,q),q);
-        SetPixelGreen(image,quantum,q);
-        q+=GetPixelChannels(image);
+        case 10:
+        {
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x+=2)
+              {
+                for (i=0; i < 4; i++)
+                {
+                  switch (n % 3)
+                  {
+                    case 0:
+                    {
+                      quantum=GetPixelRed(image,p);
+                      break;
+                    }
+                    case 1:
+                    {
+                      quantum=GetPixelGreen(image,p);
+                      break;
+                    }
+                    case 2:
+                    {
+                      quantum=GetPixelBlue(image,p);
+                      break;
+                    }
+                  }
+                  cbcr[i]=(Quantum) quantum;
+                  n++;
+                }
+                pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
+                  (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p+=channels;
+                pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
+                  (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p+=channels;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          break;
+        }
+        default:
+        {
+          for (x=0; x < (ssize_t) number_pixels; x+=2)
+          {
+            for (i=0; i < 4; i++)
+            {
+              switch (n % 3)
+              {
+                case 0:
+                {
+                  quantum=GetPixelRed(image,p);
+                  break;
+                }
+                case 1:
+                {
+                  quantum=GetPixelGreen(image,p);
+                  break;
+                }
+                case 2:
+                {
+                  quantum=GetPixelBlue(image,p);
+                  break;
+                }
+              }
+              cbcr[i]=(Quantum) quantum;
+              n++;
+            }
+            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+=channels;
+            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+=channels;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
       }
-    }
-  x=0;
-  q=pixels;
-  InitializeQuantumState(quantum_info,image->endian,&quantum_state);
-  extent=GetQuantumExtent(image,quantum_info,quantum_type);
-  switch (quantum_type)
-  {
-    case AlphaQuantum:
-    {
-      ExportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case BGRQuantum:
-    {
-      ExportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case BGRAQuantum:
-    case BGROQuantum:
-    {
-      ExportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case BlackQuantum:
-    {
-      ExportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case RGBQuantum:
-    case BlueQuantum:
-    case YellowQuantum:
-    {
-      ExportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case CMYKQuantum:
-    {
-      ExportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case CMYKAQuantum:
-    case CMYKOQuantum:
-    {
-      ExportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case CbYCrYQuantum:
-    {
-      ExportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case GrayQuantum:
-    {
-      ExportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case GrayAlphaQuantum:
-    {
-      ExportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case GreenQuantum:
-    case MagentaQuantum:
-    {
-      ExportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case IndexQuantum:
-    {
-      ExportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case IndexAlphaQuantum:
-    {
-      ExportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,
-        q,exception);
-      break;
-    }
-    case RedQuantum:
-    case CyanQuantum:
-    {
-      ExportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case OpacityQuantum:
-    {
-      ExportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case CbYCrQuantum:
-    {
-      ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
-      break;
-    }
-    case RGBAQuantum:
-    case RGBOQuantum:
-    case CbYCrAQuantum:
-    {
-      ExportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
-        exception);
       break;
     }
     default:
@@ -3505,7 +3316,7 @@ MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
         quantum=GetPixelRed(image,q);
         SetPixelRed(image,GetPixelGreen(image,q),q);
         SetPixelGreen(image,quantum,q);
-        q+=GetPixelChannels(image);
+        q+=channels;
       }
     }
   if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
@@ -3520,7 +3331,7 @@ MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         SetPixelAlpha(image,GetPixelAlpha(image,q),q);
-        q+=GetPixelChannels(image);
+        q+=channels;
       }
     }
   return(extent);
diff --git a/PerlMagick/t/png/read-16.t b/PerlMagick/t/png/read-16.t
index e5c4ebde7..e5e193fd9 100644
--- a/PerlMagick/t/png/read-16.t
+++ b/PerlMagick/t/png/read-16.t
@@ -18,7 +18,7 @@ chdir 't/png' || die 'Cd failed';
 # 1) Test Monochrome PNG
 # 
 testRead( 'input_mono.png',
-  '7e704fc1a99118630a92374ba27adf5baf69f30019016be2ed70eac79629e8b4' );
+  '1502b4e5747ed8805fe9103f56f9c4097f60440b3a867fa6b1ae0ba81f12a90d' );
 
 #
 # 2) Test 256 color pseudocolor PNG
@@ -47,5 +47,5 @@ testRead( 'input.mng',
 ++$test;
 testRead( 'input_16.png',
   '6b6761c8108b1616e9411c4ef2564505715a37b93e86d2c824c9a4bca31bf47b',
-  '5647f05ec18958947d32874eeb788fa396a05d0bab7c1b71f112ceb7e9b31eee');
+  '30e14955ebf1352266dc2ff8067e68104607e750abb9d3b36582b8af909fcb58');
 
diff --git a/PerlMagick/t/png/read.t b/PerlMagick/t/png/read.t
index 9a09593a3..e2b9d1737 100644
--- a/PerlMagick/t/png/read.t
+++ b/PerlMagick/t/png/read.t
@@ -19,7 +19,7 @@ chdir 't/png' || die 'Cd failed';
 # 
 print( "1-bit grayscale PNG ...\n" );
 testRead( 'input_bw.png',
-  'fe660b68ebf6e851ed91840b8ff8b083fcf8a58f675c8d699516e01a9946d85a' );
+  'b0ed82ae119a2baa1e8bf714fab26415708c47b8f07771fb5506ff101a550dbc' );
 
 #
 # 2) Test Monochrome PNG
@@ -27,7 +27,7 @@ testRead( 'input_bw.png',
 ++$test;
 print( "8-bit grayscale PNG ...\n" );
 testRead( 'input_mono.png',
-  '7e704fc1a99118630a92374ba27adf5baf69f30019016be2ed70eac79629e8b4' );
+  '1502b4e5747ed8805fe9103f56f9c4097f60440b3a867fa6b1ae0ba81f12a90d' );
 
 #
 # 3) Test 16-bit Portable Network Graphics
@@ -36,7 +36,7 @@ testRead( 'input_mono.png',
 print( "16-bit grayscale PNG ...\n" );
 testRead( 'input_16.png',
   '6b6761c8108b1616e9411c4ef2564505715a37b93e86d2c824c9a4bca31bf47b',
-  '5647f05ec18958947d32874eeb788fa396a05d0bab7c1b71f112ceb7e9b31eee' );
+  '30e14955ebf1352266dc2ff8067e68104607e750abb9d3b36582b8af909fcb58' );
 #
 # 4) Test 256 color pseudocolor PNG
 # 
diff --git a/PerlMagick/t/png/write-16.t b/PerlMagick/t/png/write-16.t
index e3bd504a6..905970393 100644
--- a/PerlMagick/t/png/write-16.t
+++ b/PerlMagick/t/png/write-16.t
@@ -37,7 +37,7 @@ testReadWrite( 'input_truecolor.png',
 ++$test;
 testReadWrite( 'input_mono.png',
   'output_mono.png', '',
-  '7e704fc1a99118630a92374ba27adf5baf69f30019016be2ed70eac79629e8b4' );
+  '1502b4e5747ed8805fe9103f56f9c4097f60440b3a867fa6b1ae0ba81f12a90d' );
 
 #
 # 4) Test Multiple-image Network Graphics
@@ -56,6 +56,6 @@ testReadWrite( 'input_16.png',
   'output_16.png',
   q/quality=>55/,
   'fa6b164245b385b3dea5764074be2c959a503dde90ecb1d4ba9c76a46bb8e4e6',
-  '5647f05ec18958947d32874eeb788fa396a05d0bab7c1b71f112ceb7e9b31eee');
+  '30e14955ebf1352266dc2ff8067e68104607e750abb9d3b36582b8af909fcb58');
 
 
diff --git a/PerlMagick/t/png/write.t b/PerlMagick/t/png/write.t
index e245f83e0..9db55ef97 100644
--- a/PerlMagick/t/png/write.t
+++ b/PerlMagick/t/png/write.t
@@ -19,7 +19,7 @@ chdir 't/png' || die 'Cd failed';
 # 
 print( "1-bit grayscale PNG ...\n" );
 testReadWrite( 'input_bw.png', 'output_bw.png', q/quality=>95/,
-  'fe660b68ebf6e851ed91840b8ff8b083fcf8a58f675c8d699516e01a9946d85a');
+  'b0ed82ae119a2baa1e8bf714fab26415708c47b8f07771fb5506ff101a550dbc');
 
 #
 # 2) Test monochrome image
@@ -28,7 +28,7 @@ testReadWrite( 'input_bw.png', 'output_bw.png', q/quality=>95/,
 print( "8-bit grayscale PNG ...\n" );
 testReadWrite( 'input_mono.png',
   'output_mono.png', '',
-  '7e704fc1a99118630a92374ba27adf5baf69f30019016be2ed70eac79629e8b4');
+  '1502b4e5747ed8805fe9103f56f9c4097f60440b3a867fa6b1ae0ba81f12a90d');
 #
 # 3) Test 16-bit Portable Network Graphics
 # 
@@ -38,7 +38,7 @@ testReadWrite( 'input_16.png',
   'output_16.png',
   q/quality=>55/,
   'fa6b164245b385b3dea5764074be2c959a503dde90ecb1d4ba9c76a46bb8e4e6',
-  '5647f05ec18958947d32874eeb788fa396a05d0bab7c1b71f112ceb7e9b31eee' );
+  '30e14955ebf1352266dc2ff8067e68104607e750abb9d3b36582b8af909fcb58' );
 #
 # 4) Test pseudocolor image
 #