]> granicus.if.org Git - imagemagick/blobdiff - MagickCore/quantum-export.c
projects / imagemagick / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[imagemagick] / MagickCore / quantum-export.c
diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c
index 461d358683ad2535c6292f4fd48ff2173bd855f3..b7608162bdfb15f808a9e329aa1cba60c46a11ec 100644 (file)
--- a/MagickCore/quantum-export.c
+++ b/MagickCore/quantum-export.c
@@ -18,11 +18,11 @@
 %                 MagickCore Methods to Export Quantum Pixels                 %
 %                                                                             %
 %                             Software Design                                 %
-%                               John Cristy                                   %
+%                                  Cristy                                     %
 %                               October 1998                                  %
 %                                                                             %
 %                                                                             %
-%  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
+%  Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization      %
 %  dedicated to making software imaging solutions freely available.           %
 %                                                                             %
 %  You may not use this file except in compliance with the License.  You may  %
@@ -91,7 +91,7 @@
 %
 %      size_t ExportQuantumPixels(const Image *image,CacheView *image_view,
 %        QuantumInfo *quantum_info,const QuantumType quantum_type,
-%        unsigned char *pixels,ExceptionInfo *exception)
+%        unsigned char *restrict pixels,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -111,7 +111,7 @@
 */
 
 static inline unsigned char *PopDoublePixel(QuantumInfo *quantum_info,
-  const double pixel,unsigned char *pixels)
+  const double pixel,unsigned char *restrict pixels)
 {
   double
     *p;
@@ -119,33 +119,34 @@ static inline unsigned char *PopDoublePixel(QuantumInfo *quantum_info,
   unsigned char
     quantum[8];
 
+  (void) ResetMagickMemory(quantum,0,sizeof(quantum));
   p=(double *) quantum;
   *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);
-  if (quantum_info->endian != LSBEndian)
+  if (quantum_info->endian == LSBEndian)
     {
-      *pixels++=quantum[7];
-      *pixels++=quantum[6];
-      *pixels++=quantum[5];
-      *pixels++=quantum[4];
-      *pixels++=quantum[3];
-      *pixels++=quantum[2];
-      *pixels++=quantum[1];
       *pixels++=quantum[0];
+      *pixels++=quantum[1];
+      *pixels++=quantum[2];
+      *pixels++=quantum[3];
+      *pixels++=quantum[4];
+      *pixels++=quantum[5];
+      *pixels++=quantum[6];
+      *pixels++=quantum[7];
       return(pixels);
     }
-  *pixels++=quantum[0];
-  *pixels++=quantum[1];
-  *pixels++=quantum[2];
-  *pixels++=quantum[3];
-  *pixels++=quantum[4];
-  *pixels++=quantum[5];
-  *pixels++=quantum[6];
   *pixels++=quantum[7];
+  *pixels++=quantum[6];
+  *pixels++=quantum[5];
+  *pixels++=quantum[4];
+  *pixels++=quantum[3];
+  *pixels++=quantum[2];
+  *pixels++=quantum[1];
+  *pixels++=quantum[0];
   return(pixels);
 }
 
 static inline unsigned char *PopFloatPixel(QuantumInfo *quantum_info,
-  const float pixel,unsigned char *pixels)
+  const float pixel,unsigned char *restrict pixels)
 {
   float
     *p;
@@ -153,26 +154,27 @@ static inline unsigned char *PopFloatPixel(QuantumInfo *quantum_info,
   unsigned char
     quantum[4];
 
+  (void) ResetMagickMemory(quantum,0,sizeof(quantum));
   p=(float *) quantum;
   *p=(float) ((double) pixel*quantum_info->state.inverse_scale+
     quantum_info->minimum);
-  if (quantum_info->endian != LSBEndian)
+  if (quantum_info->endian == LSBEndian)
     {
-      *pixels++=quantum[3];
-      *pixels++=quantum[2];
-      *pixels++=quantum[1];
       *pixels++=quantum[0];
+      *pixels++=quantum[1];
+      *pixels++=quantum[2];
+      *pixels++=quantum[3];
       return(pixels);
     }
-  *pixels++=quantum[0];
-  *pixels++=quantum[1];
-  *pixels++=quantum[2];
   *pixels++=quantum[3];
+  *pixels++=quantum[2];
+  *pixels++=quantum[1];
+  *pixels++=quantum[0];
   return(pixels);
 }
 
 static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
-  const QuantumAny pixel,unsigned char *pixels)
+  const QuantumAny pixel,unsigned char *restrict pixels)
 {
   register ssize_t
     i;
@@ -188,6 +190,8 @@ static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
     if (quantum_bits > quantum_info->state.bits)
       quantum_bits=quantum_info->state.bits;
     i-=(ssize_t) quantum_bits;
+    if (i < 0)
+      i=0;
     if (quantum_info->state.bits == 8UL)
       *pixels='\0';
     quantum_info->state.bits-=quantum_bits;
@@ -203,7 +207,7 @@ static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,
 }
 
 static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,
