(no commit message)

diff --git a/magick/enhance.c b/magick/enhance.c
index 96b6bc8875c91ccfeef27fd58c71a5bad801114c..7ad27f184428bce53ec04378d480bc737cfad4c7 100644 (file)
--- a/magick/enhance.c
+++ b/magick/enhance.c
@@ -2544,7 +2544,7 @@ MagickExport MagickBooleanType LevelImageChannel(Image *image,
   const double gamma)
 {
 #define LevelImageTag  "Level/Image"
-#define LevelQuantum(x) (KlampToQuantum((MagickRealType) QuantumRange* \
+#define LevelQuantum(x) (ClampToQuantum((MagickRealType) QuantumRange* \
   pow(scale*((double) (x)-black_point),1.0/gamma)))
 
   CacheView

diff --git a/magick/fourier.c b/magick/fourier.c
index c821095c6719fb3b8cd2bf93db5089459738fa49..d29dafdf66371b5ddf28751d1912a8f16a8033b0 100644 (file)
--- a/magick/fourier.c
+++ b/magick/fourier.c
@@ -117,6 +117,19 @@ typedef struct _FourierInfo
 
 #if defined(MAGICKCORE_FFTW_DELEGATE)
 
+static inline Quantum FourierClampToQuantum(const MagickRealType value)
+{
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) value);
+#else
+  if (value <= 0.0)
+    return((Quantum) 0);
+  if (value >= (MagickRealType) QuantumRange)
+    return((Quantum) QuantumRange);
+  return((Quantum) (value+0.5));
+#endif
+}
+
 static MagickBooleanType RollFourier(const unsigned long width,
   const unsigned long height,const long x_offset,const long y_offset,
   double *fourier)
@@ -298,32 +311,32 @@ static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
         case RedChannel:
         default:
         {
-          q->red=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           break;
         }
         case GreenChannel:
         {
-          q->green=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          q->green=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           break;
         }
         case BlueChannel:
         {
-          q->blue=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          q->blue=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           break;
         }
         case OpacityChannel:
         {
-          q->opacity=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          q->opacity=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           break;
         }
         case IndexChannel:
         {
-          indexes[x]=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          indexes[x]=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           break;
         }
         case GrayChannels:
         {
-          q->red=ClampToQuantum(QuantumRange*magnitude_source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*magnitude_source[i]);
           q->green=q->red;
           q->blue=q->red;
           break;
@@ -351,32 +364,32 @@ static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
         case RedChannel:
         default:
         {
-          q->red=ClampToQuantum(QuantumRange*phase_source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*phase_source[i]);
           break;
         }
         case GreenChannel:
         {
-          q->green=ClampToQuantum(QuantumRange*phase_source[i]);
+          q->green=FourierClampToQuantum(QuantumRange*phase_source[i]);
           break;
         }
         case BlueChannel:
         {
-          q->blue=ClampToQuantum(QuantumRange*phase_source[i]);
+          q->blue=FourierClampToQuantum(QuantumRange*phase_source[i]);
           break;
         }
         case OpacityChannel:
         {
-          q->opacity=ClampToQuantum(QuantumRange*phase_source[i]);
+          q->opacity=FourierClampToQuantum(QuantumRange*phase_source[i]);
           break;
         }
         case IndexChannel:
         {
-          indexes[x]=ClampToQuantum(QuantumRange*phase_source[i]);
+          indexes[x]=FourierClampToQuantum(QuantumRange*phase_source[i]);
           break;
         }
         case GrayChannels:
         {
-          q->red=ClampToQuantum(QuantumRange*phase_source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*phase_source[i]);
           q->green=q->red;
           q->blue=q->red;
           break;
@@ -1073,32 +1086,32 @@ static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
         case RedChannel:
         default:
         {
-          q->red=ClampToQuantum(QuantumRange*source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*source[i]);
           break;
         }
         case GreenChannel:
         {
-          q->green=ClampToQuantum(QuantumRange*source[i]);
+          q->green=FourierClampToQuantum(QuantumRange*source[i]);
           break;
         }
         case BlueChannel:
         {
-          q->blue=ClampToQuantum(QuantumRange*source[i]);
+          q->blue=FourierClampToQuantum(QuantumRange*source[i]);
           break;
         }
         case OpacityChannel:
         {
-          q->opacity=ClampToQuantum(QuantumRange*source[i]);
+          q->opacity=FourierClampToQuantum(QuantumRange*source[i]);
           break;
         }
         case IndexChannel:
         {
-          indexes[x]=ClampToQuantum(QuantumRange*source[i]);
+          indexes[x]=FourierClampToQuantum(QuantumRange*source[i]);
           break;
         }
         case GrayChannels:
         {
-          q->red=ClampToQuantum(QuantumRange*source[i]);
+          q->red=FourierClampToQuantum(QuantumRange*source[i]);
           q->green=q->red;
           q->blue=q->red;
           break;

diff --git a/magick/gem.c b/magick/gem.c
index d1f7ee50a47adda2dfb792451361f62fc76c6a8d..278360ba0c7027cc1c1e3eb780f4618b3e4254bf 100644 (file)
--- a/magick/gem.c
+++ b/magick/gem.c
@@ -100,7 +100,7 @@ MagickExport void ConvertHSBToRGB(const double hue,const double saturation,
   assert(blue != (Quantum *) NULL);
   if (saturation == 0.0)
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       *green=(*red);
       *blue=(*red);
       return;
@@ -115,44 +115,44 @@ MagickExport void ConvertHSBToRGB(const double hue,const double saturation,
     case 0:
     default:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*brightness);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*t);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*p);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*t);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
       break;
     }
     case 1:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*q);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*brightness);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*p);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*q);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
       break;
     }
     case 2:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*p);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*brightness);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*t);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*t);
       break;
     }
     case 3:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*p);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*q);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*q);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       break;
     }
     case 4:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*t);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*p);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*t);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       break;
     }
     case 5:
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*brightness);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*p);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*q);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*q);
       break;
     }
   }
