(no commit message)

diff --git a/ChangeLog b/ChangeLog
index 737338d2f61aae40db1162b0959b9fbf3596d8e2..086055a10da4c7d41e0bfa9fadaa2de8fe1d28de 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -10,6 +10,8 @@
   * Compute the proper DPX user data field size.
   * Do not interpret a format specifier when enclosed in brackets (e.g.
     rose_tile_%[filename:tile].gif.
+  * Use 64-bit types when compiling with the 64-bit Visual C++ compiler under
+    Windows.
 
 2010-05-23  6.6.2.0 Anthony Thyssen <A.Thyssen@griffith...>
   * Third Re-write of MorphologyApply() to better handle compound methods.

diff --git a/magick/accelerate.c b/magick/accelerate.c
index 10470c524320212a6a7faebeb23fbdd9d31574ae..2e627431218147420b9521f258c595fdc426fcfe 100644 (file)
--- a/magick/accelerate.c
+++ b/magick/accelerate.c
@@ -133,7 +133,7 @@
 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
 #define CLOptions "-DCLQuantum=ussize_t -DCLPixelType=ussize_t4 " \
   "-DQuantumRange=%g -DMagickEpsilon=%g"
-#define CLPixelPacket  cl_ussize_t4
+#define CLPixelPacket  cl_ulong4
 #endif
 #endif
 
@@ -158,7 +158,7 @@ typedef struct _ConvolveInfo
     pixels,
     convolve_pixels;
 
-  cl_ussize_t
+  cl_ulong
     width,
     height;
 
@@ -171,12 +171,12 @@ typedef struct _ConvolveInfo
 
 static char
   *ConvolveKernel =
-    "static inline ssize_t ClampToCanvas(const ssize_t offset,const ussize_t range)\n"
+    "static inline long ClampToCanvas(const long offset,const unsigned long range)\n"
     "{\n"
     "  if (offset < 0L)\n"
     "    return(0L);\n"
     "  if (offset >= range)\n"
-    "    return((ssize_t) (range-1L));\n"
+    "    return((long) (range-1L));\n"
     "  return(offset);\n"
     "}\n"
     "\n"
@@ -194,21 +194,21 @@ static char
     "}\n"
     "\n"
     "__kernel void Convolve(const __global CLPixelType *input,\n"
-    "  __constant double *filter,const ussize_t width,const ussize_t height,\n"
+    "  __constant double *filter,const unsigned long width,const unsigned long height,\n"
     "  const bool matte,__global CLPixelType *output)\n"
     "{\n"
-    "  const ussize_t columns = get_global_size(0);\n"
-    "  const ussize_t rows = get_global_size(1);\n"
+    "  const unsigned long columns = get_global_size(0);\n"
+    "  const unsigned long rows = get_global_size(1);\n"
     "\n"
-    "  const ssize_t x = get_global_id(0);\n"
-    "  const ssize_t y = get_global_id(1);\n"
+    "  const long x = get_global_id(0);\n"
+    "  const long y = get_global_id(1);\n"
     "\n"
     "  const double scale = (1.0/QuantumRange);\n"
-    "  const ssize_t mid_width = (width-1)/2;\n"
-    "  const ssize_t mid_height = (height-1)/2;\n"
+    "  const long mid_width = (width-1)/2;\n"
+    "  const long mid_height = (height-1)/2;\n"
     "  double4 sum = { 0.0, 0.0, 0.0, 0.0 };\n"
     "  double gamma = 0.0;\n"
-    "  register ussize_t i = 0;\n"
+    "  register unsigned long i = 0;\n"
     "\n"
     "  int method = 0;\n"
     "  if (matte != false)\n"
@@ -224,11 +224,11 @@ static char
     "  {\n"
     "    case 0:\n"
     "    {\n"
-    "      for (ssize_t v=(-mid_height); v <= mid_height; v++)\n"
+    "      for (long v=(-mid_height); v <= mid_height; v++)\n"
     "      {\n"
-    "        for (ssize_t u=(-mid_width); u <= mid_width; u++)\n"
+    "        for (long u=(-mid_width); u <= mid_width; u++)\n"
     "        {\n"
-    "          const ssize_t index=ClampToCanvas(y+v,rows)*columns+\n"
+    "          const long index=ClampToCanvas(y+v,rows)*columns+\n"
     "            ClampToCanvas(x+u,columns);\n"
     "          sum.x+=filter[i]*input[index].x;\n"
     "          sum.y+=filter[i]*input[index].y;\n"
@@ -241,11 +241,11 @@ static char
     "    }\n"
     "    case 1:\n"
     "    {\n"
-    "      for (ssize_t v=(-mid_height); v <= mid_height; v++)\n"
+    "      for (long v=(-mid_height); v <= mid_height; v++)\n"
     "      {\n"
-    "        for (ssize_t u=(-mid_width); u <= mid_width; u++)\n"
+    "        for (long u=(-mid_width); u <= mid_width; u++)\n"
     "        {\n"
-    "          const ussize_t index=ClampToCanvas(y+v,rows)*columns+\n"
+    "          const unsigned long index=ClampToCanvas(y+v,rows)*columns+\n"
     "            ClampToCanvas(x+u,columns);\n"
     "          const double alpha=scale*(QuantumRange-input[index].w);\n"
     "          sum.x+=alpha*filter[i]*input[index].x;\n"
@@ -260,11 +260,11 @@ static char
     "    }\n"
     "    case 2:\n"
     "    {\n"
-    "      for (ssize_t v=(-mid_height); v <= mid_height; v++)\n"
+    "      for (long v=(-mid_height); v <= mid_height; v++)\n"
     "      {\n"
-    "        for (ssize_t u=(-mid_width); u <= mid_width; u++)\n"
+    "        for (long u=(-mid_width); u <= mid_width; u++)\n"
     "        {\n"
-    "          const ussize_t index=(y+v)*columns+(x+u);\n"
+    "          const unsigned long index=(y+v)*columns+(x+u);\n"
     "          sum.x+=filter[i]*input[index].x;\n"
     "          sum.y+=filter[i]*input[index].y;\n"
     "          sum.z+=filter[i]*input[index].z;\n"
@@ -276,11 +276,11 @@ static char
     "    }\n"
     "    case 3:\n"
     "    {\n"
-    "      for (ssize_t v=(-mid_height); v <= mid_height; v++)\n"
+    "      for (long v=(-mid_height); v <= mid_height; v++)\n"
     "      {\n"
-    "        for (ssize_t u=(-mid_width); u <= mid_width; u++)\n"
+    "        for (long u=(-mid_width); u <= mid_width; u++)\n"
     "        {\n"
-    "          const ussize_t index=(y+v)*columns+(x+u);\n"
+    "          const unsigned long index=(y+v)*columns+(x+u);\n"
     "          const double alpha=scale*(QuantumRange-input[index].w);\n"
     "          sum.x+=alpha*filter[i]*input[index].x;\n"
     "          sum.y+=alpha*filter[i]*input[index].y;\n"
@@ -294,7 +294,7 @@ static char
     "    }\n"
     "  }\n"
     "  gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);\n"
-    "  const ussize_t index = y*columns+x;\n"
+    "  const unsigned long index = y*columns+x;\n"
     "  output[index].x=ClampToQuantum(gamma*sum.x);\n"
     "  output[index].y=ClampToQuantum(gamma*sum.y);\n"
     "  output[index].z=ClampToQuantum(gamma*sum.z);\n"
@@ -324,7 +324,7 @@ static MagickBooleanType BindConvolveParameters(ConvolveInfo *convolve_info,
   cl_int
     status;
 
-  register int
+  register cl_uint
     i;
 
   size_t
@@ -334,19 +334,21 @@ static MagickBooleanType BindConvolveParameters(ConvolveInfo *convolve_info,
     Allocate OpenCL buffers.
   */
   length=image->columns*image->rows;
-  convolve_info->pixels=clCreateBuffer(convolve_info->context,CL_MEM_READ_ONLY |
-    CL_MEM_USE_HOST_PTR,length*sizeof(CLPixelPacket),(void *) pixels,&status);
+  convolve_info->pixels=clCreateBuffer(convolve_info->context,(cl_mem_flags)
+    (CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR),length*sizeof(CLPixelPacket),
+    (void *) pixels,&status);
   if ((convolve_info->pixels == (cl_mem) NULL) || (status != CL_SUCCESS))
     return(MagickFalse);
   length=width*height;
-  convolve_info->filter=clCreateBuffer(convolve_info->context,CL_MEM_READ_ONLY |
-    CL_MEM_USE_HOST_PTR,length*sizeof(cl_double),filter,&status);
+  convolve_info->filter=clCreateBuffer(convolve_info->context,(cl_mem_flags)
+    (CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR),length*sizeof(cl_double),filter,
+    &status);
   if ((convolve_info->filter == (cl_mem) NULL) || (status != CL_SUCCESS))
     return(MagickFalse);
   length=image->columns*image->rows;
   convolve_info->convolve_pixels=clCreateBuffer(convolve_info->context,
-    CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR,length*sizeof(CLPixelPacket),
-    convolve_pixels,&status);
+    (cl_mem_flags) (CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR),length*
+    sizeof(CLPixelPacket),convolve_pixels,&status);
   if ((convolve_info->convolve_pixels == (cl_mem) NULL) ||
       (status != CL_SUCCESS))
     return(MagickFalse);
@@ -362,13 +364,13 @@ static MagickBooleanType BindConvolveParameters(ConvolveInfo *convolve_info,
     &convolve_info->filter);
   if (status != CL_SUCCESS)
     return(MagickFalse);
-  convolve_info->width=(cl_ussize_t) width;
-  status=clSetKernelArg(convolve_info->kernel,i++,sizeof(cl_ussize_t),(void *)
+  convolve_info->width=(cl_ulong) width;
+  status=clSetKernelArg(convolve_info->kernel,i++,sizeof(cl_ulong),(void *)
     &convolve_info->width);
   if (status != CL_SUCCESS)
     return(MagickFalse);
-  convolve_info->height=(cl_ussize_t) height;
-  status=clSetKernelArg(convolve_info->kernel,i++,sizeof(cl_ussize_t),(void *)
+  convolve_info->height=(cl_ulong) height;
+  status=clSetKernelArg(convolve_info->kernel,i++,sizeof(cl_ulong),(void *)
     &convolve_info->height);
   if (status != CL_SUCCESS)
     return(MagickFalse);
@@ -487,18 +489,20 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
     Create OpenCL context.
   */
   convolve_info->context=clCreateContextFromType((cl_context_properties *)
-    NULL,CL_DEVICE_TYPE_GPU,ConvolveNotify,exception,&status);
+    NULL,(cl_device_type) CL_DEVICE_TYPE_GPU,ConvolveNotify,exception,&status);
   if ((convolve_info->context == (cl_context) NULL) || (status != CL_SUCCESS))
     convolve_info->context=clCreateContextFromType((cl_context_properties *)
-      NULL,CL_DEVICE_TYPE_CPU,ConvolveNotify,exception,&status);
+      NULL,(cl_device_type) CL_DEVICE_TYPE_CPU,ConvolveNotify,exception,
+      &status);
   if ((convolve_info->context == (cl_context) NULL) || (status != CL_SUCCESS))
     convolve_info->context=clCreateContextFromType((cl_context_properties *)
-      NULL,CL_DEVICE_TYPE_DEFAULT,ConvolveNotify,exception,&status);
+      NULL,(cl_device_type) CL_DEVICE_TYPE_DEFAULT,ConvolveNotify,exception,
+      &status);
   if ((convolve_info->context == (cl_context) NULL) || (status != CL_SUCCESS))
     {
       (void) ThrowMagickException(exception,GetMagickModule(),DelegateWarning,
         "failed to create OpenCL context","`%s' (%d)",image->filename,status);
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   /*
@@ -508,7 +512,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
     &length);
   if ((status != CL_SUCCESS) || (length == 0))
     {
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   convolve_info->devices=(cl_device_id *) AcquireMagickMemory(length);
@@ -516,14 +520,14 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
         ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   status=clGetContextInfo(convolve_info->context,CL_CONTEXT_DEVICES,length,
     convolve_info->devices,NULL);
   if (status != CL_SUCCESS)
     {
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   /*
@@ -534,7 +538,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
   if ((convolve_info->command_queue == (cl_command_queue) NULL) ||
       (status != CL_SUCCESS))
     {
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   /*
@@ -544,7 +548,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
     &source,lengths,&status);
   if ((convolve_info->program == (cl_program) NULL) || (status != CL_SUCCESS))
     {
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   (void) FormatMagickString(options,MaxTextExtent,CLOptions,(double)
@@ -561,7 +565,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
       log=(char *) AcquireMagickMemory(length);
       if (log == (char *) NULL)
         {
-          DestroyConvolveInfo(convolve_info);
+          convolve_info=DestroyConvolveInfo(convolve_info);
           return((ConvolveInfo *) NULL);
         }
       status=clGetProgramBuildInfo(convolve_info->program,
@@ -569,7 +573,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
       (void) ThrowMagickException(exception,GetMagickModule(),DelegateWarning,
         "failed to build OpenCL program","`%s' (%s)",image->filename,log);
       log=DestroyString(log);
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   /*
@@ -578,7 +582,7 @@ static ConvolveInfo *GetConvolveInfo(const Image *image,const char *name,
   convolve_info->kernel=clCreateKernel(convolve_info->program,name,&status);
   if ((convolve_info->kernel == (cl_kernel) NULL) || (status != CL_SUCCESS))
     {
-      DestroyConvolveInfo(convolve_info);
+      convolve_info=DestroyConvolveInfo(convolve_info);
       return((ConvolveInfo *) NULL);
     }
   return(convolve_info);

diff --git a/magick/cache.c b/magick/cache.c
index da5da6c7e1a0cdeefff775ad25bb53c30d8e1621..750b570ef06c1a93e9fef3f89b9debac85dd3d92 100644 (file)
--- a/magick/cache.c
+++ b/magick/cache.c
@@ -1965,8 +1965,8 @@ MagickExport PixelPacket *GetAuthenticPixelQueue(const Image *image)
 %
 %  The format of the GetAuthenticPixels() method is:
 %
-%      PixelPacket *GetAuthenticPixels(Image *image,const ssize_t x,const ssize_t y,
-%        const size_t columns,const size_t rows,
+%      PixelPacket *GetAuthenticPixels(Image *image,const ssize_t x,
+%        const ssize_t y,const size_t columns,const size_t rows,
 %        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
@@ -2319,7 +2319,8 @@ MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,const ssize_t x
 %  The format of the GetOneAuthenticPixelFromCache() method is:
 %
 %      MagickBooleanType GetOneAuthenticPixelFromCache(const Image image,
-%        const ssize_t x,const ssize_t y,PixelPacket *pixel,ExceptionInfo *exception)
+%        const ssize_t x,const ssize_t y,PixelPacket *pixel,
+%        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -3137,8 +3138,8 @@ MagickExport const IndexPacket *GetVirtualIndexQueue(const Image *image)
 %
 %      PixelPacket *GetVirtualPixelsFromNexus(const Image *image,
 %        const VirtualPixelMethod method,const ssize_t x,const ssize_t y,
-%        const size_t columns,const size_t rows,
-%        NexusInfo *nexus_info,ExceptionInfo *exception)
+%        const size_t columns,const size_t rows,NexusInfo *nexus_info,
+%        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -4401,8 +4402,8 @@ MagickExport MagickBooleanType PersistPixelCache(Image *image,
 %
 %  The format of the QueueAuthenticNexus() method is:
 %
-%      PixelPacket *QueueAuthenticNexus(Image *image,const ssize_t x,const ssize_t y,
-%        const size_t columns,const size_t rows,
+%      PixelPacket *QueueAuthenticNexus(Image *image,const ssize_t x,
+%        const ssize_t y,const size_t columns,const size_t rows,
 %        NexusInfo *nexus_info,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
@@ -4565,8 +4566,8 @@ static PixelPacket *QueueAuthenticPixelsCache(Image *image,const ssize_t x,
 %
 %  The format of the QueueAuthenticPixels() method is:
 %
-%      PixelPacket *QueueAuthenticPixels(Image *image,const ssize_t x,const ssize_t y,
-%        const size_t columns,const size_t rows,
+%      PixelPacket *QueueAuthenticPixels(Image *image,const ssize_t x,
+%        const ssize_t y,const size_t columns,const size_t rows,
 %        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:

diff --git a/magick/colorspace.c b/magick/colorspace.c
index ac036c6c603269497c15120e011508005ca33b60..0347608e9cd7d6efdfe58cc6c834d2971988deec 100644 (file)
--- a/magick/colorspace.c
+++ b/magick/colorspace.c
@@ -185,20 +185,22 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
   ExceptionInfo
     *exception;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status,
     sync;
 
+  MagickOffsetType
+    progress;
+
   PrimaryInfo
     primary_info;
 
   register ssize_t
     i;
 
+  ssize_t
+    y;
+
   TransformPacket
     *x_map,
     *y_map,
@@ -1401,16 +1403,18 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
   ExceptionInfo
     *exception;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   register ssize_t
     i;
 
+  ssize_t
+    y;
+
   TransformPacket
     *y_map,
     *x_map,

diff --git a/magick/composite.c b/magick/composite.c
index ef1a75fc8d8516f933c4b603048f71e4f36e39ee..1f8c2f0c63c9500d9624f4fa00603b3a3adb93f0 100644 (file)
--- a/magick/composite.c
+++ b/magick/composite.c
@@ -1535,14 +1535,13 @@ MagickExport MagickBooleanType CompositeImageChannel(Image *image,
   Image
     *destination_image;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     modify_outside_overlay,
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     zero;
 
@@ -1558,6 +1557,9 @@ MagickExport MagickBooleanType CompositeImageChannel(Image *image,
   MagickStatusType
     flags;
 
+  ssize_t
+    y;
+
   /*
     Prepare composite image.
   */

diff --git a/magick/distort.c b/magick/distort.c
index 66f23b830d19ee9ca2520769aaf4b06dfd8b167b..549e1acb53272f80c361565ba4750fcbb357d8e7 100644 (file)
--- a/magick/distort.c
+++ b/magick/distort.c
@@ -1942,17 +1942,22 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
     CacheView
       *distort_view;
 
-    ssize_t
-      j,
-      progress,
+    MagickBooleanType
       status;
 
+    MagickOffsetType
+      progress;
+
     MagickPixelPacket
       zero;
 
     ResampleFilter
       **restrict resample_filter;
 
+    ssize_t
+      j,
+      y;
+
     status=MagickTrue;
     progress=0;
     GetMagickPixelPacket(distort_image,&zero);

diff --git a/magick/morphology.c b/magick/morphology.c
index b208e1af6a6ab00dccda7abef8cae5f64d91d922..8f3b6e2cf88f75756d09bf805e2ce2aa9482625f 100644 (file)
--- a/magick/morphology.c
+++ b/magick/morphology.c
@@ -2152,17 +2152,19 @@ static size_t MorphologyPrimitive(const Image *image, Image
 {
 #define MorphologyTag  "Morphology/Image"
 
+  CacheView
+    *p_view,
+    *q_view;
+
   ssize_t
-    progress,
     y, offx, offy,
     changed;
 
   MagickBooleanType
     status;
 
-  CacheView
-    *p_view,
-    *q_view;
+  MagickOffsetType
+    progress;
 
   status=MagickTrue;
   changed=0;

diff --git a/magick/profile.c b/magick/profile.c
index e55949f308d6275fc3c390596ec7c39f55bfe7d3..d22ccae7449219bb4a4dcf2197fad15f725edfa8 100644 (file)
--- a/magick/profile.c
+++ b/magick/profile.c
@@ -991,18 +991,20 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
             int
               intent;
 
-            ssize_t
-              progress,
-              y;
-
             MagickBooleanType
               status;
 
+            MagickOffsetType
+              progress;
+
             size_t
               length,
               source_channels,
               target_channels;
 
+            ssize_t
+              y;
+
             unsigned short
               **restrict source_pixels,
               **restrict target_pixels;

diff --git a/magick/resize.c b/magick/resize.c
index 4bedcf169e6c051d26def129d8d024aff26a6a49..fa2ca435c73b287e3eb6a2c86c8f921f0e559c28 100644 (file)
--- a/magick/resize.c
+++ b/magick/resize.c
@@ -2342,17 +2342,19 @@ MagickExport Image *SampleImage(const Image *image,const size_t columns,
   Image
     *sample_image;
 
-  ssize_t
-    progress,
-    *x_offset,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   register ssize_t
     x;
 
+  ssize_t
+    *x_offset,
+    y;
+
   /*
     Initialize sampled image attributes.
   */

diff --git a/magick/segment.c b/magick/segment.c
index 8b6005a000be41dd87b66f149b2c75cf4af346fa..c1f5e3ed61f683eb16fc750ef7b7e1cf3ac2f269 100644 (file)
--- a/magick/segment.c
+++ b/magick/segment.c
@@ -259,10 +259,8 @@ static MagickBooleanType Classify(Image *image,short **extrema,
     green,
     red;
 
-  ssize_t
-    count,
-    progress,
-    y;
+  MagickOffsetType
+    progress;
 
   MagickRealType
     *free_squares;
@@ -279,6 +277,10 @@ static MagickBooleanType Classify(Image *image,short **extrema,
   size_t
     number_clusters;
 
+  ssize_t
+    count,
+    y;
+
   /*
     Form clusters.
   */

diff --git a/magick/shear.c b/magick/shear.c
index 7d1c9cf4e360c66f44c61db151de34944333ec60..065f47706446803ed7358ab0d6d7bd6fd1d083de 100644 (file)
--- a/magick/shear.c
+++ b/magick/shear.c
@@ -1020,16 +1020,18 @@ static Image *IntegralRotateImage(const Image *image,size_t rotations,
   Image
     *rotate_image;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   RectangleInfo
     page;
 
+  ssize_t
+    y;
+
   /*
     Initialize rotated image attributes.
   */
@@ -1191,7 +1193,7 @@ static Image *IntegralRotateImage(const Image *image,size_t rotations,
         Rotate 180 degrees.
       */
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(MAGICKCORE_FUTURE)
-  #pragma omp parallel for schedule(dynamic,4) shared(progress, status)
+  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 #endif
       for (y=0; y < (ssize_t) image->rows; y++)
       {
@@ -1267,7 +1269,7 @@ static Image *IntegralRotateImage(const Image *image,size_t rotations,
       */
       GetPixelCacheTileSize(image,&tile_width,&tile_height);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(MAGICKCORE_FUTURE)
-  #pragma omp parallel for schedule(dynamic,4) shared(progress, status)
+  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 #endif
       for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=tile_height)
       {
@@ -1436,16 +1438,18 @@ static MagickBooleanType XShearImage(Image *image,const MagickRealType degrees,
   CacheView
     *image_view;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     background;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -1654,16 +1658,18 @@ static MagickBooleanType YShearImage(Image *image,const MagickRealType degrees,
   CacheView
     *image_view;
 
-  ssize_t
-    progress,
-    x;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     background;
 
+  ssize_t
+    x;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)

diff --git a/magick/statistic.c b/magick/statistic.c
index 010472def62d539606436b82cc27a7b4081f8833..86b7b0daaf80a7ca88dcd248bfc7373769488b07 100644 (file)
--- a/magick/statistic.c
+++ b/magick/statistic.c
@@ -387,13 +387,12 @@ MagickExport Image *EvaluateImages(const Image *images,
   Image
     *evaluate_image;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     **restrict evaluate_pixels,
     zero;
@@ -404,6 +403,9 @@ MagickExport Image *EvaluateImages(const Image *images,
   size_t
     number_images;
 
+  ssize_t
+    y;
+
   /*
     Ensure the image are the same size.
   */
@@ -583,16 +585,18 @@ MagickExport MagickBooleanType EvaluateImageChannel(Image *image,
   CacheView
     *image_view;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   RandomInfo
     **restrict random_info;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -822,13 +826,15 @@ MagickExport MagickBooleanType FunctionImageChannel(Image *image,
   CacheView
     *image_view;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)

diff --git a/magick/threshold.c b/magick/threshold.c
index 825d3dcbb7ec9d87530ed1db6aed264fb9d50a3a..acfb3b2d0734938347c54f85caf185587c392676 100644 (file)
--- a/magick/threshold.c
+++ b/magick/threshold.c
@@ -154,19 +154,21 @@ MagickExport Image *AdaptiveThresholdImage(const Image *image,
   Image
     *threshold_image;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     zero;
 
   MagickRealType
     number_pixels;
 
+  ssize_t
+    y;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -367,13 +369,15 @@ MagickExport MagickBooleanType BilevelImageChannel(Image *image,
   ExceptionInfo
     *exception;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -523,19 +527,21 @@ MagickExport MagickBooleanType BlackThresholdImageChannel(Image *image,
   GeometryInfo
     geometry_info;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     threshold;
 
   MagickStatusType
     flags;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -710,13 +716,15 @@ MagickExport MagickBooleanType ClampImageChannel(Image *image,
   ExceptionInfo
     *exception;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -1353,16 +1361,18 @@ MagickExport MagickBooleanType OrderedPosterizeImageChannel(Image *image,
   CacheView
     *image_view;
 
-  ssize_t
-    progress,
-    y;
-
   LongPixelPacket
     levels;
 
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
+  ssize_t
+    y;
+
   ThresholdMap
     *map;
 
@@ -1636,13 +1646,12 @@ MagickExport MagickBooleanType RandomThresholdImageChannel(Image *image,
   MagickStatusType
     flags;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
+  MagickOffsetType
+    progress;
+
   MagickPixelPacket
     threshold;
 
@@ -1653,6 +1662,9 @@ MagickExport MagickBooleanType RandomThresholdImageChannel(Image *image,
   RandomInfo
     **restrict random_info;
 
+  ssize_t
+    y;
+
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -1944,24 +1956,26 @@ MagickExport MagickBooleanType WhiteThresholdImageChannel(Image *image,
 {
 #define ThresholdImageTag  "Threshold/Image"
 
+  CacheView
+    *image_view;
+
   GeometryInfo
     geometry_info;
 
-  ssize_t
-    progress,
-    y;
-
   MagickBooleanType
     status;
 
   MagickPixelPacket
     threshold;
 
+  MagickOffsetType
+    progress;
+
   MagickStatusType
     flags;
 
-  CacheView
-    *image_view;
+  ssize_t
+    y;
 
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);