(no commit message)

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index e14f7c9bbce046854352082988ff276aeb936dc8..72100b9b3342c96c7f5134d60f792bc3b10fe565 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -1175,13 +1175,13 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
   register ssize_t
     x;
 
-  register unsigned long
+  register MagickSizeType
     *q;
 
   ssize_t
     y;
 
-  q=(unsigned long *) pixels;
+  q=(MagickSizeType *) pixels;
   if (LocaleCompare(map,"BGR") == 0)
     {
       for (y=0; y < (ssize_t) rows; y++)
@@ -1191,9 +1191,9 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1208,10 +1208,10 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
-          *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1226,9 +1226,9 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
           *q++=0;
           p+=GetPixelChannels(image);
         }
@@ -1244,7 +1244,7 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1259,9 +1259,9 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1276,10 +1276,10 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
-          *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1294,9 +1294,9 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelRed(image,p));
-          *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
-          *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
+          *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
           *q++=0;
           p+=GetPixelChannels(image);
         }
@@ -1321,40 +1321,40 @@ static void ExportLongPixel(const Image *image,const ssize_t x_offset,
           case RedQuantum:
           case CyanQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelRed(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
             break;
           }
           case GreenQuantum:
           case MagentaQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelGreen(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
             break;
           }
           case BlueQuantum:
           case YellowQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelBlue(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
             break;
           }
           case AlphaQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
             break;
           }
           case OpacityQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
             break;
           }
           case BlackQuantum:
           {
             if (image->colorspace == CMYKColorspace)
-              *q=ScaleQuantumToLong(GetPixelBlack(image,p));
+              *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
             break;
           }
           case IndexQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+            *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
             break;
           }
           default:
@@ -3063,7 +3063,7 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
   const char *restrict map,const QuantumType *quantum_map,
   const unsigned char *restrict pixels,ExceptionInfo *exception)
 {
-  register const unsigned long
+  register const MagickSizeType
     *restrict p;
 
   register Quantum
@@ -3075,7 +3075,7 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
   ssize_t
     y;
 
-  p=(const unsigned long *) pixels;
+  p=(const MagickSizeType *) pixels;
   if (LocaleCompare(map,"BGR") == 0)
     {
       for (y=0; y < (ssize_t) rows; y++)
@@ -3085,9 +3085,9 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
           q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3104,10 +3104,10 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
-          SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
           q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3124,9 +3124,9 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
           p++;
           q+=GetPixelChannels(image);
         }
@@ -3144,7 +3144,7 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelGray(image,ScaleLongToQuantum(*p++),q);
+          SetPixelGray(image,ScaleLongLongToQuantum(*p++),q);
           q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3161,9 +3161,9 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
           q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3180,10 +3180,10 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
-          SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
           q+=GetPixelChannels(image);
         }
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
@@ -3200,9 +3200,9 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           break;
         for (x=0; x < (ssize_t) columns; x++)
         {
-          SetPixelRed(image,ScaleLongToQuantum(*p++),q);
-          SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
-          SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
+          SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
+          SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
           p++;
           q+=GetPixelChannels(image);
         }
@@ -3228,39 +3228,39 @@ static void ImportLongPixel(Image *image,const ssize_t x_offset,
           case RedQuantum:
           case CyanQuantum:
           {
-            SetPixelRed(image,ScaleLongToQuantum(*p),q);
+            SetPixelRed(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case GreenQuantum:
           case MagentaQuantum:
           {
-            SetPixelGreen(image,ScaleLongToQuantum(*p),q);
+            SetPixelGreen(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case BlueQuantum:
           case YellowQuantum:
           {
-            SetPixelBlue(image,ScaleLongToQuantum(*p),q);
+            SetPixelBlue(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case AlphaQuantum:
           {
-            SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+            SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case OpacityQuantum:
           {
-            SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
+            SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case BlackQuantum:
           {
-            SetPixelBlack(image,ScaleLongToQuantum(*p),q);
+            SetPixelBlack(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           case IndexQuantum:
           {
-            SetPixelGray(image,ScaleLongToQuantum(*p),q);
+            SetPixelGray(image,ScaleLongLongToQuantum(*p),q);
             break;
           }
           default:

diff --git a/MagickCore/quantum-private.h b/MagickCore/quantum-private.h
index 1e6f2e11e5ec0a5f28e71ca64b86f77d7a87e2ad..6bc11d3818b663e03f970f13f6c0056bbca311a7 100644 (file)
--- a/MagickCore/quantum-private.h
+++ b/MagickCore/quantum-private.h
@@ -322,6 +322,16 @@ static inline Quantum ScaleLongToQuantum(const unsigned int value)
 #endif
 }
 
+static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) ((value+MagickULLConstant(551911719039))/
+    MagickULLConstant(1103823438079)));
+#else
+  return((Quantum) (value/1103823438079.0));
+#endif
+}
+
 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 {
   if (value <= 0.0)
@@ -348,6 +358,19 @@ static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 #endif
 }
 
+static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((MagickSizeType) (MagickULLConstant(551911719039)*quantum));
+#else
+  if (quantum <= 0.0)
+    return(0UL);
+  if ((551911719039.0*quantum) >= 18446744073709551615.0)
+    return(MagickULLConstant(18446744073709551615));
+  return((MagickSizeType) (1103823438079.0*quantum+0.5));
+#endif
+}
+
 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum >= (Quantum) MaxMap)
@@ -402,6 +425,16 @@ static inline Quantum ScaleLongToQuantum(const unsigned int value)
 #endif
 }
 
+static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((Quantum) ((value+MagickULLConstant(8421376))/
+    MagickULLConstant(16842752)));
+#else
+  return((Quantum) (value/16842752.0));
+#endif
+}
+
 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 {
   if (value <= 0.0)
@@ -428,6 +461,19 @@ static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 #endif
 }
 
+static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((MagickSizeType) (MagickULLConstant(16842752)*quantum));
+#else
+  if (quantum <= 0.0)
+    return(0UL);
+  if ((65537.0*quantum) >= 18446744073709551615.0)
+    return(MagickULLConstant(18446744073709551615));
+  return((MagickSizeType) (16842752.0*quantum+0.5));
+#endif
+}
+
 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum >= (Quantum) MaxMap)
@@ -473,6 +519,11 @@ static inline Quantum ScaleLongToQuantum(const unsigned int value)
   return((Quantum) value);
 }
 
+static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
+{
+  return((Quantum) value);
+}
+
 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 {
   if (value <= 0.0)
@@ -495,6 +546,15 @@ static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
 #endif
 }
 
+static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
+{
+#if !defined(MAGICKCORE_HDRI_SUPPORT)
+  return((MagickSizeType) quantum);
+#else
+  return((MagickSizeType) (quantum+0.5));
+#endif
+}
+
 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum < 0.0)
@@ -542,6 +602,11 @@ static inline Quantum ScaleLongToQuantum(const unsigned int value)
   return((Quantum) (4294967297.0*value));
 }
 
+static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
+{
+  return((Quantum) (18446744073709551615.0*value));
+}
+
 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
 {
   if (value <= 0.0)
@@ -556,6 +621,11 @@ static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
   return((unsigned int) (quantum/4294967297.0+0.5));
 }
 
+static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
+{
+  return((MagickSizeType) (quantum/18446744073709551615.0+0.5));
+}
+
 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
 {
   if (quantum <= 0.0)