]> granicus.if.org Git - imagemagick/blobdiff - MagickCore/quantum-import.c
projects / imagemagick / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[imagemagick] / MagickCore / quantum-import.c
diff --git a/MagickCore/quantum-import.c b/MagickCore/quantum-import.c
index bdb411b21cb10646ca070c8862bed31dc11a34af..32c2f685bef26e75886e1b05de7792c6cab1938c 100644 (file)
--- a/MagickCore/quantum-import.c
+++ b/MagickCore/quantum-import.c
@@ -1,5 +1,4 @@
-
-  /*
+/*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
 %                                                                             %
@@ -19,11 +18,11 @@
 %                 MagickCore Methods to Import Quantum Pixels                 %
 %                                                                             %
 %                             Software Design                                 %
-%                               John Cristy                                   %
+%                                  Cristy                                     %
 %                               October 1998                                  %
 %                                                                             %
 %                                                                             %
-%  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
+%  Copyright 1999-2014 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  %
@@ -63,6 +62,7 @@
 #include "MagickCore/option.h"
 #include "MagickCore/pixel.h"
 #include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
 #include "MagickCore/quantum.h"
 #include "MagickCore/quantum-private.h"
 #include "MagickCore/resource_.h"
@@ -92,7 +92,7 @@
 %
 %      size_t ImportQuantumPixels(const Image *image,CacheView *image_view,
 %        QuantumInfo *quantum_info,const QuantumType quantum_type,
-%        const unsigned char *pixels,ExceptionInfo *exception)
+%        const unsigned char *restrict pixels,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -121,7 +121,7 @@ static inline Quantum PushColormapIndex(const Image *image,const size_t index,
 }
 
 static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
-  const unsigned char *pixels,double *pixel)
+  const unsigned char *restrict pixels,double *pixel)
 {
   double
     *p;
@@ -129,30 +129,30 @@ static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
   unsigned char
     quantum[8];
 
-  if (quantum_info->endian != LSBEndian)
+  if (quantum_info->endian == LSBEndian)
     {
-      quantum[7]=(*pixels++);
-      quantum[6]=(*pixels++);
-      quantum[5]=(*pixels++);
-      quantum[5]=(*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]=(*pixels++);
       p=(double *) quantum;
       *pixel=(*p);
       *pixel-=quantum_info->minimum;
       *pixel*=quantum_info->scale;
       return(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]=(*pixels++);
   p=(double *) quantum;
   *pixel=(*p);
   *pixel-=quantum_info->minimum;
@@ -161,7 +161,7 @@ static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,
 }
 
 static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
-  const unsigned char *pixels,float *pixel)
+  const unsigned char *restrict pixels,float *pixel)
 {
   float
     *p;
@@ -169,22 +169,22 @@ static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
   unsigned char
     quantum[4];
 
-  if (quantum_info->endian != LSBEndian)
+  if (quantum_info->endian == LSBEndian)
     {
-      quantum[3]=(*pixels++);
-      quantum[2]=(*pixels++);
-      quantum[1]=(*pixels++);
       quantum[0]=(*pixels++);
+      quantum[1]=(*pixels++);
+      quantum[2]=(*pixels++);
+      quantum[3]=(*pixels++);
       p=(float *) quantum;
       *pixel=(*p);
       *pixel-=quantum_info->minimum;
       *pixel*=quantum_info->scale;
       return(pixels);
     }
-  quantum[0]=(*pixels++);
-  quantum[1]=(*pixels++);
-  quantum[2]=(*pixels++);
   quantum[3]=(*pixels++);
+  quantum[2]=(*pixels++);
+  quantum[1]=(*pixels++);
+  quantum[0]=(*pixels++);
   p=(float *) quantum;
   *pixel=(*p);
   *pixel-=quantum_info->minimum;
@@ -193,7 +193,7 @@ static inline const unsigned char *PushFloatPixel(QuantumInfo *quantum_info,
 }
 
 static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
-  const unsigned char *pixels,unsigned int *quantum)
+  const unsigned char *restrict pixels,unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -222,7 +222,8 @@ static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,
 }
 
 static inline const unsigned char *PushQuantumLongPixel(
-  QuantumInfo *quantum_info,const unsigned char *pixels,unsigned int *quantum)
+  QuantumInfo *quantum_info,const unsigned char *restrict pixels,
+  unsigned int *quantum)
 {
   register ssize_t
     i;
@@ -263,6 +264,8 @@ static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -289,7 +292,7 @@ static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -352,7 +355,7 @@ static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -381,6 +384,8 @@ static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -404,7 +409,7 @@ static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 10:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
@@ -447,7 +452,7 @@ static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 12:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
           unsigned short
@@ -573,13 +578,13 @@ static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -658,7 +663,7 @@ static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -687,6 +692,8 @@ static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -792,16 +799,16 @@ static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -888,7 +895,7 @@ static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -951,7 +958,7 @@ static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlack(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1014,7 +1021,7 @@ static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1040,6 +1047,8 @@ static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -1066,7 +1075,7 @@ static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1129,7 +1138,7 @@ static void ImportBlueQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1155,6 +1164,8 @@ static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 10:
@@ -1220,7 +1231,7 @@ static void ImportCbYCrYQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1285,16 +1296,16 @@ static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlack(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1381,7 +1392,7 @@ static void ImportCMYKQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1452,19 +1463,19 @@ static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlack(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlack(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1560,7 +1571,7 @@ static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1596,6 +1607,8 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 1:
@@ -1605,10 +1618,10 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         white;
 
       black=0;
-      white=(Quantum) QuantumRange;
+      white=QuantumRange;
       if (quantum_info->min_is_white != MagickFalse)
         {
-          black=(Quantum) QuantumRange;
+          black=QuantumRange;
           white=0;
         }
       for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
@@ -1634,7 +1647,7 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
       register unsigned char
         pixel;
 
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < ((ssize_t) number_pixels-1); x+=2)
       {
         pixel=(unsigned char) ((*p >> 4) & 0xf);
@@ -1682,21 +1695,21 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 10:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
-          if (image->endian != LSBEndian)
+          if (image->endian == LSBEndian)
             {
               for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
               {
                 p=PushLongPixel(quantum_info->endian,p,&pixel);
-                SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+                SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
                   range),q);
                 q+=GetPixelChannels(image);
                 SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
                   range),q);
                 q+=GetPixelChannels(image);
-                SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
+                SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
                   range),q);
                 p+=quantum_info->pad;
                 q+=GetPixelChannels(image);
@@ -1704,7 +1717,7 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
               p=PushLongPixel(quantum_info->endian,p,&pixel);
               if (x++ < (ssize_t) (number_pixels-1))
                 {
-                  SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+                  SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,
                     range),q);
                   q+=GetPixelChannels(image);
                 }
@@ -1719,13 +1732,13 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
           {
             p=PushLongPixel(quantum_info->endian,p,&pixel);
-            SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
+            SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
               q);
             q+=GetPixelChannels(image);
             SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
               q);
             q+=GetPixelChannels(image);
-            SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),
+            SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
               q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1733,14 +1746,14 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           p=PushLongPixel(quantum_info->endian,p,&pixel);
           if (x++ < (ssize_t) (number_pixels-1))
             {
-              SetPixelGray(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),
-                q);
+              SetPixelGray(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,
+                range),q);
               q+=GetPixelChannels(image);
             }
           if (x++ < (ssize_t) number_pixels)
             {
-              SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),
-                q);
+              SetPixelGray(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,
+                range),q);
               q+=GetPixelChannels(image);
             }
           break;
@@ -1756,7 +1769,7 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 12:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
           unsigned short
@@ -1816,7 +1829,7 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGray(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -1879,7 +1892,7 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1908,6 +1921,8 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 1:
@@ -1915,6 +1930,7 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
       register unsigned char
         pixel;
 
+      bit=0;
       for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
       {
         for (bit=0; bit < 8; bit+=2)
@@ -1945,7 +1961,7 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
       register unsigned char
         pixel;
 
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         pixel=(unsigned char) ((*p >> 4) & 0xf);
@@ -1975,7 +1991,7 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 10:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -1989,7 +2005,7 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 12:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2011,10 +2027,10 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGray(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2085,7 +2101,7 @@ static void ImportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2113,6 +2129,8 @@ static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2139,7 +2157,7 @@ static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2202,7 +2220,7 @@ static void ImportGreenQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2332,7 +2350,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
-              (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+              (double) QuantumRange*HalfToSinglePrecision(pixel)),
               &range_exception),q);
             SetPixelInfoPixel(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
@@ -2492,7 +2510,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       register unsigned char
         pixel;
 
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         pixel=(unsigned char) ((*p >> 4) & 0xf);
@@ -2535,13 +2553,13 @@ static void ImportIndexAlphaQuantum(const Image *image,
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
-              (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)),
+              (double) QuantumRange*HalfToSinglePrecision(pixel)),
               &range_exception),q);
             SetPixelInfoPixel(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType)
-              QuantumRange*HalfToSinglePrecision(pixel)),q);
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
+              HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
           }
@@ -2621,7 +2639,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2654,6 +2672,8 @@ static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2680,7 +2700,7 @@ static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelOpacity(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelOpacity(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2743,7 +2763,7 @@ static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2755,6 +2775,7 @@ static void ImportOpacityQuantum(const Image *image,QuantumInfo *quantum_info,
     }
   }
 }
+
 static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
   const MagickSizeType number_pixels,const unsigned char *restrict p,
   Quantum *restrict q,ExceptionInfo *exception)
@@ -2768,6 +2789,8 @@ static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2794,7 +2817,7 @@ static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2857,7 +2880,7 @@ static void ImportRedQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -2886,6 +2909,8 @@ static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -2909,7 +2934,7 @@ static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 10:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
@@ -2952,7 +2977,7 @@ static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     case 12:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       if (quantum_info->pack == MagickFalse)
         {
           unsigned short
@@ -3078,13 +3103,13 @@ static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -3163,7 +3188,7 @@ static void ImportRGBQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -3192,6 +3217,8 @@ static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
   unsigned int
     pixel;
 
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
   switch (quantum_info->depth)
   {
     case 8:
@@ -3297,16 +3324,16 @@ static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelRed(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelGreen(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelBlue(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
-            SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
+            SetPixelAlpha(image,ClampToQuantum(QuantumRange*
               HalfToSinglePrecision(pixel)),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -3393,7 +3420,7 @@ static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
     }
     default:
     {
-      range=GetQuantumRange(image->depth);
+      range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
@@ -3413,7 +3440,7 @@ static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
 
 MagickExport size_t ImportQuantumPixels(const Image *image,
   CacheView *image_view,QuantumInfo *quantum_info,
-  const QuantumType quantum_type,const unsigned char *pixels,
+  const QuantumType quantum_type,const unsigned char *restrict pixels,
   ExceptionInfo *exception)
 {
   MagickSizeType
@@ -3586,7 +3613,7 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
     }
   if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
     {
-      MagickRealType
+      double
         gamma,
         Sa;
 
@@ -3604,20 +3631,20 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
         register ssize_t
           i;
 
+        if (GetPixelReadMask(image,q) == 0)
+          {
+            q+=GetPixelChannels(image);
+            continue;
+          }
         Sa=QuantumScale*GetPixelAlpha(image,q);
-        gamma=1.0/(fabs(Sa) <= MagickEpsilon ? 1.0 : Sa);
+        gamma=PerceptibleReciprocal(Sa);
         for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
         {
-          PixelChannel
-            channel;
-
-          PixelTrait
-            traits;
-
-          channel=GetPixelChannelMapChannel(image,i);
-          traits=GetPixelChannelMapTraits(image,channel);
-          if ((traits & UpdatePixelTrait) != 0)
-            q[i]=ClampToQuantum(gamma*q[i]);
+          PixelChannel channel=GetPixelChannelChannel(image,i);
+          PixelTrait traits=GetPixelChannelTraits(image,channel);
+          if ((traits & UpdatePixelTrait) == 0)
+            continue;
+          q[i]=ClampToQuantum(gamma*q[i]);
         }
         q+=GetPixelChannels(image);
       }
Unnamed repository; edit this file 'description' to name the repository.