(no commit message)

diff --git a/MagickCore/animate.c b/MagickCore/animate.c
index 3ea023fa9191e2b67f189f69b343d641c0ed5d63..0e94968c6d8d8d7410c08d3dfa3ddb1c6b5b371f 100644 (file)
--- a/MagickCore/animate.c
+++ b/MagickCore/animate.c
@@ -317,10 +317,8 @@ MagickExport MagickBooleanType AnimateImages(const ImageInfo *image_info,
   resource_info.immutable=MagickTrue;
   argv[0]=AcquireString(GetClientName());
   (void) XAnimateImages(display,&resource_info,argv,1,images,exception);
-  SetErrorHandler((ErrorHandler) NULL);
-  SetWarningHandler((WarningHandler) NULL);
-  SetErrorHandler((ErrorHandler) NULL);
-  SetWarningHandler((WarningHandler) NULL);
+  (void) SetErrorHandler((ErrorHandler) NULL);
+  (void) SetWarningHandler((WarningHandler) NULL);
   argv[0]=DestroyString(argv[0]);
   (void) XCloseDisplay(display);
   XDestroyResourceInfo(&resource_info);

diff --git a/MagickCore/colormap.c b/MagickCore/colormap.c
index 92c46be42cdfb93cac4d3ccc02da6c0765e81e59..418ba5e31308f0775f47e7c50682228e07479443 100644 (file)
--- a/MagickCore/colormap.c
+++ b/MagickCore/colormap.c
@@ -136,13 +136,13 @@ MagickExport MagickBooleanType AcquireImageColormap(Image *image,
       image->filename);
   for (i=0; i < (ssize_t) image->colors; i++)
   {
-    size_t
+    double
       pixel;
 
-    pixel=(size_t) (i*(QuantumRange/MagickMax(colors-1,1)));
-    image->colormap[i].red=(Quantum) pixel;
-    image->colormap[i].green=(Quantum) pixel;
-    image->colormap[i].blue=(Quantum) pixel;
+    pixel=(double) (i*(QuantumRange/MagickMax(colors-1,1)));
+    image->colormap[i].red=pixel;
+    image->colormap[i].green=pixel;
+    image->colormap[i].blue=pixel;
     image->colormap[i].alpha=OpaqueAlpha;
   }
   return(SetImageStorageClass(image,PseudoClass,exception));
@@ -328,7 +328,7 @@ MagickExport MagickBooleanType SortColormapByIntensity(Image *image,
   #pragma omp parallel for schedule(static,4) shared(status)
 #endif
   for (i=0; i < (ssize_t) image->colors; i++)
-    image->colormap[i].alpha=(Quantum) i;
+    image->colormap[i].alpha=(double) i;
   /*
     Sort image colormap by decreasing color popularity.
   */

diff --git a/MagickCore/display.c b/MagickCore/display.c
index a8a06784ac5a35bc1088c74fc891ba14d24aba32..5fab74291c9cc5c1bfe2c7732660f3e660673d18 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -1701,8 +1701,8 @@ MagickExport MagickBooleanType DisplayImages(const ImageInfo *image_info,
     image=GetImageFromList(images,i % GetImageListLength(images));
     (void) XDisplayImage(display,&resource_info,argv,1,&image,&state,exception);
   }
-  SetErrorHandler((ErrorHandler) NULL);
-  SetWarningHandler((WarningHandler) NULL);
+  (void) SetErrorHandler((ErrorHandler) NULL);
+  (void) SetWarningHandler((WarningHandler) NULL);
   argv[0]=DestroyString(argv[0]);
   (void) XCloseDisplay(display);
   XDestroyResourceInfo(&resource_info);
@@ -3768,10 +3768,10 @@ static MagickBooleanType XColorEditImage(Display *display,
             */
             (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t) x_offset,
               (ssize_t) y_offset,virtual_pixel,exception);
-            target.red=virtual_pixel[RedPixelChannel];
-            target.green=virtual_pixel[GreenPixelChannel];
-            target.blue=virtual_pixel[BluePixelChannel];
-            target.alpha=virtual_pixel[AlphaPixelChannel];
+            target.red=(double) virtual_pixel[RedPixelChannel];
+            target.green=(double) virtual_pixel[GreenPixelChannel];
+            target.blue=(double) virtual_pixel[BluePixelChannel];
+            target.alpha=(double) virtual_pixel[AlphaPixelChannel];
             if ((*image)->storage_class == DirectClass)
               {
                 for (y=0; y < (int) (*image)->rows; y++)
@@ -3803,11 +3803,11 @@ static MagickBooleanType XColorEditImage(Display *display,
                 for (i=0; i < (ssize_t) (*image)->colors; i++)
                   if (IsFuzzyEquivalencePixelInfo((*image)->colormap+i,&target))
                     {
-                      (*image)->colormap[i].red=ScaleShortToQuantum(
+                      (*image)->colormap[i].red=(double) ScaleShortToQuantum(
                         color.red);
-                      (*image)->colormap[i].green=ScaleShortToQuantum(
+                      (*image)->colormap[i].green=(double) ScaleShortToQuantum(
                         color.green);
-                      (*image)->colormap[i].blue=ScaleShortToQuantum(
+                      (*image)->colormap[i].blue=(double) ScaleShortToQuantum(
                         color.blue);
                     }
                 (void) SyncImage(*image,exception);
@@ -10132,10 +10132,10 @@ static MagickBooleanType XMatteEditImage(Display *display,
             */
             (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t) x_offset,
               (ssize_t) y_offset,virtual_pixel,exception);
-            target.red=virtual_pixel[RedPixelChannel];
-            target.green=virtual_pixel[GreenPixelChannel];
-            target.blue=virtual_pixel[BluePixelChannel];
-            target.alpha=virtual_pixel[AlphaPixelChannel];
+            target.red=(double) virtual_pixel[RedPixelChannel];
+            target.green=(double) virtual_pixel[GreenPixelChannel];
+            target.blue=(double) virtual_pixel[BluePixelChannel];
+            target.alpha=(double) virtual_pixel[AlphaPixelChannel];
             for (y=0; y < (int) (*image)->rows; y++)
             {
               q=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,
@@ -10183,8 +10183,8 @@ static MagickBooleanType XMatteEditImage(Display *display,
               }
             draw_info=CloneDrawInfo(resource_info->image_info,
               (DrawInfo *) NULL);
-            draw_info->fill.alpha=ClampToQuantum(StringToDouble(matte,
-              (char **) NULL));
+            draw_info->fill.alpha=(MagickRealType) ClampToQuantum(
+              StringToDouble(matte,(char **) NULL));
             channel_mask=SetPixelChannelMask(*image,AlphaChannel); 
             (void) FloodfillPaintImage(*image,draw_info,&target,(ssize_t)
               x_offset,(ssize_t) y_offset,method == FloodfillMethod ?
@@ -12416,11 +12416,11 @@ static MagickBooleanType XRotateImage(Display *display,
       exception);
   XSetCursorState(display,windows,MagickTrue);
   XCheckRefreshWindows(display,windows);
-  (*image)->background_color.red=ScaleShortToQuantum(
+  (*image)->background_color.red=(double) ScaleShortToQuantum(
     windows->pixel_info->pen_colors[pen_id].red);
-  (*image)->background_color.green=ScaleShortToQuantum(
+  (*image)->background_color.green=(double) ScaleShortToQuantum(
     windows->pixel_info->pen_colors[pen_id].green);
-  (*image)->background_color.blue=ScaleShortToQuantum(
+  (*image)->background_color.blue=(double) ScaleShortToQuantum(
     windows->pixel_info->pen_colors[pen_id].blue);
   rotate_image=RotateImage(*image,degrees,exception);
   XSetCursorState(display,windows,MagickFalse);
@@ -13286,10 +13286,10 @@ static Image *XTileImage(Display *display,XResourceInfo *resource_info,
         image_view=AcquireCacheView(image);
         (void) GetOneCacheViewVirtualPixel(image_view,0,0,virtual_pixel,
           exception);
-        pixel.red=virtual_pixel[RedPixelChannel];
-        pixel.green=virtual_pixel[GreenPixelChannel];
-        pixel.blue=virtual_pixel[BluePixelChannel];
-        pixel.alpha=virtual_pixel[AlphaPixelChannel];
+        pixel.red=(double) virtual_pixel[RedPixelChannel];
+        pixel.green=(double) virtual_pixel[GreenPixelChannel];
+        pixel.blue=(double) virtual_pixel[BluePixelChannel];
+        pixel.alpha=(double) virtual_pixel[AlphaPixelChannel];
         for (i=0; i < (int) height; i++)
         {
           s=GetCacheViewAuthenticPixels(image_view,(ssize_t) x_offset,(ssize_t)

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index 73321d2ae964424d5aff16761f572621ee66464f..c5349e3ecb1b39260e679d2fefd332c00c87a1a1 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -2246,7 +2246,7 @@ MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info,
                 if (graphic_context[n]->clip_mask != (char *) NULL)
                   if (LocaleCompare(graphic_context[n]->clip_mask,
                       graphic_context[n-1]->clip_mask) != 0)
-                    SetImageMask(image,(Image *) NULL,exception);
+                    (void) SetImageMask(image,(Image *) NULL,exception);
                 graphic_context[n]=DestroyDrawInfo(graphic_context[n]);
                 n--;
                 break;

diff --git a/MagickCore/geometry.c b/MagickCore/geometry.c
index f138dde798c3945fb3d4a612f7e1700c2606d9dd..0b642cc35ee3fad5f9bf525ddb55e8ed697b67bb 100644 (file)
--- a/MagickCore/geometry.c
+++ b/MagickCore/geometry.c
@@ -1275,8 +1275,8 @@ MagickExport MagickStatusType ParseMetaGeometry(const char *geometry,ssize_t *x,
       (void) ParseGeometry(geometry,&geometry_info);
       area=geometry_info.rho;
       distance=sqrt((double) former_width*former_height);
-      scale.x=former_width/(distance/sqrt((double) area));
-      scale.y=former_height/(distance/sqrt((double) area));
+      scale.x=(double) former_width/(distance/sqrt((double) area));
+      scale.y=(double) former_height/(distance/sqrt((double) area));
       if ((scale.x < (double) *width) || (scale.y < (double) *height))
         {
           *width=(size_t) (former_width/(distance/sqrt(area))+0.5);

diff --git a/MagickCore/histogram.c b/MagickCore/histogram.c
index 67bc0d3d1d535cf216fdb6d480f4773b601b8fab..b1dc5b0ad30cc6b26e44425e5c37b34d33537870 100644 (file)
--- a/MagickCore/histogram.c
+++ b/MagickCore/histogram.c
@@ -279,12 +279,12 @@ static CubeInfo *ClassifyImageColors(const Image *image,
               return(0);
             }
           node_info->list[i]=pixel;
-          node_info->list[i].red=GetPixelRed(image,p);
-          node_info->list[i].green=GetPixelGreen(image,p);
-          node_info->list[i].blue=GetPixelBlue(image,p);
+          node_info->list[i].red=(double) GetPixelRed(image,p);
+          node_info->list[i].green=(double) GetPixelGreen(image,p);
+          node_info->list[i].blue=(double) GetPixelBlue(image,p);
           if (image->colorspace == CMYKColorspace)
-            node_info->list[i].black=GetPixelBlack(image,p);
-          node_info->list[i].alpha=GetPixelAlpha(image,p);
+            node_info->list[i].black=(double) GetPixelBlack(image,p);
+          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
           node_info->list[i].count=1;
           node_info->number_unique++;
           cube_info->colors++;
@@ -745,12 +745,12 @@ MagickExport MagickBooleanType IsHistogramImage(const Image *image,
                 image->filename);
               break;
             }
-          node_info->list[i].red=GetPixelRed(image,p);
-          node_info->list[i].green=GetPixelGreen(image,p);
-          node_info->list[i].blue=GetPixelBlue(image,p);
+          node_info->list[i].red=(double) GetPixelRed(image,p);
+          node_info->list[i].green=(double) GetPixelGreen(image,p);
+          node_info->list[i].blue=(double) GetPixelBlue(image,p);
           if (image->colorspace == CMYKColorspace)
-            node_info->list[i].black=GetPixelBlack(image,p);
-          node_info->list[i].alpha=GetPixelAlpha(image,p);
+            node_info->list[i].black=(double) GetPixelBlack(image,p);
+          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
           node_info->list[i].count=1;
           node_info->number_unique++;
           cube_info->colors++;
@@ -906,12 +906,12 @@ MagickExport MagickBooleanType IsPaletteImage(const Image *image,
               break;
             }
           node_info->list[i]=pixel;
-          node_info->list[i].red=GetPixelRed(image,p);
-          node_info->list[i].green=GetPixelGreen(image,p);
-          node_info->list[i].blue=GetPixelBlue(image,p);
+          node_info->list[i].red=(double) GetPixelRed(image,p);
+          node_info->list[i].green=(double) GetPixelGreen(image,p);
+          node_info->list[i].blue=(double) GetPixelBlue(image,p);
           if (image->colorspace == CMYKColorspace)
-            node_info->list[i].black=GetPixelBlack(image,p);
-          node_info->list[i].alpha=GetPixelAlpha(image,p);
+            node_info->list[i].black=(double) GetPixelBlack(image,p);
+          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
           node_info->list[i].count=1;
           node_info->number_unique++;
           cube_info->colors++;
@@ -1241,12 +1241,12 @@ static void UniqueColorsToImage(Image *unique_image,CacheView *unique_view,
           exception);
         if (q == (Quantum *) NULL)
           continue;
-        SetPixelRed(unique_image,p->red,q);
-        SetPixelGreen(unique_image,p->green,q);
-        SetPixelBlue(unique_image,p->blue,q);
-        SetPixelAlpha(unique_image,p->alpha,q);
+        SetPixelRed(unique_image,ClampToQuantum(p->red),q);
+        SetPixelGreen(unique_image,ClampToQuantum(p->green),q);
+        SetPixelBlue(unique_image,ClampToQuantum(p->blue),q);
+        SetPixelAlpha(unique_image,ClampToQuantum(p->alpha),q);
         if (unique_image->colorspace == CMYKColorspace)
-          SetPixelBlack(unique_image,p->black,q);
+          SetPixelBlack(unique_image,ClampToQuantum(p->black),q);
         if (SyncCacheViewAuthenticPixels(unique_view,exception) == MagickFalse)
           break;
         cube_info->x++;

diff --git a/MagickCore/montage.c b/MagickCore/montage.c
index 74900923ae6b8560dfaeb66d21059cd4da2d470d..a3d07e33cff71e8211b83507bf4796aca60ef1e9 100644 (file)
--- a/MagickCore/montage.c
+++ b/MagickCore/montage.c
@@ -637,8 +637,8 @@ MagickExport Image *MontageImageList(const ImageInfo *image_info,
     */
     (void) CopyMagickString(montage->filename,montage_info->filename,
       MaxTextExtent);
-    montage->columns=MagickMax(bounds.width,1);
-    montage->rows=MagickMax(bounds.height,1);
+    montage->columns=(size_t) MagickMax((ssize_t) bounds.width,1);
+    montage->rows=(size_t) MagickMax((ssize_t) bounds.height,1);
     (void) SetImageBackgroundColor(montage,exception);
     /*
       Set montage geometry.

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index ec8a7c3320e620de64083a5e055e634c7af23d04..1e17fee7a050705399a7a4e604e926630643d1e4 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -1382,8 +1382,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[3] = +MagickSQ2;
-            kernel->values[5] = -MagickSQ2;
+            kernel->values[3]+=(MagickRealType) MagickSQ2;
+            kernel->values[5]-=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             break;
           case 2:
@@ -1391,8 +1391,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[1] = kernel->values[3] = +MagickSQ2;
-            kernel->values[5] = kernel->values[7] = -MagickSQ2;
+            kernel->values[1] = kernel->values[3]+=(MagickRealType) MagickSQ2;
+            kernel->values[5] = kernel->values[7]-=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1407,8 +1407,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[3] = +MagickSQ2;
-            kernel->values[5] = -MagickSQ2;
+            kernel->values[3]+=(MagickRealType) MagickSQ2;
+            kernel->values[5]-=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);     /* recalculate meta-data */
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1417,8 +1417,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[1] = +MagickSQ2;
-            kernel->values[7] = +MagickSQ2;
+            kernel->values[1]+=(MagickRealType) MagickSQ2;
+            kernel->values[7]+=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1427,8 +1427,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[0] = +MagickSQ2;
-            kernel->values[8] = -MagickSQ2;
+            kernel->values[0]+=(MagickRealType) MagickSQ2;
+            kernel->values[8]-=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -1437,8 +1437,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             if (kernel == (KernelInfo *) NULL)
               return(kernel);
             kernel->type = type;
-            kernel->values[2] = -MagickSQ2;
-            kernel->values[6] = +MagickSQ2;
+            kernel->values[2]-=(MagickRealType) MagickSQ2;
+            kernel->values[6]+=(MagickRealType) MagickSQ2;
             CalcKernelMetaData(kernel);
             ScaleKernelInfo(kernel, (double) (1.0/2.0*MagickSQ2), NoValue);
             break;
@@ -4474,7 +4474,8 @@ static void RotateKernelInfo(KernelInfo *kernel, double angle)
         j;
 
       k=kernel->values;
-      for ( i=0, j=kernel->width*kernel->height-1;  i<j;  i++, j--)
+      j=(ssize_t) (kernel->width*kernel->height-1);
+      for (i=0;  i < j;  i++, j--)
         t=k[i],  k[i]=k[j],  k[j]=t;
 
       kernel->x = (ssize_t) kernel->width  - kernel->x - 1;

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 02574e1e0ace734658703ba59629307836baee27..35f2e53b2800091bf6ea61ed128a1772d171b314 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -620,11 +620,15 @@ static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
               SetPixelIndex(image,(Quantum) index,q);
             if (cube.quantize_info->measure_error == MagickFalse)
               {
-                SetPixelRed(image,image->colormap[index].red,q);
-                SetPixelGreen(image,image->colormap[index].green,q);
-                SetPixelBlue(image,image->colormap[index].blue,q);
+                SetPixelRed(image,ClampToQuantum(
+                  image->colormap[index].red),q);
+                SetPixelGreen(image,ClampToQuantum(
+                  image->colormap[index].green),q);
+                SetPixelBlue(image,ClampToQuantum(
+                  image->colormap[index].blue),q);
                 if (cube.associate_alpha != MagickFalse)
-                  SetPixelAlpha(image,image->colormap[index].alpha,q);
+                  SetPixelAlpha(image,ClampToQuantum(
+                    image->colormap[index].alpha),q);
               }
             q+=GetPixelChannels(image);
           }
@@ -652,7 +656,7 @@ static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
   if ((cube_info->quantize_info->number_colors == 2) &&
       (cube_info->quantize_info->colorspace == GRAYColorspace))
     {
-      Quantum
+      double
         intensity;
 
       register PixelInfo
@@ -667,7 +671,7 @@ static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
       q=image->colormap;
       for (i=0; i < (ssize_t) image->colors; i++)
       {
-        intensity=(Quantum) ((MagickRealType) GetPixelInfoIntensity(q) <
+        intensity=(double) ((MagickRealType) GetPixelInfoIntensity(q) <
           ((MagickRealType) QuantumRange/2.0) ? 0 : QuantumRange);
         q->red=intensity;
         q->green=intensity;
@@ -1251,12 +1255,12 @@ static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
       alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
       if (cube_info->associate_alpha == MagickFalse)
         {
-          q->red=ClampToQuantum((MagickRealType)
+          q->red=(double) ClampToQuantum((MagickRealType)
             (alpha*QuantumRange*node_info->total_color.red));
-          q->green=ClampToQuantum((MagickRealType)
+          q->green=(double) ClampToQuantum((MagickRealType)
             (alpha*QuantumRange*node_info->total_color.green));
-          q->blue=ClampToQuantum((MagickRealType)
-            (alpha*QuantumRange*node_info->total_color.blue));
+          q->blue=(double) ClampToQuantum((MagickRealType)
+            (alpha*(double) QuantumRange*node_info->total_color.blue));
           q->alpha=OpaqueAlpha;
         }
       else
@@ -1266,14 +1270,14 @@ static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
 
           opacity=(MagickRealType) (alpha*QuantumRange*
             node_info->total_color.alpha);
-          q->alpha=ClampToQuantum(opacity);
+          q->alpha=(double) ClampToQuantum(opacity);
           if (q->alpha == OpaqueAlpha)
             {
-              q->red=ClampToQuantum((MagickRealType)
+              q->red=(double) ClampToQuantum((MagickRealType)
                 (alpha*QuantumRange*node_info->total_color.red));
-              q->green=ClampToQuantum((MagickRealType)
+              q->green=(double) ClampToQuantum((MagickRealType)
                 (alpha*QuantumRange*node_info->total_color.green));
-              q->blue=ClampToQuantum((MagickRealType)
+              q->blue=(double) ClampToQuantum((MagickRealType)
                 (alpha*QuantumRange*node_info->total_color.blue));
             }
           else
@@ -1283,11 +1287,11 @@ static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
 
               gamma=(MagickRealType) (QuantumScale*q->alpha);
               gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
-              q->red=ClampToQuantum((MagickRealType)
+              q->red=(double) ClampToQuantum((MagickRealType)
                 (alpha*gamma*QuantumRange*node_info->total_color.red));
-              q->green=ClampToQuantum((MagickRealType)
+              q->green=(double) ClampToQuantum((MagickRealType)
                 (alpha*gamma*QuantumRange*node_info->total_color.green));
-              q->blue=ClampToQuantum((MagickRealType)
+              q->blue=(double) ClampToQuantum((MagickRealType)
                 (alpha*gamma*QuantumRange*node_info->total_color.blue));
               if (node_info->number_unique > cube_info->transparent_pixels)
                 {
@@ -1622,11 +1626,11 @@ static MagickBooleanType FloydSteinbergDither(Image *image,CubeInfo *cube_info,
         SetPixelIndex(image,(Quantum) index,q);
       if (cube.quantize_info->measure_error == MagickFalse)
         {
-          SetPixelRed(image,image->colormap[index].red,q);
-          SetPixelGreen(image,image->colormap[index].green,q);
-          SetPixelBlue(image,image->colormap[index].blue,q);
+          SetPixelRed(image,ClampToQuantum(image->colormap[index].red),q);
+          SetPixelGreen(image,ClampToQuantum(image->colormap[index].green),q);
+          SetPixelBlue(image,ClampToQuantum(image->colormap[index].blue),q);
           if (cube.associate_alpha != MagickFalse)
-            SetPixelAlpha(image,image->colormap[index].alpha,q);
+            SetPixelAlpha(image,ClampToQuantum(image->colormap[index].alpha),q);
         }
       if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
         status=MagickFalse;
@@ -1879,11 +1883,11 @@ static MagickBooleanType RiemersmaDither(Image *image,CacheView *image_view,
         SetPixelIndex(image,(Quantum) index,q);
       if (cube_info->quantize_info->measure_error == MagickFalse)
         {
-          SetPixelRed(image,image->colormap[index].red,q);
-          SetPixelGreen(image,image->colormap[index].green,q);
-          SetPixelBlue(image,image->colormap[index].blue,q);
+          SetPixelRed(image,ClampToQuantum(image->colormap[index].red),q);
+          SetPixelGreen(image,ClampToQuantum(image->colormap[index].green),q);
+          SetPixelBlue(image,ClampToQuantum(image->colormap[index].blue),q);
           if (cube_info->associate_alpha != MagickFalse)
-            SetPixelAlpha(image,image->colormap[index].alpha,q);
+            SetPixelAlpha(image,ClampToQuantum(image->colormap[index].alpha),q);
         }
       if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
         return(MagickFalse);
@@ -2384,13 +2388,17 @@ MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
         Posterize colormap.
       */
       if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
-        image->colormap[i].red=PosterizePixel(image->colormap[i].red);
+        image->colormap[i].red=(double)
+          PosterizePixel(image->colormap[i].red);
       if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
-        image->colormap[i].green=PosterizePixel(image->colormap[i].green);
+        image->colormap[i].green=(double)
+          PosterizePixel(image->colormap[i].green);
       if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
-        image->colormap[i].blue=PosterizePixel(image->colormap[i].blue);
+        image->colormap[i].blue=(double)
+          PosterizePixel(image->colormap[i].blue);
       if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
-        image->colormap[i].alpha=PosterizePixel(image->colormap[i].alpha);
+        image->colormap[i].alpha=(double)
+          PosterizePixel(image->colormap[i].alpha);
     }
   /*
     Posterize image.
@@ -2689,10 +2697,10 @@ static MagickBooleanType DirectToColormapImage(Image *image,
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      image->colormap[i].red=GetPixelRed(image,q);
-      image->colormap[i].green=GetPixelGreen(image,q);
-      image->colormap[i].blue=GetPixelBlue(image,q);
-      image->colormap[i].alpha=GetPixelAlpha(image,q);
+      image->colormap[i].red=(double) GetPixelRed(image,q);
+      image->colormap[i].green=(double) GetPixelGreen(image,q);
+      image->colormap[i].blue=(double) GetPixelBlue(image,q);
+      image->colormap[i].alpha=(double) GetPixelAlpha(image,q);
       SetPixelIndex(image,(Quantum) i,q);
       i++;
       q+=GetPixelChannels(image);
@@ -3328,9 +3336,12 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
               if (colormap_index[intensity] < 0)
                 {
                   colormap_index[intensity]=(ssize_t) image->colors;
-                  image->colormap[image->colors].red=GetPixelRed(image,q);
-                  image->colormap[image->colors].green=GetPixelGreen(image,q);
-                  image->colormap[image->colors].blue=GetPixelBlue(image,q);
+                  image->colormap[image->colors].red=(double)
+                    GetPixelRed(image,q);
+                  image->colormap[image->colors].green=(double)
+                    GetPixelGreen(image,q);
+                  image->colormap[image->colors].blue=(double)
+                    GetPixelBlue(image,q);
                   image->colors++;
                }
             }
@@ -3344,7 +3355,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
       image_view=DestroyCacheView(image_view);
     }
   for (i=0; i < (ssize_t) image->colors; i++)
-    image->colormap[i].alpha=(unsigned short) i;
+    image->colormap[i].alpha=(double) i;
   qsort((void *) image->colormap,image->colors,sizeof(PixelInfo),
     IntensityCompare);
   colormap=(PixelInfo *) AcquireQuantumMemory(image->colors,

diff --git a/MagickCore/segment.c b/MagickCore/segment.c
index de5bc44e827a18671d23f8e4a72d74720ea9082d..ebdf8b6f4269ea392e2a2f643d251c9187e51186 100644 (file)
--- a/MagickCore/segment.c
+++ b/MagickCore/segment.c
@@ -517,11 +517,11 @@ static MagickBooleanType Classify(Image *image,short **extrema,
   i=0;
   for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
   {
-    image->colormap[i].red=ScaleCharToQuantum((unsigned char)
+    image->colormap[i].red=(double) ScaleCharToQuantum((unsigned char)
       (cluster->red.center+0.5));
-    image->colormap[i].green=ScaleCharToQuantum((unsigned char)
+    image->colormap[i].green=(double) ScaleCharToQuantum((unsigned char)
       (cluster->green.center+0.5));
-    image->colormap[i].blue=ScaleCharToQuantum((unsigned char)
+    image->colormap[i].blue=(double) ScaleCharToQuantum((unsigned char)
       (cluster->blue.center+0.5));
     i++;
   }
@@ -602,22 +602,22 @@ static MagickBooleanType Classify(Image *image,short **extrema,
             p=image->colormap+j;
             distance_squared=squares[(ssize_t) ScaleQuantumToChar(
               GetPixelRed(image,q))-(ssize_t)
-              ScaleQuantumToChar(p->red)]+squares[(ssize_t)
+              ScaleQuantumToChar(ClampToQuantum(p->red))]+squares[(ssize_t)
               ScaleQuantumToChar(GetPixelGreen(image,q))-(ssize_t)
-              ScaleQuantumToChar(p->green)]+squares[(ssize_t)
+              ScaleQuantumToChar(ClampToQuantum(p->green))]+squares[(ssize_t)
               ScaleQuantumToChar(GetPixelBlue(image,q))-(ssize_t)
-              ScaleQuantumToChar(p->blue)];
+              ScaleQuantumToChar(ClampToQuantum(p->blue))];
             numerator=distance_squared;
             for (k=0; k < (ssize_t) image->colors; k++)
             {
               p=image->colormap+k;
                 distance_squared=squares[(ssize_t) ScaleQuantumToChar(
                   GetPixelRed(image,q))-(ssize_t)
-                  ScaleQuantumToChar(p->red)]+squares[(ssize_t)
-                  ScaleQuantumToChar(GetPixelGreen(image,q))-(ssize_t)
-                  ScaleQuantumToChar(p->green)]+squares[(ssize_t)
-                  ScaleQuantumToChar(GetPixelBlue(image,q))-(ssize_t)
-                  ScaleQuantumToChar(p->blue)];
+                  ScaleQuantumToChar(ClampToQuantum(p->red))]+squares[
+                  (ssize_t) ScaleQuantumToChar(GetPixelGreen(image,q))-(ssize_t)
+                  ScaleQuantumToChar(ClampToQuantum(p->green))]+squares[
+                  (ssize_t) ScaleQuantumToChar(GetPixelBlue(image,q))-(ssize_t)
+                  ScaleQuantumToChar(ClampToQuantum(p->blue))];
               ratio=numerator/distance_squared;
               sum+=SegmentPower(ratio);
             }

diff --git a/MagickCore/statistic.c b/MagickCore/statistic.c
index fc8ed22b9a379ad6878a06be4beaadca59d84ebd..e335bed4f22dead749e7fb0dcea1b3824b8dbd81 100644 (file)
--- a/MagickCore/statistic.c
+++ b/MagickCore/statistic.c
@@ -1475,9 +1475,9 @@ MagickExport MagickBooleanType GetImageRange(const Image *image,double *minima,
         #pragma omp critical (MagickCore_GetImageRange)
 #endif
         {
-          if (p[i] < *minima)
+          if ((double) p[i] < *minima)
             *minima=(double) p[i];
-          if (p[i] > *maxima)
+          if ((double) p[i] > *maxima)
             *maxima=(double) p[i];
         }
       }

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index 57e38dab08a4e8db668680284b8959e5b89546fb..f766d606df9caa09721ae3e2c4021f26d5fd0f19 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -674,10 +674,10 @@ MagickExport MagickBooleanType ClampImage(Image *image,ExceptionInfo *exception)
       q=image->colormap;
       for (i=0; i < (ssize_t) image->colors; i++)
       {
-        q->red=ClampToUnsignedQuantum(q->red);
-        q->green=ClampToUnsignedQuantum(q->green);
-        q->blue=ClampToUnsignedQuantum(q->blue);
-        q->alpha=ClampToUnsignedQuantum(q->alpha);
+        q->red=(double) ClampToUnsignedQuantum(ClampToQuantum(q->red));
+        q->green=(double) ClampToUnsignedQuantum(ClampToQuantum(q->green));
+        q->blue=(double) ClampToUnsignedQuantum(ClampToQuantum(q->blue));
+        q->alpha=(double) ClampToUnsignedQuantum(ClampToQuantum(q->alpha));
         q++;
       }
       return(SyncImage(image,exception));
@@ -1365,8 +1365,9 @@ MagickExport MagickBooleanType OrderedPosterizeImage(Image *image,
         threshold=(ssize_t) (QuantumScale*q[i]*(levels[n]*(map->divisor-1)+1));
         level=threshold/(map->divisor-1);
         threshold-=level*(map->divisor-1);
-        q[i]=RoundToQuantum((level+(threshold >= map->levels[(x % map->width)+
-          map->width*(y % map->height)]))*QuantumRange/levels[n]);
+        q[i]=RoundToQuantum((MagickRealType) (level+(threshold >=
+          map->levels[(x % map->width)+map->width*(y % map->height)]))*
+          QuantumRange/levels[n]);
         n++;
       }
       q+=GetPixelChannels(image);

diff --git a/MagickCore/utility-private.h b/MagickCore/utility-private.h
index 832c1f143566c7f5fcab9bf12d63f17e88f1bf3c..7d5380286406693a47665493cb3e10128f78e3ee 100644 (file)
--- a/MagickCore/utility-private.h
+++ b/MagickCore/utility-private.h
@@ -65,7 +65,7 @@ static inline int MultiByteToWideCharacter(const char *string,
 }
 #endif
 
-static inline int access_utf8(const char *path,mode_t mode)
+static inline int access_utf8(const char *path,int mode)
 {
 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
   return(access(path,mode));

diff --git a/MagickCore/utility.c b/MagickCore/utility.c
index 52ed7921e4fb667d57750da685de10a56ab829ad..634a40d816cf9e3665b88919586ed47615e15439 100644 (file)
--- a/MagickCore/utility.c
+++ b/MagickCore/utility.c
@@ -1854,7 +1854,7 @@ MagickExport int SystemCommand(const MagickBooleanType asynchronous,
       /*
         Call application directly rather than from a shell.
       */
-      child_pid=fork();
+      child_pid=(pid_t) fork();
       if (child_pid == (pid_t) -1)
         status=system(command);
       else
@@ -1872,7 +1872,7 @@ MagickExport int SystemCommand(const MagickBooleanType asynchronous,
               pid;
 
             child_status=0;
-            pid=waitpid(child_pid,&child_status,0);
+            pid=(pid_t) waitpid(child_pid,&child_status,0);
             if (pid == -1)
               status=(-1);
             else

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index 4f4ae24b03adff6837617d8278c86710931f8979..99bad6718778e5754f0012b11d6c2e210e009f49 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -561,10 +561,14 @@ MagickPrivate MagickBooleanType XAnnotateImage(Display *display,
   (void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
   (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
     exception);
-  annotate_image->background_color.red=virtual_pixel[RedPixelChannel];
-  annotate_image->background_color.green=virtual_pixel[GreenPixelChannel];
-  annotate_image->background_color.blue=virtual_pixel[BluePixelChannel];
-  annotate_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
+  annotate_image->background_color.red=(double)
+    virtual_pixel[RedPixelChannel];
+  annotate_image->background_color.green=(double)
+    virtual_pixel[GreenPixelChannel];
+  annotate_image->background_color.blue=(double)
+    virtual_pixel[BluePixelChannel];
+  annotate_image->background_color.alpha=(double)
+    virtual_pixel[AlphaPixelChannel];
   if (annotate_info->stencil == ForegroundStencil)
     annotate_image->matte=MagickTrue;
   annotate_view=AcquireCacheView(annotate_image);
@@ -2242,12 +2246,12 @@ static void XDitherImage(Image *image,XImage *ximage,ExceptionInfo *exception)
       break;
     for (x=0; x < (int) image->columns; x++)
     {
-      color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
-        ScaleQuantumToChar(GetPixelRed(image,p))] << 8));
-      color.green=ClampToQuantum((MagickRealType) (green_map[i][j][(int)
-        ScaleQuantumToChar(GetPixelGreen(image,p))] << 8));
-      color.blue=ClampToQuantum((MagickRealType) (blue_map[i][j][(int)
-        ScaleQuantumToChar(GetPixelBlue(image,p))] << 8));
+      color.red=(double) ClampToQuantum((MagickRealType) (red_map[i][j][
+        (int) ScaleQuantumToChar(GetPixelRed(image,p))] << 8));
+      color.green=(double) ClampToQuantum((MagickRealType) (green_map[i][j][
+        (int) ScaleQuantumToChar(GetPixelGreen(image,p))] << 8));
+      color.blue=(double) ClampToQuantum((MagickRealType) (blue_map[i][j][
+        (int) ScaleQuantumToChar(GetPixelBlue(image,p))] << 8));
       pixel=(size_t) (((size_t) color.red & 0xe0) |
         (((size_t) color.green & 0xe0) >> 3) |
         (((size_t) color.blue & 0xc0) >> 6));
@@ -2490,10 +2494,10 @@ MagickPrivate MagickBooleanType XDrawImage(Display *display,
   (void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
   (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,virtual_pixel,
     exception);
-  draw_image->background_color.red=virtual_pixel[RedPixelChannel];
-  draw_image->background_color.green=virtual_pixel[GreenPixelChannel];
-  draw_image->background_color.blue=virtual_pixel[BluePixelChannel];
-  draw_image->background_color.alpha=virtual_pixel[AlphaPixelChannel];
+  draw_image->background_color.red=(double) virtual_pixel[RedPixelChannel];
+  draw_image->background_color.green=(double) virtual_pixel[GreenPixelChannel];
+  draw_image->background_color.blue=(double) virtual_pixel[BluePixelChannel];
+  draw_image->background_color.alpha=(double) virtual_pixel[AlphaPixelChannel];
   if (SetImageStorageClass(draw_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   draw_image->matte=MagickTrue;
@@ -3941,9 +3945,9 @@ MagickPrivate MagickBooleanType XGetWindowColor(Display *display,
     Match color against the color database.
   */
   (void) XQueryColor(display,window_attributes.colormap,&color);
-  pixel.red=ScaleShortToQuantum(color.red);
-  pixel.green=ScaleShortToQuantum(color.green);
-  pixel.blue=ScaleShortToQuantum(color.blue);
+  pixel.red=(double) ScaleShortToQuantum(color.red);
+  pixel.green=(double) ScaleShortToQuantum(color.green);
+  pixel.blue=(double) ScaleShortToQuantum(color.blue);
   pixel.alpha=OpaqueAlpha;
   (void) QueryColorname(windows->image.image,&pixel,X11Compliance,name,
     exception);
@@ -4487,11 +4491,11 @@ static Image *XGetWindowImage(Display *display,const Window window,
               }
             for (i=0; i < (int) composite_image->colors; i++)
             {
-              composite_image->colormap[colors[i].pixel].red=
+              composite_image->colormap[colors[i].pixel].red=(double)
                 ScaleShortToQuantum(colors[i].red);
-              composite_image->colormap[colors[i].pixel].green=
+              composite_image->colormap[colors[i].pixel].green=(double)
                 ScaleShortToQuantum(colors[i].green);
-              composite_image->colormap[colors[i].pixel].blue=
+              composite_image->colormap[colors[i].pixel].blue=(double)
                 ScaleShortToQuantum(colors[i].blue);
             }
             /*
@@ -8011,9 +8015,9 @@ MagickPrivate void XMakeStandardColormap(Display *display,
               "UnableToCreateColormap",image->filename);
           for (i=0; i < (ssize_t) image->colors; i++)
           {
-            diversity[i].red=image->colormap[i].red;
-            diversity[i].green=image->colormap[i].green;
-            diversity[i].blue=image->colormap[i].blue;
+            diversity[i].red=ClampToQuantum(image->colormap[i].red);
+            diversity[i].green=ClampToQuantum(image->colormap[i].green);
+            diversity[i].blue=ClampToQuantum(image->colormap[i].blue);
             diversity[i].index=(unsigned short) i;
             diversity[i].count=0;
           }

diff --git a/MagickWand/drawing-wand.c b/MagickWand/drawing-wand.c
index 661a840c3c87ab566be96ed7ced9733c00b9512c..e833b97af76b4e3ab76bcb87913c3ffbc53864f1 100644 (file)
--- a/MagickWand/drawing-wand.c
+++ b/MagickWand/drawing-wand.c
@@ -4728,14 +4728,14 @@ WandExport void DrawSetFillColor(DrawingWand *wand,const PixelWand *fill_wand)
 */
 WandExport void DrawSetFillAlpha(DrawingWand *wand,const double fill_alpha)
 {
-  Quantum
+  double
     alpha;
 
   assert(wand != (DrawingWand *) NULL);
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  alpha=ClampToQuantum((double) QuantumRange*(1.0-fill_alpha));
+  alpha=(double) ClampToQuantum((double) QuantumRange*(1.0-fill_alpha));
   if ((wand->filter_off != MagickFalse) ||
       (CurrentContext->fill.alpha != alpha))
     {
@@ -4889,7 +4889,7 @@ WandExport MagickBooleanType DrawSetFillPatternURL(DrawingWand *wand,
     &CurrentContext->fill_pattern);
 #endif
   if (CurrentContext->fill.alpha != (Quantum) TransparentAlpha)
-    CurrentContext->fill.alpha=CurrentContext->alpha;
+    CurrentContext->fill.alpha=(double) CurrentContext->alpha;
   (void) MvgPrintf(wand,"fill %s\n",pattern_spec);
   return(MagickTrue);
 }
@@ -5329,7 +5329,7 @@ WandExport MagickBooleanType DrawSetStrokePatternURL(DrawingWand *wand,
     &CurrentContext->stroke_pattern);
 #endif
   if (CurrentContext->stroke.alpha != (Quantum) TransparentAlpha)
-    CurrentContext->stroke.alpha=CurrentContext->alpha;
+    CurrentContext->stroke.alpha=(double) CurrentContext->alpha;
   (void) MvgPrintf(wand,"stroke %s\n",pattern_spec);
   return(MagickTrue);
 }
@@ -5695,14 +5695,14 @@ WandExport void DrawSetStrokeMiterLimit(DrawingWand *wand,
 WandExport void DrawSetStrokeAlpha(DrawingWand *wand,
   const double stroke_alpha)
 {
-  Quantum
+  double
     alpha;
 
   assert(wand != (DrawingWand *) NULL);
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  alpha=ClampToQuantum((double) QuantumRange*(1.0-stroke_alpha));
+  alpha=(double) ClampToQuantum((double) QuantumRange*(1.0-stroke_alpha));
   if ((wand->filter_off != MagickFalse) ||
       (CurrentContext->stroke.alpha != alpha))
     {
@@ -6189,7 +6189,7 @@ WandExport MagickBooleanType DrawSetVectorGraphics(DrawingWand *wand,
     {
       value=GetXMLTreeContent(child);
       if (value != (const char *) NULL)
-        CurrentContext->fill.alpha=ClampToQuantum((MagickRealType)
+        CurrentContext->fill.alpha=(double) ClampToQuantum((MagickRealType)
           QuantumRange*(1.0-StringToDouble(value,(char **) NULL)));
     }
   child=GetXMLTreeChild(xml_info,"fill-rule");
@@ -6353,7 +6353,7 @@ WandExport MagickBooleanType DrawSetVectorGraphics(DrawingWand *wand,
     {
       value=GetXMLTreeContent(child);
       if (value != (const char *) NULL)
-        CurrentContext->stroke.alpha=ClampToQuantum((MagickRealType)
+        CurrentContext->stroke.alpha=(double) ClampToQuantum((MagickRealType)
           QuantumRange*(1.0-StringToDouble(value,(char **) NULL)));
     }
   child=GetXMLTreeChild(xml_info,"stroke-width");

diff --git a/MagickWand/pixel-wand.c b/MagickWand/pixel-wand.c
index 8950383e9750362b1edc3a013326e846b68d3f91..c44e3d687fa131c940eca7719f48e3ae3523f1e1 100644 (file)
--- a/MagickWand/pixel-wand.c
+++ b/MagickWand/pixel-wand.c
@@ -1067,9 +1067,9 @@ WandExport void PixelGetHSL(const PixelWand *wand,double *hue,
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  ConvertRGBToHSL(ClampToQuantum(wand->pixel.red),ClampToQuantum(
-    wand->pixel.green),ClampToQuantum(wand->pixel.blue),hue,saturation,
-    lightness);
+  ConvertRGBToHSL((double) ClampToQuantum(wand->pixel.red),(double)
+    ClampToQuantum(wand->pixel.green),(double) ClampToQuantum(wand->pixel.blue),
+    hue,saturation,lightness);
 }
 \f
 /*
@@ -1262,24 +1262,24 @@ WandExport void PixelGetQuantumPacket(const PixelWand *wand,PixelInfo *packet)
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
   assert(packet != (PixelInfo *) NULL);
-  packet->alpha=ClampToQuantum(wand->pixel.alpha);
+  packet->alpha=(double) ClampToQuantum(wand->pixel.alpha);
   if (wand->pixel.colorspace == CMYKColorspace)
     {
-      packet->red=ClampToQuantum((MagickRealType) QuantumRange-
+      packet->red=(double) ClampToQuantum((MagickRealType) QuantumRange-
         (wand->pixel.red*(QuantumRange-wand->pixel.black)+
         wand->pixel.black));
-      packet->green=ClampToQuantum((MagickRealType) QuantumRange-
+      packet->green=(double) ClampToQuantum((MagickRealType) QuantumRange-
         (wand->pixel.green*(QuantumRange-wand->pixel.black)+
         wand->pixel.black));
-      packet->blue=ClampToQuantum((MagickRealType) QuantumRange-
+      packet->blue=(double) ClampToQuantum((MagickRealType) QuantumRange-
         (wand->pixel.blue*(QuantumRange-wand->pixel.black)+
         wand->pixel.black));
-      packet->black=ClampToQuantum(wand->pixel.black);
+      packet->black=(double) ClampToQuantum(wand->pixel.black);
       return;
     }
-  packet->red=ClampToQuantum(wand->pixel.red);
-  packet->green=ClampToQuantum(wand->pixel.green);
-  packet->blue=ClampToQuantum(wand->pixel.blue);
+  packet->red=(double) ClampToQuantum(wand->pixel.red);
+  packet->green=(double) ClampToQuantum(wand->pixel.green);
+  packet->blue=(double) ClampToQuantum(wand->pixel.blue);
 }
 \f
 /*
@@ -1490,7 +1490,7 @@ WandExport void PixelSetAlpha(PixelWand *wand,const double alpha)
   assert(wand->signature == WandSignature);
   if (wand->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  wand->pixel.alpha=ClampToQuantum(QuantumRange*alpha);
+  wand->pixel.alpha=(double) ClampToQuantum(QuantumRange*alpha);
 }
 \f
 /*

diff --git a/coders/yuv.c b/coders/yuv.c
index fe292fc369b3561f574a800d938e8cb56ce03053..782fd3230912b1a8eaf5d11ed0d723f14ee274ad 100644 (file)
--- a/coders/yuv.c
+++ b/coders/yuv.c
@@ -588,7 +588,7 @@ static MagickBooleanType WriteYUVImage(const ImageInfo *image_info,Image *image,
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  quantum=image->depth <= 8 ? 1 : 2;
+  quantum=(size_t) (image->depth <= 8 ? 1 : 2);
   interlace=image->interlace;
   horizontal_factor=2;
   vertical_factor=2;
@@ -638,7 +638,7 @@ static MagickBooleanType WriteYUVImage(const ImageInfo *image_info,Image *image,
     /*
       Sample image to an even width and height, if necessary.
     */
-    image->depth=quantum == 1 ? 8 : 16;
+    image->depth=(size_t) (quantum == 1 ? 8 : 16);
     width=image->columns+(image->columns & (horizontal_factor-1));
     height=image->rows+(image->rows & (vertical_factor-1));
     yuv_image=ResizeImage(image,width,height,TriangleFilter,1.0,exception);

diff --git a/tests/validate.c b/tests/validate.c
index 475a465db39a09ff01a14e56f2135bc87e95319c..23423fdd3de656f7f949d91465c641aca07c8216 100644 (file)
--- a/tests/validate.c
+++ b/tests/validate.c
@@ -123,7 +123,7 @@ static size_t ValidateCompareCommand(ImageInfo *image_info,
       }
     status=CompareImagesCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)
@@ -215,7 +215,7 @@ static size_t ValidateCompositeCommand(ImageInfo *image_info,
       }
     status=CompositeImageCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)
@@ -306,7 +306,7 @@ static size_t ValidateConvertCommand(ImageInfo *image_info,
       }
     status=ConvertImageCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)
@@ -398,7 +398,7 @@ static size_t ValidateIdentifyCommand(ImageInfo *image_info,
       }
     status=IdentifyImageCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)
@@ -1099,7 +1099,7 @@ static size_t ValidateMontageCommand(ImageInfo *image_info,
       }
     status=MontageImageCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)
@@ -1190,7 +1190,7 @@ static size_t ValidateStreamCommand(ImageInfo *image_info,
       }
     status=StreamImageCommand(image_info,number_arguments,arguments,
       (char **) NULL,exception);
-    for (j=0; j < number_arguments; j++)
+    for (j=0; j < (ssize_t) number_arguments; j++)
       arguments[j]=DestroyString(arguments[j]);
     arguments=(char **) RelinquishMagickMemory(arguments);
     if (status != MagickFalse)