-  const size_t pixel,unsigned char *pixels)
+  const size_t pixel,unsigned char *restrict pixels)
 {
   register ssize_t
     i;
@@ -244,6 +248,8 @@ static void ExportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -350,6 +356,8 @@ static void ExportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
   ssize_t
     bit;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -644,6 +652,8 @@ static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -889,7 +899,7 @@ static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
   if (image->colorspace != CMYKColorspace)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","'%s'",image->filename);
+        "ColorSeparatedImageRequired","`%s'",image->filename);
       return;
     }
   switch (quantum_info->depth)
@@ -995,6 +1005,8 @@ static void ExportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -1108,6 +1120,8 @@ static void ExportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
   ssize_t
     n;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   n=0;
   quantum=0;
   switch (quantum_info->depth)
@@ -1211,7 +1225,7 @@ static void ExportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
   if (image->colorspace != CMYKColorspace)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","'%s'",image->filename);
+        "ColorSeparatedImageRequired","`%s'",image->filename);
       return;
     }
   switch (quantum_info->depth)
@@ -1356,7 +1370,7 @@ static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
   if (image->colorspace != CMYKColorspace)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColorSeparatedImageRequired","'%s'",image->filename);
+        "ColorSeparatedImageRequired","`%s'",image->filename);
       return;
     }
   switch (quantum_info->depth)
@@ -1521,11 +1535,13 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 1:
     {
-      register Quantum
+      register double
         threshold;
 
       register unsigned char
@@ -1542,25 +1558,25 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           black=0x01;
           white=0x00;
         }
-      threshold=(Quantum) (QuantumRange/2);
+      threshold=QuantumRange/2.0;
       for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
       {
         *q='\0';
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 7;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 6;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 5;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 4;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 3;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 2;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 1;
         p+=GetPixelChannels(image);
-        *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
+        *q|=(GetPixelLuma(image,p) < threshold ? black : white) << 0;
         p+=GetPixelChannels(image);
         q++;
       }
@@ -1569,7 +1585,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           *q='\0';
           for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
           {
-            *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit;
+            *q|=(GetPixelLuma(image,p) < threshold ? black : white) << bit;
             p+=GetPixelChannels(image);
           }
           q++;
@@ -1583,17 +1599,17 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
         *q=(((pixel >> 4) & 0xf) << 4);
         p+=GetPixelChannels(image);
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
         *q|=pixel >> 4;
         p+=GetPixelChannels(image);
         q++;
       }
       if ((number_pixels % 2) != 0)
         {
-          pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+          pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
           *q=(((pixel >> 4) & 0xf) << 4);
           p+=GetPixelChannels(image);
           q++;
@@ -1607,7 +1623,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopCharPixel(pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1624,10 +1640,11 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
           for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
           {
-            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=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
+              GetPixelLuma(image,p+2*GetPixelChannels(image))),range) << 22 |
+              ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
+              GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
+              ClampToQuantum(GetPixelLuma(image,p)),range) << 2);
             q=PopLongPixel(quantum_info->endian,pixel,q);
             p+=3*GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1636,18 +1653,19 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
             {
               pixel=0U;
               if (x++ < (ssize_t) (number_pixels-1))
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+
-                  GetPixelChannels(image)),range) << 12;
+                pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p+
+                  GetPixelChannels(image))),range) << 12;
               if (x++ < (ssize_t) number_pixels)
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2;
+                pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
+                  range) << 2;
               q=PopLongPixel(quantum_info->endian,pixel,q);
             }
           break;
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelLuma(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1663,7 +1681,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+            pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
             q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
               q);
             p+=GetPixelChannels(image);