@@ -220,7 +220,7 @@ MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
   assert(blue != (Quantum *) NULL);
   if (saturation == 0)
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*lightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*lightness);
       *green=(*red);
       *blue=(*red);
       return;
@@ -233,9 +233,9 @@ MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
   r=ConvertHueToRGB(m1,m2,hue+1.0/3.0);
   g=ConvertHueToRGB(m1,m2,hue);
   b=ConvertHueToRGB(m1,m2,hue-1.0/3.0);
-  *red=KlampToQuantum((MagickRealType) QuantumRange*r);
-  *green=KlampToQuantum((MagickRealType) QuantumRange*g);
-  *blue=KlampToQuantum((MagickRealType) QuantumRange*b);
+  *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+  *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+  *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
 }
 \f
 /*
@@ -288,9 +288,9 @@ MagickExport void ConvertHWBToRGB(const double hue,const double whiteness,
   v=1.0-blackness;
   if (hue == 0.0)
     {
-      *red=KlampToQuantum((MagickRealType) QuantumRange*v);
-      *green=KlampToQuantum((MagickRealType) QuantumRange*v);
-      *blue=KlampToQuantum((MagickRealType) QuantumRange*v);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*v);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*v);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*v);
       return;
     }
   i=(long) floor(6.0*hue);
@@ -309,9 +309,9 @@ MagickExport void ConvertHWBToRGB(const double hue,const double whiteness,
     case 4: r=n; g=whiteness; b=v; break;
     case 5: r=v; g=whiteness; b=n; break;
   }
-  *red=KlampToQuantum((MagickRealType) QuantumRange*r);
-  *green=KlampToQuantum((MagickRealType) QuantumRange*g);
-  *blue=KlampToQuantum((MagickRealType) QuantumRange*b);
+  *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+  *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+  *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
 }
 \f
 /*

diff --git a/magick/quantum-private.h b/magick/quantum-private.h
index 9174c3f690a138ba9d319a581455416395295c59..5ab1cd47e898a34874e9b12b6ed640fef1c49d16 100644 (file)
--- a/magick/quantum-private.h
+++ b/magick/quantum-private.h
@@ -188,19 +188,6 @@ static inline void InitializeQuantumState(const QuantumInfo *quantum_info,
   quantum_state->mask=mask;
 }
 
-static inline Quantum KlampToQuantum(const MagickRealType value)
-{
-  if (value <= 0.0)
-    return((Quantum) 0);
-  if (value >= (MagickRealType) QuantumRange)
-    return((Quantum) QuantumRange);
-#if defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) value);
-#else
-  return((Quantum) (value+0.5));
-#endif
-}
-
 static inline unsigned char *PopCharPixel(const unsigned char pixel,
   unsigned char *pixels)
 {
@@ -305,7 +292,7 @@ static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (((MagickRealType) QuantumRange*quantum)/range+0.5));
 #else
-  return((Quantum) (((MagickRealType) QuantumRange*quantum)/range));
+  return((Quantum) (((MagickRealType) QuantumRange*quantum)/range+0.0));
 #endif
 }
 
@@ -315,7 +302,7 @@ static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((QuantumAny) (((MagickRealType) range*quantum)/QuantumRange+0.5));
 #else
-  return((QuantumAny) (((MagickRealType) range*quantum)/QuantumRange));
+  return((QuantumAny) (((MagickRealType) range*quantum)/QuantumRange+0.5));
 #endif
 }
 
@@ -382,9 +369,9 @@ static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
 #else
   if (quantum <= 0.0)
     return(0);
-  if ((257.0*quantum) >= 65535.0)
+  if ((256.0*quantum) >= 65535.0)
     return(65535);
-  return((unsigned short) (257.0*quantum+0.5));
+  return((unsigned short) (256.0*quantum+0.5));
 #endif
 }
 
@@ -393,7 +380,7 @@ static inline Quantum ScaleShortToQuantum(const unsigned short value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) ((value+128U)/257U));
 #else
-  return((Quantum) (value/257.0));
+  return((Quantum) (value/256.0+0.5));
 #endif
 }
 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
@@ -402,7 +389,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (257U*value));
 #else
-  return((Quantum) (257.0*value));
+  return((Quantum) (256.0*value+0.5));
 #endif
 }
 
@@ -412,7 +399,7 @@ static inline Quantum ScaleLongToQuantum(const unsigned long value)
   return((Quantum) ((value+MagickULLConstant(32768))/
     MagickULLConstant(65537)));
 #else
-  return((Quantum) (value/65537.0));
+  return((Quantum) (value/65536.0+0.5));
 #endif
 }
 
@@ -438,9 +425,9 @@ static inline unsigned long ScaleQuantumToLong(const Quantum quantum)
 #else
   if (quantum <= 0.0)
     return(0UL);
-  if ((65537.0*quantum) >= 4294967295.0)
+  if ((65536.0*quantum) >= 4294967295.0)
     return(4294967295UL);
-  return((unsigned long) (65537.0*quantum+0.5));
+  return((unsigned long) (65536.0*quantum+0.5));
 #endif
 }
 
@@ -480,7 +467,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (16843009UL*value));
 #else
-  return((Quantum) (16843009.0*value));
+  return((Quantum) (16843008.0*value+0.5));
 #endif
 }
 
@@ -498,9 +485,9 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
     return(QuantumRange);
   return((Quantum) (65537.0*value));
 #else
-  if ((value+0.5) >= MaxMap)
+  if (value >= MaxMap)
     return(QuantumRange);
-  return((Quantum) (65537UL*value));
+  return((Quantum) (65536UL*value+0.5));
 #endif
 }
 
@@ -519,7 +506,7 @@ static inline unsigned long ScaleQuantumToMap(const Quantum quantum)
   return((unsigned long) ((quantum+MagickULLConstant(32768))/
     MagickULLConstant(65537)));
 #else
-  return((unsigned long) (quantum/65537.0)+0.5);
+  return((unsigned long) (quantum/65536.0+0.5));
 #endif
 }
 
@@ -531,9 +518,9 @@ static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
 #else
   if (quantum <= 0.0)
     return(0);
-  if ((quantum/65537.0) >= 65535.0)
+  if ((quantum/65536.0) >= 65535.0)
     return(65535);
-  return((unsigned short) (quantum/65537.0+0.5));
+  return((unsigned short) (quantum/65536.0+0.5));
 #endif
 }
 
@@ -542,7 +529,7 @@ static inline Quantum ScaleShortToQuantum(const unsigned short value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (65537UL*value));
 #else
-  return((Quantum) (65537.0*value));
+  return((Quantum) (65536.0*value+0.5));
 #endif
 }
 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
@@ -551,7 +538,7 @@ static inline Quantum ScaleCharToQuantum(const unsigned char value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (MagickULLConstant(71777214294589695)*value));
 #else
-  return((Quantum) (71777214294589695.0*value));
+  return((Quantum) (71777214294589694.0*value+0.5));
 #endif
 }
 
@@ -560,7 +547,7 @@ static inline Quantum ScaleLongToQuantum(const unsigned long value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (4294967295UL*value));
 #else
-  return((Quantum) (4294967295.0*value));
+  return((Quantum) (4294967294.0*value+0.5));
 #endif
 }
 
@@ -573,9 +560,9 @@ static inline Quantum ScaleMapToQuantum(const MagickRealType value)
     return(QuantumRange);
   return((Quantum) (281479271612415.0*value));
 #else
-  if ((value+0.5) >= MaxMap)
+  if (value >= MaxMap)
     return(QuantumRange);
-  return((Quantum) (MagickULLConstant(281479271612415)*value));
+  return((Quantum) (MagickULLConstant(281479271612414)*value+0.5));
 #endif
 }
 
@@ -584,7 +571,7 @@ static inline unsigned long ScaleQuantumToLong(const Quantum quantum)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((unsigned long) ((quantum+2147483648.0)/4294967297.0));
 #else
-  return((unsigned long) (quantum/4294967297.0+0.5));
+  return((unsigned long) (quantum/4294967296.0+0.5));
 #endif
 }
 
@@ -597,7 +584,7 @@ static inline unsigned long ScaleQuantumToMap(const Quantum quantum)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((unsigned long) ((quantum+2147450879.0)/281479271612415.0));
 #else
-  return((unsigned long) (quantum/281479271612415.0)+0.5);
+  return((unsigned long) (quantum/281479271612414.0)+0.5);
 #endif
 }
 
@@ -606,7 +593,7 @@ static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((unsigned short) ((quantum+2147450879.0)/281479271612415.0));
 #else
-  return((unsigned short) (quantum/281479271612415.0+0.5));
+  return((unsigned short) (quantum/281479271612414.0+0.5));
 #endif
 }
 
@@ -615,7 +602,7 @@ static inline Quantum ScaleShortToQuantum(const unsigned short value)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((Quantum) (MagickULLConstant(281479271612415)*value));
 #else
-  return((Quantum) (281479271612415.0*value));
+  return((Quantum) (281479271612414.0*value));
 #endif
 }
 #endif

diff --git a/magick/quantum.h b/magick/quantum.h
index 4818602ca348b5062d854b0cb1d4f353ffd0901f..8348068a538d68bd93db103b058e4d7295da9983 100644 (file)
--- a/magick/quantum.h
+++ b/magick/quantum.h
@@ -83,13 +83,13 @@ typedef struct _QuantumInfo
 
 static inline Quantum ClampToQuantum(const MagickRealType value)
 {
-#if defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) value);
-#else
   if (value <= 0.0)
     return((Quantum) 0);
   if (value >= (MagickRealType) QuantumRange)
     return((Quantum) QuantumRange);
+#if defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) value);
+#else
   return((Quantum) (value+0.5));
 #endif
 }
@@ -115,9 +115,9 @@ static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
 #else
   if (quantum <= 0.0)
     return(0);
-  if ((quantum/257.0) >= 255.0)
+  if ((quantum/256.0) >= 255.0)
     return(255);
-  return((unsigned char) (quantum/257.0+0.5));
+  return((unsigned char) (quantum/256.0+0.5));
 #endif
 }
 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
@@ -129,9 +129,9 @@ static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
 #else
   if (quantum <= 0.0)
     return(0);
-  if ((quantum/16843009.0) >= 255.0)
+  if ((quantum/16843008.0) >= 255.0)
     return(255);
-  return((unsigned char) (quantum/16843009.0+0.5));
+  return((unsigned char) (quantum/16843008.0+0.5));
 #endif
 }
 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
@@ -140,7 +140,7 @@ static inline unsigned char ScaleQuantumToChar(const Quantum quantum)
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   return((unsigned char) ((quantum+2155839615.0)/71777214294589695.0));
 #else
-  return((unsigned char) (quantum/71777214294589695.0+0.5));
+  return((unsigned char) (quantum/71777214294589694.0+0.5));
 #endif
 }
 #endif