(no commit message)

diff --git a/MagickCore/annotate.c b/MagickCore/annotate.c
index ccdf2134f703be09f4138afbd849e79fbe481c00..4ada438d61df3f8e37c4b7d4ffe9a9284e997f0d 100644 (file)
--- a/MagickCore/annotate.c
+++ b/MagickCore/annotate.c
@@ -279,7 +279,7 @@ MagickExport MagickBooleanType AnnotateImage(Image *image,
         &image->exception);
       (void) ParseGeometry(annotate_info->geometry,&geometry_info);
     }
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   for (i=0; textlist[i] != (char *) NULL; i++)
@@ -1243,7 +1243,7 @@ static MagickBooleanType RenderFreetype(Image *image,const DrawInfo *draw_info,
   if (draw_info->render != MagickFalse)
     {
       if (image->storage_class != DirectClass)
-        (void) SetImageStorageClass(image,DirectClass);
+        (void) SetImageStorageClass(image,DirectClass,&image->exception);
       if (image->matte == MagickFalse)
         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
     }

diff --git a/MagickCore/cache-view.c b/MagickCore/cache-view.c
index 25fe60b653e35d2af8ae59d4effda0c03d1332ca..fe7837d7dddbd81277a65ef8eab3fbca6fba0f02 100644 (file)
--- a/MagickCore/cache-view.c
+++ b/MagickCore/cache-view.c
@@ -875,12 +875,17 @@ MagickExport Quantum *QueueCacheViewAuthenticPixels(CacheView *cache_view,
 MagickExport MagickBooleanType SetCacheViewStorageClass(CacheView *cache_view,
   const ClassType storage_class)
 {
+  MagickBooleanType
+    status;
+
   assert(cache_view != (CacheView *) NULL);
   assert(cache_view->signature == MagickSignature);
   if (cache_view->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
       cache_view->image->filename);
-  return(SetImageStorageClass(cache_view->image,storage_class));
+  status=SetImageStorageClass(cache_view->image,storage_class,
+    &cache_view->image->exception);
+  return(status);
 }
 \f
 /*

diff --git a/MagickCore/cipher.c b/MagickCore/cipher.c
index bbc8beee4c1df9f5c1f50ba57e08771d302c2bdc..8fcdc9bf786b9fdf8dbbf6ec97f9ff319bf1712f 100644 (file)
--- a/MagickCore/cipher.c
+++ b/MagickCore/cipher.c
@@ -799,7 +799,7 @@ MagickExport MagickBooleanType PasskeyEncipherImage(Image *image,
   assert(exception->signature == MagickSignature);
   if (passkey == (const StringInfo *) NULL)
     return(MagickTrue);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
   if (quantum_info == (QuantumInfo *) NULL)

diff --git a/MagickCore/colormap.c b/MagickCore/colormap.c
index 42be2fc9ed86e9a594910649a4d480cb3703bd51..9d09809de4b5c01452a1432a80309ad591700ea4 100644 (file)
--- a/MagickCore/colormap.c
+++ b/MagickCore/colormap.c
@@ -151,7 +151,7 @@ MagickExport MagickBooleanType AcquireImageColormap(Image *image,
     image->colormap[i].blue=(Quantum) pixel;
     image->colormap[i].alpha=OpaqueAlpha;
   }
-  return(SetImageStorageClass(image,PseudoClass));
+  return(SetImageStorageClass(image,PseudoClass,&image->exception));
 }
 \f
 /*

diff --git a/MagickCore/colorspace.c b/MagickCore/colorspace.c
index ce0d66c5999b761ed19e3ae1cb246a7124706349..c5a3c4c585fb52f377c52ebdf0f11a61dead51f8 100644 (file)
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -244,7 +244,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -299,7 +299,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       GetPixelInfo(image,&zero);
@@ -353,7 +353,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -413,7 +413,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -473,7 +473,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -533,7 +533,7 @@ MagickExport MagickBooleanType RGBTransformImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -1665,7 +1665,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -1723,7 +1723,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       GetPixelInfo(image,&zero);
@@ -1780,7 +1780,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -1846,7 +1846,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -1912,7 +1912,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -1978,7 +1978,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
         {
           if (SyncImage(image) == MagickFalse)
             return(MagickFalse);
-          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+          if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
       image_view=AcquireCacheView(image);
@@ -2094,7 +2094,7 @@ MagickExport MagickBooleanType TransformRGBImage(Image *image,
           (gamma/density)*0.002/film_gamma)-black));
       for ( ; i <= (ssize_t) MaxMap; i++)
         logmap[i]=(Quantum) QuantumRange;
-      if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+      if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
         return(MagickFalse);
       image_view=AcquireCacheView(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 9fc5488fcc95da7f5049911e51ecfc1b88704511..535cb19ab14ba84e21b6dc33cc54e6a11cbaa853 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -154,9 +154,8 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
       difference_image=DestroyImage(difference_image);
       return((Image *) NULL);
     }
-  if (SetImageStorageClass(highlight_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(highlight_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&highlight_image->exception);
       difference_image=DestroyImage(difference_image);
       highlight_image=DestroyImage(highlight_image);
       return((Image *) NULL);
@@ -1786,9 +1785,8 @@ MagickExport Image *SimilarityImage(Image *image,const Image *reference,
     image->rows-reference->rows+1,MagickTrue,exception);
   if (similarity_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(similarity_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(similarity_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&similarity_image->exception);
       similarity_image=DestroyImage(similarity_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index ebd239aba3a4a698f80839bd4809b6118e319422..489b4f720f8e371b0468c805cf7337eba7450c9c 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -1601,7 +1601,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(composite_image != (Image *) NULL);
   assert(composite_image->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   GetPixelInfo(image,&zero);
   destination_image=(Image *) NULL;
@@ -2770,7 +2770,7 @@ MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture)
   if (texture == (const Image *) NULL)
     return(MagickFalse);
   (void) SetImageVirtualPixelMethod(texture,TileVirtualPixelMethod);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   if ((image->compose != CopyCompositeOp) &&

diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index 2ca33697de81d651c2d5e89e8d59ae47bf587dcc..58198048cc86311a0f1556cc0d3284ec625154a8 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -220,9 +220,8 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
     exception);
   if (frame_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(frame_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(frame_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&frame_image->exception);
       frame_image=DestroyImage(frame_image);
       return((Image *) NULL);
     }
@@ -672,7 +671,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       foreground=(Quantum) 0;
       background=(Quantum) QuantumRange;
     }
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   /*
     Raise image.

diff --git a/MagickCore/display.c b/MagickCore/display.c
index 5c0b50839f95b93dae58e8595ac1986d5fbbcd4e..0c893235d236479155d9a0c459079d3390eb5d84 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -3708,10 +3708,10 @@ static MagickBooleanType XColorEditImage(Display *display,
             /*
               Update color information using point algorithm.
             */
-            if (SetImageStorageClass(*image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(*image,DirectClass,exception) == MagickFalse)
               return(MagickFalse);
             q=GetCacheViewAuthenticPixels(image_view,(ssize_t)x_offset,
-              (ssize_t)y_offset,1,1,exception);
+              (ssize_t) y_offset,1,1,exception);
             if (q == (Quantum *) NULL)
               break;
             SetPixelRed(*image,ScaleShortToQuantum(color.red),q);
@@ -3812,7 +3812,7 @@ static MagickBooleanType XColorEditImage(Display *display,
             /*
               Update color information using reset algorithm.
             */
-            if (SetImageStorageClass(*image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(*image,DirectClass,exception) == MagickFalse)
               return(MagickFalse);
             for (y=0; y < (int) (*image)->rows; y++)
             {
@@ -4298,10 +4298,10 @@ static MagickBooleanType XCompositeImage(Display *display,
       (void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel);
       opacity=(Quantum) (ScaleQuantumToChar((Quantum) QuantumRange)-
         ((ssize_t) ScaleQuantumToChar((Quantum) QuantumRange)*blend)/100);
-      if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+      exception=(&image->exception);
+      if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
         return(MagickFalse);
       image->matte=MagickTrue;
-      exception=(&image->exception);
       image_view=AcquireCacheView(image);
       for (y=0; y < (int) image->rows; y++)
       {
@@ -5316,10 +5316,10 @@ static MagickBooleanType XCropImage(Display *display,
   /*
     Cut image.
   */
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  exception=(&image->exception);
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   image->matte=MagickTrue;
-  exception=(&image->exception);
   image_view=AcquireCacheView(image);
   for (y=0; y < (int) crop_info.height; y++)
   {
@@ -10000,10 +10000,10 @@ static MagickBooleanType XMatteEditImage(Display *display,
         if ((x_offset >= (int) (*image)->columns) ||
             (y_offset >= (int) (*image)->rows))
           continue;
-        if (SetImageStorageClass(*image,DirectClass) == MagickFalse)
+        exception=(&(*image)->exception);
+        if (SetImageStorageClass(*image,DirectClass,exception) == MagickFalse)
           return(MagickFalse);
         (*image)->matte=MagickTrue;
-        exception=(&(*image)->exception);
         image_view=AcquireCacheView(*image);
         switch (method)
         {
@@ -10090,7 +10090,7 @@ static MagickBooleanType XMatteEditImage(Display *display,
             /*
               Update matte information using reset algorithm.
             */
-            if (SetImageStorageClass(*image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(*image,DirectClass,exception) == MagickFalse)
               return(MagickFalse);
             for (y=0; y < (int) (*image)->rows; y++)
             {

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index 70050e7dbe67213647cf98e1d4997d771de71d86..ef480d2d28b43631a1eb455c6afdcdedeaf790f3 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -2211,9 +2211,8 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
   if (distort_image == (Image *) NULL)
     return((Image *) NULL);
   /* if image is ColorMapped - change it to DirectClass */
-  if (SetImageStorageClass(distort_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(distort_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&distort_image->exception);
       distort_image=DestroyImage(distort_image);
       return((Image *) NULL);
     }
@@ -2871,9 +2870,8 @@ MagickExport Image *SparseColorImage(const Image *image,
   sparse_image=CloneImage(image,0,0,MagickTrue,exception);
   if (sparse_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(sparse_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(sparse_image,DirectClass,exception) == MagickFalse)
     { /* if image is ColorMapped - change it to DirectClass */
-      InheritException(exception,&image->exception);
       sparse_image=DestroyImage(sparse_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index bdad05803ec9d7a0fdf3ffe46acfe278190fbe4c..ad61ec18e50afb2b6df1d0f2775738fe44764288 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -1148,7 +1148,7 @@ MagickExport MagickBooleanType DrawAffineImage(Image *image,
   /*
     Affine transform image.
   */
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   edge.x1=MagickMax(min.x,0.0);
@@ -1777,7 +1777,7 @@ MagickExport MagickBooleanType DrawImage(Image *image,const DrawInfo *draw_info)
     }
   token=AcquireString(primitive);
   (void) QueryColorDatabase("#000000",&start_color,&image->exception);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   for (q=primitive; *q != '\0'; )

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index ab794b4f48fe99f4d15c528ed73aaa88ead9b2cf..e357a2982419eb07c08c581f4150bac1f612b3a9 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -217,9 +217,8 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,
     return((Image *) NULL);
   if (fabs(sigma) <= MagickEpsilon)
     return(blur_image);
-  if (SetImageStorageClass(blur_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&blur_image->exception);
       blur_image=DestroyImage(blur_image);
       return((Image *) NULL);
     }
@@ -509,9 +508,8 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
     return((Image *) NULL);
   if (fabs(sigma) <= MagickEpsilon)
     return(sharp_image);
-  if (SetImageStorageClass(sharp_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(sharp_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&sharp_image->exception);
       sharp_image=DestroyImage(sharp_image);
       return((Image *) NULL);
     }
@@ -835,9 +833,8 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
     return((Image *) NULL);
   if (fabs(sigma) <= MagickEpsilon)
     return(blur_image);
-  if (SetImageStorageClass(blur_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&blur_image->exception);
       blur_image=DestroyImage(blur_image);
       return((Image *) NULL);
     }
@@ -1220,6 +1217,7 @@ MagickExport Image *ConvolveImage(const Image *image,
     progress;
 
   ssize_t
+    center,
     y;
 
   /*
@@ -1237,9 +1235,8 @@ MagickExport Image *ConvolveImage(const Image *image,
     exception);
   if (convolve_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(convolve_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(convolve_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&convolve_image->exception);
       convolve_image=DestroyImage(convolve_image);
       return((Image *) NULL);
     }
@@ -1280,6 +1277,8 @@ MagickExport Image *ConvolveImage(const Image *image,
   /*
     Convolve image.
   */
+  center=(ssize_t) GetPixelChannels(image)*(image->columns+kernel_info->width)*
+    (kernel_info->height/2L)+GetPixelChannels(image)*(kernel_info->width/2);
   status=MagickTrue;
   progress=0;
   image_view=AcquireCacheView(image);
@@ -1298,9 +1297,6 @@ MagickExport Image *ConvolveImage(const Image *image,
     register ssize_t
       x;
 
-    ssize_t
-      center;
-
     if (status == MagickFalse)
       continue;
     p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel_info->width/2L),y-
@@ -1313,9 +1309,6 @@ MagickExport Image *ConvolveImage(const Image *image,
         status=MagickFalse;
         continue;
       }
-    center=(ssize_t) GetPixelChannels(image)*(image->columns+
-      kernel_info->width)*(kernel_info->height/2L)+GetPixelChannels(image)*
-      (kernel_info->width/2);
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       register ssize_t
@@ -1593,9 +1586,8 @@ MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
     exception);
   if (despeckle_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(despeckle_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(despeckle_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&despeckle_image->exception);
       despeckle_image=DestroyImage(despeckle_image);
       return((Image *) NULL);
     }
@@ -2131,11 +2123,10 @@ MagickExport Image *MotionBlurImage(const Image *image,
       offset=(OffsetInfo *) RelinquishMagickMemory(offset);
       return((Image *) NULL);
     }
-  if (SetImageStorageClass(blur_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
     {
       kernel=(double *) RelinquishMagickMemory(kernel);
       offset=(OffsetInfo *) RelinquishMagickMemory(offset);
-      InheritException(exception,&blur_image->exception);
       blur_image=DestroyImage(blur_image);
       return((Image *) NULL);
     }
@@ -2888,9 +2879,8 @@ MagickExport Image *RadialBlurImage(const Image *image,
   blur_image=CloneImage(image,0,0,MagickTrue,exception);
   if (blur_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(blur_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&blur_image->exception);
       blur_image=DestroyImage(blur_image);
       return((Image *) NULL);
     }
@@ -3213,9 +3203,8 @@ MagickExport Image *SelectiveBlurImage(const Image *image,
   blur_image=CloneImage(image,0,0,MagickTrue,exception);
   if (blur_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(blur_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(blur_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&blur_image->exception);
       blur_image=DestroyImage(blur_image);
       return((Image *) NULL);
     }
@@ -3520,9 +3509,8 @@ MagickExport Image *ShadeImage(const Image *image,const MagickBooleanType gray,
   shade_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (shade_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(shade_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(shade_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&shade_image->exception);
       shade_image=DestroyImage(shade_image);
       return((Image *) NULL);
     }
@@ -3830,9 +3818,8 @@ MagickExport Image *SpreadImage(const Image *image,const double radius,
     exception);
   if (spread_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(spread_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(spread_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&spread_image->exception);
       spread_image=DestroyImage(spread_image);
       return((Image *) NULL);
     }
@@ -4580,9 +4567,8 @@ MagickExport Image *StatisticImage(const Image *image,const StatisticType type,
     exception);
   if (statistic_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(statistic_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(statistic_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&statistic_image->exception);
       statistic_image=DestroyImage(statistic_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index 84200598a7aa73087d93cd10e65a534b1ba070d2..bfb8f04d9a95538d45e0a86cf946cad030edc82c 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -723,10 +723,9 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(clut_image != (Image *) NULL);
   assert(clut_image->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
-  clut_map=(PixelInfo *) AcquireQuantumMemory(MaxMap+1UL,
-    sizeof(*clut_map));
+  clut_map=(PixelInfo *) AcquireQuantumMemory(MaxMap+1UL,sizeof(*clut_map));
   if (clut_map == (PixelInfo *) NULL)
     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
       image->filename);
@@ -1516,9 +1515,8 @@ MagickExport Image *EnhanceImage(const Image *image,ExceptionInfo *exception)
     exception);
   if (enhance_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(enhance_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(enhance_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&enhance_image->exception);
       enhance_image=DestroyImage(enhance_image);
       return((Image *) NULL);
     }
@@ -2132,7 +2130,7 @@ MagickExport MagickBooleanType HaldClutImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(hald_image != (Image *) NULL);
   assert(hald_image->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   if (image->matte == MagickFalse)
     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index 0cd3ccffa4602c87e1202f5ccc27372ab8173e5e..88cef6e8f80384f1f52da8c8b8661a70f701dfc1 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -343,9 +343,8 @@ MagickExport Image *AddNoiseImage(const Image *image,const NoiseType noise_type,
   noise_image=CloneImage(image,0,0,MagickTrue,exception);
   if (noise_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(noise_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(noise_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&noise_image->exception);
       noise_image=DestroyImage(noise_image);
       return((Image *) NULL);
     }
@@ -499,9 +498,8 @@ MagickExport Image *BlueShiftImage(const Image *image,const double factor,
     exception);
   if (shift_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(shift_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(shift_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&shift_image->exception);
       shift_image=DestroyImage(shift_image);
       return((Image *) NULL);
     }
@@ -732,9 +730,8 @@ MagickExport Image *ColorizeImage(const Image *image,const char *opacity,
     exception);
   if (colorize_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(colorize_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(colorize_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&colorize_image->exception);
       colorize_image=DestroyImage(colorize_image);
       return((Image *) NULL);
     }
@@ -917,9 +914,8 @@ MagickExport Image *ColorMatrixImage(const Image *image,
   color_image=CloneImage(image,0,0,MagickTrue,exception);
   if (color_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(color_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(color_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&color_image->exception);
       color_image=DestroyImage(color_image);
       return((Image *) NULL);
     }
@@ -2967,9 +2963,8 @@ MagickExport Image *FxImage(const Image *image,const char *expression,
   fx_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (fx_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(fx_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(fx_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&fx_image->exception);
       fx_image=DestroyImage(fx_image);
       return((Image *) NULL);
     }
@@ -3156,9 +3151,8 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
   implode_image=CloneImage(image,0,0,MagickTrue,exception);
   if (implode_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(implode_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(implode_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&implode_image->exception);
       implode_image=DestroyImage(implode_image);
       return((Image *) NULL);
     }
@@ -3390,9 +3384,8 @@ MagickExport Image *MorphImages(const Image *image,
           morph_images=DestroyImageList(morph_images);
           return((Image *) NULL);
         }
-      if (SetImageStorageClass(morph_image,DirectClass) == MagickFalse)
+      if (SetImageStorageClass(morph_image,DirectClass,exception) == MagickFalse)
         {
-          InheritException(exception,&morph_image->exception);
           morph_image=DestroyImage(morph_image);
           return((Image *) NULL);
         }
@@ -3750,7 +3743,7 @@ MagickExport MagickBooleanType PlasmaImage(Image *image,
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   image_view=AcquireCacheView(image);
   random_info=AcquireRandomInfo();
@@ -4006,9 +3999,8 @@ MagickExport Image *SepiaToneImage(const Image *image,const double threshold,
   sepia_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (sepia_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(sepia_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(sepia_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&sepia_image->exception);
       sepia_image=DestroyImage(sepia_image);
       return((Image *) NULL);
     }
@@ -4271,8 +4263,8 @@ MagickExport Image *ShadowImage(const Image *image,const double opacity,
 %
 %    o image: the image.
 %
-%    o radius: the radius of the Gaussian, in pixels, not counting
-%      the center pixel.
+%    o radius: the radius of the Gaussian, in pixels, not counting the
+%      center pixel.
 %
 %    o sigma: the standard deviation of the Gaussian, in pixels.
 %
@@ -4607,9 +4599,8 @@ MagickExport Image *SteganoImage(const Image *image,const Image *watermark,
   stegano_image=CloneImage(image,0,0,MagickTrue,exception);
   if (stegano_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(stegano_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(stegano_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&stegano_image->exception);
       stegano_image=DestroyImage(stegano_image);
       return((Image *) NULL);
     }
@@ -4779,9 +4770,8 @@ MagickExport Image *StereoAnaglyphImage(const Image *left_image,
     MagickTrue,exception);
   if (stereo_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(stereo_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(stereo_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&stereo_image->exception);
       stereo_image=DestroyImage(stereo_image);
       return((Image *) NULL);
     }
@@ -4912,9 +4902,8 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
   swirl_image=CloneImage(image,0,0,MagickTrue,exception);
   if (swirl_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(swirl_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(swirl_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&swirl_image->exception);
       swirl_image=DestroyImage(swirl_image);
       return((Image *) NULL);
     }
@@ -5097,9 +5086,8 @@ MagickExport Image *TintImage(const Image *image,const char *opacity,
   tint_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (tint_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(tint_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(tint_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&tint_image->exception);
       tint_image=DestroyImage(tint_image);
       return((Image *) NULL);
     }
@@ -5260,9 +5248,8 @@ MagickExport Image *VignetteImage(const Image *image,const double radius,
   canvas_image=CloneImage(image,0,0,MagickTrue,exception);
   if (canvas_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(canvas_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(canvas_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&canvas_image->exception);
       canvas_image=DestroyImage(canvas_image);
       return((Image *) NULL);
     }
@@ -5373,9 +5360,8 @@ MagickExport Image *WaveImage(const Image *image,const double amplitude,
     fabs(amplitude)),MagickTrue,exception);
   if (wave_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(wave_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(wave_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&wave_image->exception);
       wave_image=DestroyImage(wave_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/histogram.c b/MagickCore/histogram.c
index eaaba4bbceba05cfa41968e647ba06c34fb2fc43..f477e700de2841e31404dee18ceec10dac7e215b 100644 (file)
--- a/MagickCore/histogram.c
+++ b/MagickCore/histogram.c
@@ -1310,9 +1310,8 @@ MagickExport Image *UniqueImageColors(const Image *image,
   unique_image=CloneImage(image,cube_info->colors,1,MagickTrue,exception);
   if (unique_image == (Image *) NULL)
     return(unique_image);
-  if (SetImageStorageClass(unique_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(unique_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&unique_image->exception);
       unique_image=DestroyImage(unique_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/image-view.c b/MagickCore/image-view.c
index 4d33f664c650d4ec7387504ba2d10467193279e5..d0c050f99f0bad8950a6f974a91080e1bfd2f5cd 100644 (file)
--- a/MagickCore/image-view.c
+++ b/MagickCore/image-view.c
@@ -237,7 +237,7 @@ MagickExport MagickBooleanType DuplexTransferImageViewIterator(
     return(MagickFalse);
   source_image=source->image;
   destination_image=destination->image;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -884,7 +884,7 @@ MagickExport MagickBooleanType SetImageViewIterator(ImageView *destination,
   if (set == (SetImageViewMethod) NULL)
     return(MagickFalse);
   destination_image=destination->image;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -1048,7 +1048,7 @@ MagickExport MagickBooleanType TransferImageViewIterator(ImageView *source,
     return(MagickFalse);
   source_image=source->image;
   destination_image=destination->image;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -1178,7 +1178,7 @@ MagickExport MagickBooleanType UpdateImageViewIterator(ImageView *source,
   if (update == (UpdateImageViewMethod) NULL)
     return(MagickFalse);
   source_image=source->image;
-  if (SetImageStorageClass(source_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(source_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;

diff --git a/MagickCore/image.c b/MagickCore/image.c
index 5810cace4f4b3d8792df7cae2008ac49c29288f5..2d8bc1f877e48e7a80c5385351ed92f89f7ae8b3 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -484,9 +484,8 @@ MagickExport Image *AppendImages(const Image *images,
   append_image=CloneImage(image,width,height,MagickTrue,exception);
   if (append_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(append_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(append_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&append_image->exception);
       append_image=DestroyImage(append_image);
       return((Image *) NULL);
     }
@@ -695,7 +694,7 @@ MagickExport MagickBooleanType ClipImagePath(Image *image,const char *pathname,
   if (clip_mask->storage_class == PseudoClass)
     {
       (void) SyncImage(clip_mask);
-      if (SetImageStorageClass(clip_mask,DirectClass) == MagickFalse)
+      if (SetImageStorageClass(clip_mask,DirectClass,&image->exception) == MagickFalse)
         return(MagickFalse);
     }
   if (inside == MagickFalse)
@@ -1039,9 +1038,8 @@ MagickExport Image *CombineImages(const Image *image,ExceptionInfo *exception)
   combine_image=CloneImage(image,0,0,MagickTrue,exception);
   if (combine_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(combine_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(combine_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&combine_image->exception);
       combine_image=DestroyImage(combine_image);
       return((Image *) NULL);
     }
@@ -2320,7 +2318,7 @@ MagickExport MagickBooleanType SeparateImage(Image *image)
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   /*
     Separate image channels.
@@ -2554,7 +2552,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
       */
       if (image->matte == MagickFalse)
         break;
-      if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+      if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
         break;
       GetPixelInfo(image,&background);
       SetPixelInfoPacket(image,&image->background_color,&background);
@@ -2715,7 +2713,8 @@ MagickExport MagickBooleanType SetImageBackgroundColor(Image *image)
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   assert(image->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  exception=(&image->exception);
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   if (image->background_color.alpha != OpaqueAlpha)
     image->matte=MagickTrue;
@@ -2729,7 +2728,6 @@ MagickExport MagickBooleanType SetImageBackgroundColor(Image *image)
   */
   status=MagickTrue;
   pixel.black=0;
-  exception=(&image->exception);
   image_view=AcquireCacheView(image);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -2868,12 +2866,17 @@ MagickExport MagickBooleanType SetImageColor(Image *image,
 %
 %    o storage_class:  The image class.
 %
+%    o exception: return any errors or warnings in this structure.
+%
 */
 MagickExport MagickBooleanType SetImageStorageClass(Image *image,
-  const ClassType storage_class)
+  const ClassType storage_class,ExceptionInfo *exception)
 {
+  PixelPacket
+    pixel;
+
   image->storage_class=storage_class;
-  return(MagickTrue);
+  return(GetOneAuthenticPixel(image,0,0,&pixel,exception));
 }
 \f
 /*
@@ -2919,7 +2922,7 @@ MagickExport MagickBooleanType SetImageClipMask(Image *image,
   image->clip_mask=NewImageList();
   if (clip_mask == (Image *) NULL)
     return(MagickTrue);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   image->clip_mask=CloneImage(clip_mask,0,0,MagickTrue,&image->exception);
   if (image->clip_mask == (Image *) NULL)
@@ -3415,7 +3418,7 @@ MagickExport MagickBooleanType SetImageMask(Image *image,
   image->mask=NewImageList();
   if (mask == (Image *) NULL)
     return(MagickTrue);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   image->mask=CloneImage(mask,0,0,MagickTrue,&image->exception);
   if (image->mask == (Image *) NULL)
@@ -3632,7 +3635,7 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type)
       if (IsRGBColorspace(image->colorspace) == MagickFalse)
         status=TransformImageColorspace(image,RGBColorspace);
       if (image->storage_class != DirectClass)
-        status=SetImageStorageClass(image,DirectClass);
+        status=SetImageStorageClass(image,DirectClass,&image->exception);
       image->matte=MagickFalse;
       break;
     }
@@ -3641,7 +3644,7 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type)
       if (IsRGBColorspace(image->colorspace) == MagickFalse)
         status=TransformImageColorspace(image,RGBColorspace);
       if (image->storage_class != DirectClass)
-        status=SetImageStorageClass(image,DirectClass);
+        status=SetImageStorageClass(image,DirectClass,&image->exception);
       if (image->matte == MagickFalse)
         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
       break;
@@ -3655,7 +3658,7 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type)
           status=TransformImageColorspace(image,CMYKColorspace);
         }
       if (image->storage_class != DirectClass)
-        status=SetImageStorageClass(image,DirectClass);
+        status=SetImageStorageClass(image,DirectClass,&image->exception);
       image->matte=MagickFalse;
       break;
     }
@@ -3668,7 +3671,7 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type)
           status=TransformImageColorspace(image,CMYKColorspace);
         }
       if (image->storage_class != DirectClass)
-        status=SetImageStorageClass(image,DirectClass);
+        status=SetImageStorageClass(image,DirectClass,&image->exception);
       if (image->matte == MagickFalse)
         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
       break;
@@ -3974,9 +3977,8 @@ MagickExport Image *SmushImages(const Image *images,
   smush_image=CloneImage(image,width,height,MagickTrue,exception);
   if (smush_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(smush_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&smush_image->exception);
       smush_image=DestroyImage(smush_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/image.h b/MagickCore/image.h
index fc22d6adb0e66fada897dc8f17e2c58ec156c08a..4043d6fa6d90ad5f8e0179af96ca7c6618914e70 100644 (file)
--- a/MagickCore/image.h
+++ b/MagickCore/image.h
@@ -526,7 +526,7 @@ extern MagickExport MagickBooleanType
   SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
   SetImageMask(Image *,const Image *),
   SetImageOpacity(Image *,const Quantum),
-  SetImageStorageClass(Image *,const ClassType),
+  SetImageStorageClass(Image *,const ClassType,ExceptionInfo *),
   SetImageType(Image *,const ImageType),
   StripImage(Image *),
   SyncImage(Image *),

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index 72dfdd2680a82769af810ffda632885e74534bee..f3186952183b2bbaffd1cd5467fe705cdfd00fd2 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -3846,11 +3846,8 @@ MagickExport Image *MorphologyApply(const Image *image,
       rslt_image=CloneImage(image,0,0,MagickTrue,exception);
       if (rslt_image == (Image *) NULL)
         goto error_cleanup;
-      if (SetImageStorageClass(rslt_image,DirectClass) == MagickFalse)
-        {
-          InheritException(exception,&rslt_image->exception);
-          goto error_cleanup;
-        }
+      if (SetImageStorageClass(rslt_image,DirectClass,exception) == MagickFalse)
+        goto error_cleanup;
 
       changed = MorphologyPrimitiveDirect(rslt_image, method,
          kernel, exception);
@@ -4026,11 +4023,8 @@ MagickExport Image *MorphologyApply(const Image *image,
               work_image=CloneImage(image,0,0,MagickTrue,exception);
               if (work_image == (Image *) NULL)
                 goto error_cleanup;
-              if (SetImageStorageClass(work_image,DirectClass) == MagickFalse)
-                {
-                  InheritException(exception,&work_image->exception);
-                  goto error_cleanup;
-                }
+              if (SetImageStorageClass(work_image,DirectClass,exception) == MagickFalse)
+                goto error_cleanup;
               /* work_image->type=image->type; ??? */
             }
 

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index 44663614c98a764d4c3f239b6e2d6afc6fb6ad1f..789e42263a222edb21c71f09a6cef36f310c9bba 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -169,7 +169,8 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
     return(MagickFalse);
   if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
     return(MagickFalse);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  exception=(&image->exception);
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   if (image->matte == MagickFalse)
     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
@@ -191,7 +192,6 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
   /*
     Push initial segment on stack.
   */
-  exception=(&image->exception);
   x=x_offset;
   y=y_offset;
   start=0;
@@ -578,9 +578,8 @@ MagickExport Image *OilPaintImage(const Image *image,const double radius,
   paint_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
   if (paint_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(paint_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(paint_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&paint_image->exception);
       paint_image=DestroyImage(paint_image);
       return((Image *) NULL);
     }
@@ -765,7 +764,7 @@ MagickExport MagickBooleanType OpaquePaintImage(Image *image,
   assert(fill != (PixelInfo *) NULL);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   /*
     Make image color opaque.
@@ -903,7 +902,7 @@ MagickExport MagickBooleanType TransparentPaintImage(Image *image,
   assert(target != (PixelInfo *) NULL);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   if (image->matte == MagickFalse)
     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);
@@ -1032,7 +1031,7 @@ MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
   assert(low != (PixelInfo *) NULL);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   if (image->matte == MagickFalse)
     (void) SetImageAlphaChannel(image,OpaqueAlphaChannel);

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index 4b460e43f6594a4658d2bd8a9b6d23a0d5690c97..4a1f60754c61381ee8594d94eca4fb622bdaacea 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -1964,7 +1964,7 @@ MagickExport MagickBooleanType ImportImagePixels(Image *image,
       }
     }
   }
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   /*
     Transfer the pixels from the pixel datarray to the image.

diff --git a/MagickCore/profile.c b/MagickCore/profile.c
index e6f9c83e16dc4c3e3914905c0ebc24126a515b75..844bed394b35bc3c22b68f989765f337c9215ed1 100644 (file)
--- a/MagickCore/profile.c
+++ b/MagickCore/profile.c
@@ -1186,7 +1186,7 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
                 ThrowProfileException(ResourceLimitError,
                   "MemoryAllocationFailed",image->filename);
               }
-            if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
               {
                 target_pixels=DestroyPixelThreadSet(target_pixels);
                 source_pixels=DestroyPixelThreadSet(source_pixels);

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 52c28863073a18f8a2c12b66f68c7a28a8476c9b..faf041359d414e9ba00456d5b4c65e572cb5a8b6 100644 (file)
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -1190,9 +1190,8 @@ MagickExport Image *AdaptiveResizeImage(const Image *image,
   resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
   if (resize_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(resize_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(resize_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&resize_image->exception);
       resize_image=DestroyImage(resize_image);
       return((Image *) NULL);
     }
@@ -1772,9 +1771,8 @@ MagickExport Image *LiquidRescaleImage(const Image *image,const size_t columns,
       pixels=(gfloat *) RelinquishMagickMemory(pixels);
       return((Image *) NULL);
     }
-  if (SetImageStorageClass(rescale_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(rescale_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&rescale_image->exception);
       pixels=(gfloat *) RelinquishMagickMemory(pixels);
       rescale_image=DestroyImage(rescale_image);
       return((Image *) NULL);
@@ -2127,11 +2125,8 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
   scale=MagickMax(1.0/x_factor+MagickEpsilon,1.0);
   support=scale*GetResizeFilterSupport(resize_filter);
   storage_class=support > 0.5 ? DirectClass : image->storage_class;
-  if (SetImageStorageClass(resize_image,storage_class) == MagickFalse)
-    {
-      InheritException(exception,&resize_image->exception);
-      return(MagickFalse);
-    }
+  if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
+    return(MagickFalse);
   if (support < 0.5)
     {
       /*
@@ -2341,11 +2336,8 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
   scale=MagickMax(1.0/y_factor+MagickEpsilon,1.0);
   support=scale*GetResizeFilterSupport(resize_filter);
   storage_class=support > 0.5 ? DirectClass : image->storage_class;
-  if (SetImageStorageClass(resize_image,storage_class) == MagickFalse)
-    {
-      InheritException(exception,&resize_image->exception);
-      return(MagickFalse);
-    }
+  if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
+    return(MagickFalse);
   if (support < 0.5)
     {
       /*
@@ -2883,9 +2875,8 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
   scale_image=CloneImage(image,columns,rows,MagickTrue,exception);
   if (scale_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(scale_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(scale_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&scale_image->exception);
       scale_image=DestroyImage(scale_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/shear.c b/MagickCore/shear.c
index 0f3a15bb24c78dc4b723d7ccfc9e1ffb57a6721b..b2dc8e4c45ccbba5199ee4e4c38f52fb881d9eba 100644 (file)
--- a/MagickCore/shear.c
+++ b/MagickCore/shear.c
@@ -1885,9 +1885,8 @@ MagickExport Image *RotateImage(const Image *image,const double degrees,
   shear.y=sin((double) DegreesToRadians(angle));
   if ((shear.x == 0.0) && (shear.y == 0.0))
     return(integral_image);
-  if (SetImageStorageClass(integral_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(integral_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&integral_image->exception);
       integral_image=DestroyImage(integral_image);
       return(integral_image);
     }
@@ -2038,9 +2037,8 @@ MagickExport Image *ShearImage(const Image *image,const double x_shear,
   shear.y=tan(DegreesToRadians(fmod(y_shear,360.0)));
   if ((shear.x == 0.0) && (shear.y == 0.0))
     return(integral_image);
-  if (SetImageStorageClass(integral_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(integral_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&integral_image->exception);
       integral_image=DestroyImage(integral_image);
       return(integral_image);
     }

diff --git a/MagickCore/statistic.c b/MagickCore/statistic.c
index cb282a6010d5a19066b0ace1b223813578ee6b17..0283e3b641750ee7196ba1c0b61a3b5bb985106a 100644 (file)
--- a/MagickCore/statistic.c
+++ b/MagickCore/statistic.c
@@ -454,9 +454,8 @@ MagickExport Image *EvaluateImages(const Image *images,
     exception);
   if (evaluate_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(evaluate_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(evaluate_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&evaluate_image->exception);
       evaluate_image=DestroyImage(evaluate_image);
       return((Image *) NULL);
     }
@@ -726,11 +725,8 @@ MagickExport MagickBooleanType EvaluateImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
-    {
-      InheritException(exception,&image->exception);
-      return(MagickFalse);
-    }
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+    return(MagickFalse);
   status=MagickTrue;
   progress=0;
   random_info=AcquireRandomInfoThreadSet();
@@ -943,11 +939,8 @@ MagickExport MagickBooleanType FunctionImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
-    {
-      InheritException(exception,&image->exception);
-      return(MagickFalse);
-    }
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+    return(MagickFalse);
   status=MagickTrue;
   progress=0;
   image_view=AcquireCacheView(image);

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index c0bb4870ab1b957f4f044599f2e9f29bb64c49d3..31275a1895edaf199e052e4d924aa806fdc470e7 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -181,9 +181,8 @@ MagickExport Image *AdaptiveThresholdImage(const Image *image,
     exception);
   if (threshold_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(threshold_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(threshold_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&threshold_image->exception);
       threshold_image=DestroyImage(threshold_image);
       return((Image *) NULL);
     }
@@ -368,7 +367,7 @@ MagickExport MagickBooleanType BilevelImage(Image *image,
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   /*
     Bilevel threshold image.
@@ -516,7 +515,7 @@ MagickExport MagickBooleanType BlackThresholdImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if (thresholds == (const char *) NULL)
     return(MagickTrue);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   GetPixelInfo(image,&threshold);
   flags=ParseGeometry(thresholds,&geometry_info);
@@ -1368,11 +1367,8 @@ printf("DEBUG levels  r=%u g=%u b=%u a=%u i=%u\n",
     levels.black   = levels.black   ? levels.black-1   : 0;
     levels.alpha = levels.alpha ? levels.alpha-1 : 0;
 
-    if (SetImageStorageClass(image,DirectClass) == MagickFalse)
-      {
-        InheritException(exception,&image->exception);
-        return(MagickFalse);
-      }
+    if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+      return(MagickFalse);
     status=MagickTrue;
     progress=0;
     image_view=AcquireCacheView(image);
@@ -1643,11 +1639,8 @@ MagickExport MagickBooleanType RandomThresholdImage(Image *image,
       random_info=DestroyRandomInfoThreadSet(random_info);
       return(status);
     }
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
-    {
-      InheritException(exception,&image->exception);
-      return(MagickFalse);
-    }
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+    return(MagickFalse);
   random_info=AcquireRandomInfoThreadSet();
   image_view=AcquireCacheView(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -1830,7 +1823,7 @@ MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if (thresholds == (const char *) NULL)
     return(MagickTrue);
-  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   flags=ParseGeometry(thresholds,&geometry_info);
   GetPixelInfo(image,&threshold);

diff --git a/MagickCore/transform.c b/MagickCore/transform.c
index 4dc1d86ec64bc5de1653d2bfda79a3b447d39406..cc03497dd91617e240c36dc7c6fd6b2282185b5c 100644 (file)
--- a/MagickCore/transform.c
+++ b/MagickCore/transform.c
@@ -330,7 +330,7 @@ MagickExport Image *ConsolidateCMYKImages(const Image *images,
       exception);
     if (cmyk_image == (Image *) NULL)
       break;
-    if (SetImageStorageClass(cmyk_image,DirectClass) == MagickFalse)
+    if (SetImageStorageClass(cmyk_image,DirectClass,exception) == MagickFalse)
       break;
     (void) SetImageColorspace(cmyk_image,CMYKColorspace);
     image_view=AcquireCacheView(images);
@@ -1078,9 +1078,8 @@ MagickExport Image *ExtentImage(const Image *image,
     exception);
   if (extent_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(extent_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(extent_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&extent_image->exception);
       extent_image=DestroyImage(extent_image);
       return((Image *) NULL);
     }
@@ -1638,9 +1637,8 @@ MagickExport Image *SpliceImage(const Image *image,
     image->rows+splice_geometry.height,MagickTrue,exception);
   if (splice_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(splice_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(splice_image,DirectClass,exception) == MagickFalse)
     {
-      InheritException(exception,&splice_image->exception);
       splice_image=DestroyImage(splice_image);
       return((Image *) NULL);
     }

diff --git a/MagickCore/version.h b/MagickCore/version.h
index 4a7eec6a0f9e5248bc401c1dc06bbd22c132114c..ccf810685a0b727898e4cd4f734230f8fd7206e7 100644 (file)
--- a/MagickCore/version.h
+++ b/MagickCore/version.h
@@ -34,7 +34,7 @@ extern "C" {
 #define MagickLibAddendum  "-0"
 #define MagickLibInterface  5
 #define MagickLibMinInterface  5
-#define MagickReleaseDate  "2011-08-03"
+#define MagickReleaseDate  "2011-08-04"
 #define MagickChangeDate   "20110801"
 #define MagickAuthoritativeURL  "http://www.imagemagick.org"
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index b48296d9bd92ae015904268054148f9cb1efc330..96528c066996dca925d048e3e7aa0289a99feecf 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -2464,7 +2464,7 @@ MagickExport MagickBooleanType XDrawImage(Display *display,
   (void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
   (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,
     &draw_image->background_color,&image->exception);
-  if (SetImageStorageClass(draw_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(draw_image,DirectClass,&image->exception) == MagickFalse)
     return(MagickFalse);
   draw_image->matte=MagickTrue;
   exception=(&image->exception);
@@ -7803,7 +7803,7 @@ MagickExport void XMakeStandardColormap(Display *display,
               }
             XGetPixelInfo(display,visual_info,map_info,resource_info,image,
               pixel);
-            (void) SetImageStorageClass(image,DirectClass);
+            (void) SetImageStorageClass(image,DirectClass,exception);
             affinity_image=DestroyImage(affinity_image);
           }
       if (IsEventLogging())

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index c3fc3537b2d299032c8bea57505ae53124be031b..f01b3ed3273a9ece8091657c00fcad000130bf4d 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -1062,7 +1062,7 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
             mask_image=GetImageCache(mogrify_info,argv[i+1],exception);
             if (mask_image == (Image *) NULL)
               break;
-            if (SetImageStorageClass(mask_image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse)
               return(MagickFalse);
             mask_view=AcquireCacheView(mask_image);
             for (y=0; y < (ssize_t) mask_image->rows; y++)

diff --git a/MagickWand/wand-view.c b/MagickWand/wand-view.c
index 876f96c830451ab6824fb048e39971d25190107f..27290414566e6384b631f3f6f9c77fac0ca9fc5c 100644 (file)
--- a/MagickWand/wand-view.c
+++ b/MagickWand/wand-view.c
@@ -285,7 +285,7 @@ WandExport MagickBooleanType DuplexTransferWandViewIterator(WandView *source,
     return(MagickFalse);
   source_image=source->wand->images;
   destination_image=destination->wand->images;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -924,7 +924,7 @@ WandExport MagickBooleanType SetWandViewIterator(WandView *destination,
   if (set == (SetWandViewMethod) NULL)
     return(MagickFalse);
   destination_image=destination->wand->images;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -1097,7 +1097,7 @@ WandExport MagickBooleanType TransferWandViewIterator(WandView *source,
     return(MagickFalse);
   source_image=source->wand->images;
   destination_image=destination->wand->images;
-  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(destination_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
@@ -1249,7 +1249,7 @@ WandExport MagickBooleanType UpdateWandViewIterator(WandView *source,
   if (update == (UpdateWandViewMethod) NULL)
     return(MagickFalse);
   source_image=source->wand->images;
-  if (SetImageStorageClass(source_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(source_image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
   status=MagickTrue;
   progress=0;

diff --git a/PerlMagick/Magick.xs b/PerlMagick/Magick.xs
index 4921db27493feeb17a053b862bc27838c6370cd8..944361d1f0ea59376cec47721eb27d0d9119be89 100644 (file)
--- a/PerlMagick/Magick.xs
+++ b/PerlMagick/Magick.xs
@@ -1799,7 +1799,7 @@ static void SetAttribute(pTHX_ struct PackageInfo *info,Image *image,
 
           for ( ; image; image=image->next)
           {
-            if (SetImageStorageClass(image,DirectClass) == MagickFalse)
+            if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
               break;
             x=0;
             y=0;
@@ -13394,7 +13394,7 @@ SetPixel(ref,...)
         }
       }
     }
-    (void) SetImageStorageClass(image,DirectClass);
+    (void) SetImageStorageClass(image,DirectClass,exception);
     PushPixelChannelMap(image,channel);
     q=GetAuthenticPixels(image,region.x,region.y,1,1,exception);
     if ((q == (const Quantum *) NULL) || (av == (AV *) NULL) ||

diff --git a/PerlMagick/t/reference/filter/Scale.miff b/PerlMagick/t/reference/filter/Scale.miff
index cec73c552251243f18a975b860dfc18c311824ac..2c5555e9ee02773a54cca0a1b31107bdc3a57420 100644 (file)
Binary files a/PerlMagick/t/reference/filter/Scale.miff and b/PerlMagick/t/reference/filter/Scale.miff differ

diff --git a/coders/bmp.c b/coders/bmp.c
index b0bc2833172d998938e1b227cda0147d768fb05f..bd5bc3a21cd8501d26c67f487c69e8dc91d027b4 100644 (file)
--- a/coders/bmp.c
+++ b/coders/bmp.c
@@ -1517,7 +1517,7 @@ static MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image)
     bmp_info.offset_bits=bmp_info.file_size;
     bmp_info.compression=BI_RGB;
     if ((image->storage_class == PseudoClass) && (image->colors > 256))
-      (void) SetImageStorageClass(image,DirectClass);
+      (void) SetImageStorageClass(image,DirectClass,&image->exception);
     if (image->storage_class != DirectClass)
       {
         /*
@@ -1536,10 +1536,10 @@ static MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image)
           bmp_info.bits_per_pixel=8;
         bmp_info.number_colors=1U << bmp_info.bits_per_pixel;
         if (image->matte != MagickFalse)
-          (void) SetImageStorageClass(image,DirectClass);
+          (void) SetImageStorageClass(image,DirectClass,&image->exception);
         else
           if ((size_t) bmp_info.number_colors < image->colors)
-            (void) SetImageStorageClass(image,DirectClass);
+            (void) SetImageStorageClass(image,DirectClass,&image->exception);
           else
             {
               bmp_info.file_size+=3*(1UL << bmp_info.bits_per_pixel);

diff --git a/coders/histogram.c b/coders/histogram.c
index 6ce7d7bfd70b1deb0a0473f1a361a5cfbdc544f2..619d80e7a4a94c876f31ceb8c07a14934fc70c3f 100644 (file)
--- a/coders/histogram.c
+++ b/coders/histogram.c
@@ -243,7 +243,7 @@ static MagickBooleanType WriteHISTOGRAMImage(const ImageInfo *image_info,
     &image->exception);
   if (histogram_image == (Image *) NULL)
     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
-  (void) SetImageStorageClass(histogram_image,DirectClass);
+  (void) SetImageStorageClass(histogram_image,DirectClass,&image->exception);
   /*
     Allocate histogram count arrays.
   */

diff --git a/coders/icon.c b/coders/icon.c
index 3a7e7aa62daecf5b8e5606a1a1ea681d17b5f138..6a18c0fcf3cda5b2d609ec6d2955d5cb1eb1f4ed 100644 (file)
--- a/coders/icon.c
+++ b/coders/icon.c
@@ -900,7 +900,7 @@ static MagickBooleanType WriteICONImage(const ImageInfo *image_info,
         icon_info.offset_bits=icon_info.file_size;
         icon_info.compression=BI_RGB;
         if ((next->storage_class != DirectClass) && (next->colors > 256))
-          (void) SetImageStorageClass(next,DirectClass);
+          (void) SetImageStorageClass(next,DirectClass,&next->exception);
         if (next->storage_class == DirectClass)
           {
             /*
@@ -929,7 +929,7 @@ static MagickBooleanType WriteICONImage(const ImageInfo *image_info,
             icon_info.number_colors=one << icon_info.bits_per_pixel;
             if (icon_info.number_colors < next->colors)
               {
-                (void) SetImageStorageClass(next,DirectClass);
+                (void) SetImageStorageClass(next,DirectClass,&next->exception);
                 icon_info.number_colors=0;
                 icon_info.bits_per_pixel=(unsigned short) 24;
                 icon_info.compression=(size_t) BI_RGB;

diff --git a/coders/miff.c b/coders/miff.c
index 3239a0790de165f0908884a40414c3af969ab5cb..4e4197581108f52a0e7061c5d6e19604279ff48d 100644 (file)
--- a/coders/miff.c
+++ b/coders/miff.c
@@ -1882,7 +1882,7 @@ static MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
       }
     if ((image->storage_class == PseudoClass) &&
         (image->colors > (size_t) (GetQuantumRange(image->depth)+1)))
-      (void) SetImageStorageClass(image,DirectClass);
+      (void) SetImageStorageClass(image,DirectClass,&image->exception);
     if (IsImageGray(image,&image->exception) != MagickFalse)
       {
         image->storage_class=DirectClass;

diff --git a/coders/palm.c b/coders/palm.c
index cc8549929ab0afcab3e5ea09ebdc24877ad5b62f..91cc2094d08811f93373a1017b4f48aba771bd9b 100644 (file)
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -748,7 +748,7 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
         (void) SortColormapByIntensity(image);
       }
     if ((image->storage_class == PseudoClass) && (image->colors > 256))
-      (void) SetImageStorageClass(image,DirectClass);
+      (void) SetImageStorageClass(image,DirectClass,&image->exception);
     if (image->storage_class == PseudoClass)
       flags|=PALM_HAS_COLORMAP_FLAG;
     else

diff --git a/coders/tiff.c b/coders/tiff.c
index ea73e3bebca38b43f613bbd005c42607753b5cf4..5723cdd9f265cdbf28544b3463c53e4cb52a04bf 100644 (file)
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1450,7 +1450,7 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
             TIFFClose(tiff);
             ThrowReaderException(CoderError,"ImageIsNotTiled");
           }
-        (void) SetImageStorageClass(image,DirectClass);
+        (void) SetImageStorageClass(image,DirectClass,&image->exception);
         number_pixels=columns*rows;
         tile_pixels=(uint32 *) AcquireQuantumMemory(number_pixels,
           sizeof(*tile_pixels));
@@ -2658,7 +2658,7 @@ static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
       }
       case JPEGCompression:
       {
-        (void) SetImageStorageClass(image,DirectClass);
+        (void) SetImageStorageClass(image,DirectClass,&image->exception);
         (void) SetImageDepth(image,8);
         break;
       }
@@ -2683,7 +2683,7 @@ static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
             {
               photometric=PHOTOMETRIC_YCBCR;
               (void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,1,1);
-              (void) SetImageStorageClass(image,DirectClass);
+              (void) SetImageStorageClass(image,DirectClass,&image->exception);
               (void) SetImageDepth(image,8);
             }
           else

diff --git a/coders/viff.c b/coders/viff.c
index a4fae9d2b4da26dadccd2481560c726980dca6ae..2cb07e1f74641f43f707d9037e08f74b2203121d 100644 (file)
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -973,7 +973,7 @@ static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
     if (IsRGBColorspace(image->colorspace) == MagickFalse)
       (void) TransformImageColorspace(image,RGBColorspace);
     if (IsImageGray(image,&image->exception) != MagickFalse)
-      (void) SetImageStorageClass(image,DirectClass);
+      (void) SetImageStorageClass(image,DirectClass,&image->exception);
     viff_info.identifier=(char) 0xab;
     viff_info.file_type=1;
     viff_info.release=1;