@@ -1673,8 +1691,8 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelLuma(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1689,8 +1707,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*
-              GetPixelIntensity(image,p));
+            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelLuma(image,p));
             q=PopShortPixel(quantum_info->endian,pixel,q);
             p+=GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1699,7 +1716,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopShortPixel(quantum_info->endian,pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1718,7 +1735,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
             float
               pixel;
 
-            pixel=(float) GetPixelIntensity(image,p);
+            pixel=(float) GetPixelLuma(image,p);
             q=PopFloatPixel(quantum_info,pixel,q);
             p+=GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1727,7 +1744,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopLongPixel(quantum_info->endian,pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1743,7 +1760,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
             double
               pixel;
 
-            pixel=(double) GetPixelIntensity(image,p);
+            pixel=GetPixelLuma(image,p);
             q=PopDoublePixel(quantum_info,pixel,q);
             p+=GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1756,8 +1773,8 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
       range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelLuma(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1776,11 +1793,13 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 1:
     {
-      register Quantum
+      register double
         threshold;
 
       register unsigned char
@@ -1798,26 +1817,26 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
           black=0x01;
           white=0x00;
         }
-      threshold=(Quantum) (QuantumRange/2);
+      threshold=QuantumRange/2.0;
       for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
       {
         *q='\0';
-        *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
+        *q|=(GetPixelLuma(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;
+        *q|=(GetPixelLuma(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;
+        *q|=(GetPixelLuma(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;
+        *q|=(GetPixelLuma(image,p) > threshold ? black : white) << 1;
         pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
           0x00 : 0x01);
         *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
@@ -1829,7 +1848,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
           *q='\0';
           for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
           {
-            *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
+            *q|=(GetPixelLuma(image,p) > threshold ? black : white) <<
               (7-bit);
             pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
               0x00 : 0x01);
@@ -1848,7 +1867,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels ; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
         *q=(((pixel >> 4) & 0xf) << 4);
         pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
         *q|=pixel & 0xf;
@@ -1864,7 +1883,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopCharPixel(pixel,q);
         pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
         q=PopCharPixel(pixel,q);
@@ -1882,8 +1901,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=SinglePrecisionToHalf(QuantumScale*
-              GetPixelIntensity(image,p));
+            pixel=SinglePrecisionToHalf(QuantumScale*GetPixelLuma(image,p));
             q=PopShortPixel(quantum_info->endian,pixel,q);
             pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
             q=PopShortPixel(quantum_info->endian,pixel,q);
@@ -1894,7 +1912,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopShortPixel(quantum_info->endian,pixel,q);
         pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
         q=PopShortPixel(quantum_info->endian,pixel,q);
@@ -1915,7 +1933,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
             float
               pixel;
 
-            pixel=(float) GetPixelIntensity(image,p);
+            pixel=(float) GetPixelLuma(image,p);
             q=PopFloatPixel(quantum_info,pixel,q);
             pixel=(float) (GetPixelAlpha(image,p));
             q=PopFloatPixel(quantum_info,pixel,q);
@@ -1926,7 +1944,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelLuma(image,p)));
         q=PopLongPixel(quantum_info->endian,pixel,q);
         pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
         q=PopLongPixel(quantum_info->endian,pixel,q);
@@ -1944,7 +1962,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
             double
               pixel;
 
-            pixel=(double) GetPixelIntensity(image,p);
+            pixel=GetPixelLuma(image,p);
             q=PopDoublePixel(quantum_info,pixel,q);
             pixel=(double) (GetPixelAlpha(image,p));
             q=PopDoublePixel(quantum_info,pixel,q);
@@ -1959,8 +1977,8 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
       range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelLuma(image,p)),range),q);
         q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
           range),q);
         p+=GetPixelChannels(image);
@@ -1981,6 +1999,8 @@ static void ExportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2087,7 +2107,7 @@ static void ExportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
   if (image->storage_class != PseudoClass)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColormappedImageRequired","'%s'",image->filename);
+        "ColormappedImageRequired","`%s'",image->filename);
       return;
     }
   switch (quantum_info->depth)
@@ -2254,7 +2274,7 @@ static void ExportIndexAlphaQuantum(const Image *image,
   if (image->storage_class != PseudoClass)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ColormappedImageRequired","'%s'",image->filename);
+        "ColormappedImageRequired","`%s'",image->filename);
       return;
     }
   switch (quantum_info->depth)
@@ -2446,6 +2466,8 @@ static void ExportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2549,6 +2571,8 @@ static void ExportRedQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2655,6 +2679,8 @@ static void ExportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
   ssize_t
     bit;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2949,6 +2975,8 @@ static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
   register ssize_t
     x;
 
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -3183,7 +3211,8 @@ static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
 
 MagickExport size_t ExportQuantumPixels(const Image *image,
   CacheView *image_view,QuantumInfo *quantum_info,
-  const QuantumType quantum_type,unsigned char *pixels,ExceptionInfo *exception)
+  const QuantumType quantum_type,unsigned char *restrict pixels,
+  ExceptionInfo *exception)
 {
   MagickSizeType
     number_pixels;
@@ -3237,7 +3266,7 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         register ssize_t
           i;
 
-        if (GetPixelMask(image,q) != 0)
+        if (GetPixelReadMask(image,q) == 0)
           {
             q+=GetPixelChannels(image);
             continue;
@@ -3245,14 +3274,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         Sa=QuantumScale*GetPixelAlpha(image,q);
         for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
         {
-          PixelChannel
-            channel;
-
-          PixelTrait
-            traits;
-
-          channel=GetPixelChannelMapChannel(image,i);
-          traits=GetPixelChannelMapTraits(image,channel);
+          PixelChannel channel=GetPixelChannelChannel(image,i);
+          PixelTrait traits=GetPixelChannelTraits(image,channel);
           if ((traits & UpdatePixelTrait) == 0)
             continue;
           q[i]=ClampToQuantum(Sa*q[i]);
Unnamed repository; edit this file 'description' to name the repository.