(no commit message)

diff --git a/Magick++/lib/Pixels.cpp b/Magick++/lib/Pixels.cpp
index df5b98939805fbdb535ac402214d16b27ee519f2..8c6b5cf1d97ee5dbb32ce4dca44b451363dab2db 100644 (file)
--- a/Magick++/lib/Pixels.cpp
+++ b/Magick++/lib/Pixels.cpp
@@ -24,7 +24,7 @@ namespace Magick
 // Construct pixel view using specified image.
 Magick::Pixels::Pixels( Magick::Image &image_ )
   : _image(image_),
-    _view(AcquireVirtualCacheView(_image.image())),
+    _view(AcquireVirtualCacheView(_image.image(),&_exception)),
     _x(0),
     _y(0),
     _columns(0),

diff --git a/MagickCore/annotate.c b/MagickCore/annotate.c
index 1f643131ce370155bb1f43161b8fa2c466e6fb78..cd5722f08746fa4d4703c53b2e74153a961502b4 100644 (file)
--- a/MagickCore/annotate.c
+++ b/MagickCore/annotate.c
@@ -1386,7 +1386,7 @@ static MagickBooleanType RenderFreetype(Image *image,const DrawInfo *draw_info,
           Rasterize the glyph.
         */
         status=MagickTrue;
-        image_view=AcquireAuthenticCacheView(image);
+        image_view=AcquireAuthenticCacheView(image,exception);
         p=bitmap->bitmap.buffer;
         for (y=0; y < (ssize_t) bitmap->bitmap.rows; y++)
         {
@@ -1824,7 +1824,7 @@ static MagickBooleanType RenderPostscript(Image *image,
         (void) SetImageAlphaChannel(annotate_image,OpaqueAlphaChannel,
           exception);
       fill_color=draw_info->fill;
-      annotate_view=AcquireAuthenticCacheView(annotate_image);
+      annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
       for (y=0; y < (ssize_t) annotate_image->rows; y++)
       {
         register ssize_t

diff --git a/MagickCore/attribute.c b/MagickCore/attribute.c
index b0aefa5a3a0c29267deb7e5a2bf384162a03f272..78237e7b72c09f3a52313911f4a4c285b5745529 100644 (file)
--- a/MagickCore/attribute.c
+++ b/MagickCore/attribute.c
@@ -151,7 +151,7 @@ MagickExport RectangleInfo GetImageBoundingBox(const Image *image,
   bounds.x=(ssize_t) image->columns;
   bounds.y=(ssize_t) image->rows;
   GetPixelInfo(image,&target[0]);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   p=GetCacheViewVirtualPixels(image_view,0,0,1,1,exception);
   if (p == (const Quantum *) NULL)
     {
@@ -352,7 +352,7 @@ MagickExport size_t GetImageDepth(const Image *image,ExceptionInfo *exception)
       current_depth=(size_t *) RelinquishMagickMemory(current_depth);
       return(depth);
     }
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   if (QuantumRange <= MaxMap)
     {
@@ -696,7 +696,7 @@ MagickExport MagickBooleanType IsImageGray(const Image *image,
       (IsRGBColorspace(image->colorspace) == MagickFalse))
     return(MagickFalse);
   type=BilevelType;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -781,7 +781,7 @@ MagickExport MagickBooleanType IsImageMonochrome(const Image *image,
       (IsRGBColorspace(image->colorspace) == MagickFalse))
     return(MagickFalse);
   type=BilevelType;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -858,7 +858,7 @@ MagickExport MagickBooleanType IsImageOpaque(const Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if (image->alpha_trait != BlendPixelTrait)
     return(MagickTrue);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -957,7 +957,7 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
       }
     }
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if !defined(MAGICKCORE_HDRI_SUPPORT)
   if (QuantumRange <= MaxMap)
     {

diff --git a/MagickCore/cache-view.c b/MagickCore/cache-view.c
index 84746d3a77d8a29b2f96c334bdd75a43c61ef1df..069afe331b211117ebf5d32dbf8327d365ba2528 100644 (file)
--- a/MagickCore/cache-view.c
+++ b/MagickCore/cache-view.c
@@ -95,10 +95,12 @@ struct _CacheView
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  AcquireAuthenticCacheView() acquires an authentic view into the pixel cache.
+%  It always succeeds but may return a warning or informational exception.
 %
 %  The format of the AcquireAuthenticCacheView method is:
 %
-%      CacheView *AcquireAuthenticCacheView(const Image *image)
+%      CacheView *AcquireAuthenticCacheView(const Image *image,
+%        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -107,18 +109,14 @@ struct _CacheView
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport CacheView *AcquireAuthenticCacheView(const Image *image)
+MagickExport CacheView *AcquireAuthenticCacheView(const Image *image,
+  ExceptionInfo *exception)
 {
   CacheView
     *cache_view;
 
-  ExceptionInfo
-    *exception;
-
-  cache_view=AcquireVirtualCacheView(image);
-  exception=AcquireExceptionInfo();
+  cache_view=AcquireVirtualCacheView(image,exception);
   (void) SyncImagePixelCache(cache_view->image,exception);
-  exception=DestroyExceptionInfo(exception);
   return(cache_view);
 }
 \f
@@ -135,6 +133,7 @@ MagickExport CacheView *AcquireAuthenticCacheView(const Image *image)
 %
 %  AcquireVirtualCacheView() acquires a virtual view into the pixel cache,
 %  using the VirtualPixelMethod that is defined within the given image itself.
+%  It always succeeds but may return a warning or informational exception.
 %
 %  The format of the AcquireVirtualCacheView method is:
 %
@@ -145,8 +144,11 @@ MagickExport CacheView *AcquireAuthenticCacheView(const Image *image)
 %
 %    o image: the image.
 %
+%    o exception: return any errors or warnings in this structure.
+%
 */
-MagickExport CacheView *AcquireVirtualCacheView(const Image *image)
+MagickExport CacheView *AcquireVirtualCacheView(const Image *image,
+  ExceptionInfo *exception)
 {
   CacheView
     *cache_view;
@@ -155,6 +157,7 @@ MagickExport CacheView *AcquireVirtualCacheView(const Image *image)
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  (void) exception;
   cache_view=(CacheView *) MagickAssumeAligned(AcquireAlignedMemory(1,
     sizeof(*cache_view)));
   if (cache_view == (CacheView *) NULL)

diff --git a/MagickCore/cache-view.h b/MagickCore/cache-view.h
index 4eeab53b69e1ad9d0721304db217b727830cedb1..b9e076e41a49389ddef0771a42e2d72aa0488962 100644 (file)
--- a/MagickCore/cache-view.h
+++ b/MagickCore/cache-view.h
@@ -49,8 +49,8 @@ typedef struct _CacheView
   CacheView;
 
 extern MagickExport CacheView
-  *AcquireAuthenticCacheView(const Image *),
-  *AcquireVirtualCacheView(const Image *),
+  *AcquireAuthenticCacheView(const Image *,ExceptionInfo *),
+  *AcquireVirtualCacheView(const Image *,ExceptionInfo *),
   *CloneCacheView(const CacheView *),
   *DestroyCacheView(CacheView *);
 

diff --git a/MagickCore/cache.c b/MagickCore/cache.c
index c01eca3dcc8d0310f3cbff30aefd537d89435189..98bb65d623850689c60e409df96493b661848d02 100644 (file)
--- a/MagickCore/cache.c
+++ b/MagickCore/cache.c
@@ -4909,7 +4909,7 @@ static MagickBooleanType SetCacheAlphaChannel(Image *image,const Quantum alpha,
   assert(cache_info->signature == MagickSignature);
   image->alpha_trait=BlendPixelTrait;
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);  /* must be virtual */
+  image_view=AcquireVirtualCacheView(image,exception);  /* must be virtual */
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/channel.c b/MagickCore/channel.c
index 24a0117423d733055b12815623645989d10fb1c4..210a6b85848e3892cb58f3e488800d0ea847c04a 100644 (file)
--- a/MagickCore/channel.c
+++ b/MagickCore/channel.c
@@ -135,8 +135,8 @@ static MagickBooleanType ChannelImage(Image *destination_image,
     y;
 
   status=MagickTrue;
-  source_view=AcquireVirtualCacheView(source_image);
-  destination_view=AcquireAuthenticCacheView(destination_image);
+  source_view=AcquireVirtualCacheView(source_image,exception);
+  destination_view=AcquireAuthenticCacheView(destination_image,exception);
   height=MagickMin(source_image->rows,destination_image->rows);
   width=MagickMin(source_image->columns,destination_image->columns);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -497,7 +497,7 @@ MagickExport Image *CombineImages(const Image *image,
   */
   status=MagickTrue;
   progress=0;
-  combine_view=AcquireAuthenticCacheView(combine_image);
+  combine_view=AcquireAuthenticCacheView(combine_image,exception);
   for (y=0; y < (ssize_t) combine_image->rows; y++)
   {
     CacheView
@@ -545,7 +545,7 @@ MagickExport Image *CombineImages(const Image *image,
       traits=GetPixelChannelTraits(combine_image,channel);
       if (traits == UndefinedPixelTrait)
         continue;
-      image_view=AcquireVirtualCacheView(next);
+      image_view=AcquireVirtualCacheView(next,exception);
       p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
       if (p == (const Quantum *) NULL)
         continue;
@@ -657,8 +657,8 @@ MagickExport Image *SeparateImage(const Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  separate_view=AcquireAuthenticCacheView(separate_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  separate_view=AcquireAuthenticCacheView(separate_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/cipher.c b/MagickCore/cipher.c
index e5dd07798e28f84de9fc9969adec9a555bf6f0cb..8a604256bbace7cdbef210461c711445e4f3a7cf 100644 (file)
--- a/MagickCore/cipher.c
+++ b/MagickCore/cipher.c
@@ -661,7 +661,7 @@ MagickExport MagickBooleanType PasskeyDecipherImage(Image *image,
     }
   quantum_type=GetQuantumType(image,exception);
   pixels=GetQuantumPixels(quantum_info);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register ssize_t
@@ -881,7 +881,7 @@ MagickExport MagickBooleanType PasskeyEncipherImage(Image *image,
     }
   quantum_type=GetQuantumType(image,exception);
   pixels=GetQuantumPixels(quantum_info);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register ssize_t

diff --git a/MagickCore/color.c b/MagickCore/color.c
index 443a9426fda5f7074520c77487291a4f1865e44e..432ad6d7a17ff070350e513a1cc13804db10f3af 100644 (file)
--- a/MagickCore/color.c
+++ b/MagickCore/color.c
@@ -1659,8 +1659,8 @@ MagickExport MagickBooleanType IsEquivalentImage(const Image *image,
   status=MagickTrue;
   GetPixelInfo(image,&pixel);
   GetPixelInfo(image,&target);
-  image_view=AcquireVirtualCacheView(image);
-  target_view=AcquireVirtualCacheView(target_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  target_view=AcquireVirtualCacheView(target_image,exception);
   for (y=(*y_offset); y < (ssize_t) image->rows; y++)
   {
     for (x=y == 0 ? *x_offset : 0; x < (ssize_t) image->columns; x++)

diff --git a/MagickCore/colormap.c b/MagickCore/colormap.c
index 9e202cf7e765fbf34bf116c480d84edff545014c..90be843901f1338efff511d96d4d9a787ab89a20 100644 (file)
--- a/MagickCore/colormap.c
+++ b/MagickCore/colormap.c
@@ -204,7 +204,7 @@ MagickExport MagickBooleanType CycleColormapImage(Image *image,
   if (image->storage_class == DirectClass)
     (void) SetImageType(image,PaletteType,exception);
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -350,7 +350,7 @@ MagickExport MagickBooleanType SortColormapByIntensity(Image *image,
   for (i=0; i < (ssize_t) image->colors; i++)
     pixels[(ssize_t) image->colormap[i].alpha]=(unsigned short) i;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     Quantum

diff --git a/MagickCore/colorspace.c b/MagickCore/colorspace.c
index c2e319b84c3715ac64d78ab54170cda7102878d3..3b9d6a087d02c211a6cb3bad59367ceb6b1235d4 100644 (file)
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -262,7 +262,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -331,7 +331,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
         return(MagickFalse);
       GetPixelInfo(image,&zero);
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -394,7 +394,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -456,7 +456,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -521,7 +521,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -586,7 +586,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -651,7 +651,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -716,7 +716,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -785,7 +785,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -860,7 +860,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -973,7 +973,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
         logmap[i]=ScaleMapToQuantum((double) (MaxMap*(reference_white+
           log10(black+(1.0*i/MaxMap)*(1.0-black))/((gamma/density)*0.002f/
           film_gamma))/1024.0));
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1038,7 +1038,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1107,7 +1107,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1169,7 +1169,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1230,7 +1230,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1570,7 +1570,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       /*
         Convert DirectClass image.
       */
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2227,7 +2227,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2295,7 +2295,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
             return(MagickFalse);
         }
       GetPixelInfo(image,&zero);
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2359,7 +2359,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
         }
       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
         return(MagickFalse);
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2416,7 +2416,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2481,7 +2481,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2546,7 +2546,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2611,7 +2611,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2676,7 +2676,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2745,7 +2745,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2818,7 +2818,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2933,7 +2933,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2998,7 +2998,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3067,7 +3067,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3128,7 +3128,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
             return(MagickFalse);
         }
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3457,7 +3457,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       /*
         Convert DirectClass image.
       */
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 49e411b71f5c0c30258cf58118bf672c990e41a8..7983c0e2bd5f677912b207318134f7acf5dd99a9 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -174,9 +174,9 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
     Generate difference image.
   */
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
-  highlight_view=AcquireAuthenticCacheView(highlight_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
+  highlight_view=AcquireAuthenticCacheView(highlight_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -323,8 +323,8 @@ static MagickBooleanType GetAbsoluteDistortion(const Image *image,
     Compute the absolute difference in pixels between two images.
   */
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -448,8 +448,8 @@ static MagickBooleanType GetFuzzDistortion(const Image *image,
     y;
 
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -549,8 +549,8 @@ static MagickBooleanType GetMeanAbsoluteDistortion(const Image *image,
     y;
 
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -657,8 +657,8 @@ static MagickBooleanType GetMeanErrorPerPixel(Image *image,
   area=0.0;
   maximum_error=0.0;
   mean_error=0.0;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -744,8 +744,8 @@ static MagickBooleanType GetMeanSquaredDistortion(const Image *image,
     y;
 
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -866,8 +866,8 @@ static MagickBooleanType GetNormalizedCrossCorrelationDistortion(
   for (i=0; i <= MaxPixelChannels; i++)
     distortion[i]=0.0;
   area=1.0/((double) image->columns*image->rows-1);
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -979,8 +979,8 @@ static MagickBooleanType GetPeakAbsoluteDistortion(const Image *image,
     y;
 
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1406,8 +1406,8 @@ MagickExport MagickBooleanType IsImagesEqual(Image *image,
   maximum_error=0.0;
   mean_error_per_pixel=0.0;
   mean_error=0.0;
-  image_view=AcquireVirtualCacheView(image);
-  reconstruct_view=AcquireVirtualCacheView(reconstruct_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1590,7 +1590,7 @@ MagickExport Image *SimilarityImage(Image *image,const Image *reference,
   */
   status=MagickTrue;
   progress=0;
-  similarity_view=AcquireAuthenticCacheView(similarity_image);
+  similarity_view=AcquireAuthenticCacheView(similarity_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index 5d8099c7d55a67611c521636f83a5cce4f204bf5..2b2ab3ca31b50dd58d5540b994dcddbd8beab5cb 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -356,8 +356,8 @@ static MagickBooleanType CompositeOverImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  composite_view=AcquireVirtualCacheView(composite_image);
-  image_view=AcquireAuthenticCacheView(image);
+  composite_view=AcquireVirtualCacheView(composite_image,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -635,8 +635,8 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
       if ((y_offset+(ssize_t) composite_image->rows) >= (ssize_t) image->rows)
         break;
       status=MagickTrue;
-      composite_view=AcquireVirtualCacheView(composite_image);
-      image_view=AcquireAuthenticCacheView(image);
+      composite_view=AcquireVirtualCacheView(composite_image,exception);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -835,8 +835,8 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
 
       /* do the variable blurring of each pixel in image */
       GetPixelInfo(image,&pixel);
-      composite_view=AcquireVirtualCacheView(composite_image);
-      destination_view=AcquireAuthenticCacheView(destination_image);
+      composite_view=AcquireVirtualCacheView(composite_image,exception);
+      destination_view=AcquireAuthenticCacheView(destination_image,exception);
       for (y=0; y < (ssize_t) composite_image->rows; y++)
       {
         MagickBooleanType
@@ -1020,9 +1020,9 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
         displacement/distortion map.  -- Like a lens...
       */
       GetPixelInfo(image,&pixel);
-      image_view=AcquireVirtualCacheView(image);
-      composite_view=AcquireVirtualCacheView(composite_image);
-      destination_view=AcquireAuthenticCacheView(destination_image);
+      image_view=AcquireVirtualCacheView(image,exception);
+      composite_view=AcquireVirtualCacheView(composite_image,exception);
+      destination_view=AcquireAuthenticCacheView(destination_image,exception);
       for (y=0; y < (ssize_t) composite_image->rows; y++)
       {
         MagickBooleanType
@@ -1204,8 +1204,8 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
   status=MagickTrue;
   progress=0;
   midpoint=((MagickRealType) QuantumRange+1.0)/2;
-  composite_view=AcquireVirtualCacheView(composite_image);
-  image_view=AcquireAuthenticCacheView(image);
+  composite_view=AcquireVirtualCacheView(composite_image,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2459,8 +2459,8 @@ MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
     Tile texture onto the image background (optimized).
   */
   status=MagickTrue;
-  texture_view=AcquireVirtualCacheView(texture_image);
-  image_view=AcquireAuthenticCacheView(image);
+  texture_view=AcquireVirtualCacheView(texture_image,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/compress.c b/MagickCore/compress.c
index 93e1419b8d2128b5875d0da7443ea8153e1ad2bf..b33d1482585b8aaa8426b37e0cb01bb3c9722b35 100644 (file)
--- a/MagickCore/compress.c
+++ b/MagickCore/compress.c
@@ -500,7 +500,7 @@ MagickExport MagickBooleanType HuffmanDecodeImage(Image *image,
   image->resolution.x=204.0;
   image->resolution.y=196.0;
   image->units=PixelsPerInchResolution;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
   {
     register Quantum

diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index fe99ef616248826e9f135d399fff8db75ed5ae68..7afb85ba9bfc89bf44dbcfa799ce3f58b7b9943f 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -281,8 +281,8 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
   trough.alpha=matte.alpha;
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  frame_view=AcquireAuthenticCacheView(frame_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  frame_view=AcquireAuthenticCacheView(frame_image,exception);
   height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
     frame_info->inner_bevel);
   if (height != 0)
@@ -689,7 +689,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/display.c b/MagickCore/display.c
index 8712d6a6e8ecf8058cad2b93c6a616dd8ef3fe12..be5e32059e785ce28df97875833082752b87a58e 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -4336,7 +4336,7 @@ static MagickBooleanType XCompositeImage(Display *display,
       if( IfMagickFalse(SetImageStorageClass(image,DirectClass,exception)) )
         return(MagickFalse);
       image->alpha_trait=BlendPixelTrait;
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
       for (y=0; y < (int) image->rows; y++)
       {
         q=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,image->columns,1,
@@ -5357,7 +5357,7 @@ static MagickBooleanType XCropImage(Display *display,
   if( IfMagickFalse(SetImageStorageClass(image,DirectClass,exception)) )
     return(MagickFalse);
   image->alpha_trait=BlendPixelTrait;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (int) crop_info.height; y++)
   {
     q=GetCacheViewAuthenticPixels(image_view,crop_info.x,y+crop_info.y,
@@ -13267,7 +13267,7 @@ static Image *XTileImage(Display *display,XResourceInfo *resource_info,
         */
         x_offset=(int) (width*(tile % (((int) image->columns-x)/width))+x);
         y_offset=(int) (height*(tile/(((int) image->columns-x)/width))+y);
-        image_view=AcquireAuthenticCacheView(image);
+        image_view=AcquireAuthenticCacheView(image,exception);
         (void) GetOneCacheViewVirtualPixelInfo(image_view,0,0,&pixel,exception);
         for (i=0; i < (int) height; i++)
         {

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index 2a81a32614703f3f3dfc0fb8df8cb907fb130338..2a854023d9d4e5777789e05183a3194a3c1f4933 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -2324,7 +2324,7 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
     GetPixelInfo(distort_image,&zero);
     resample_filter=AcquireResampleFilterThreadSet(image,
       UndefinedVirtualPixelMethod,MagickFalse,exception);
-    distort_view=AcquireAuthenticCacheView(distort_image);
+    distort_view=AcquireAuthenticCacheView(distort_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
       dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3047,7 +3047,7 @@ MagickExport Image *SparseColorImage(const Image *image,
 
     status=MagickTrue;
     progress=0;
-    sparse_view=AcquireAuthenticCacheView(sparse_image);
+    sparse_view=AcquireAuthenticCacheView(sparse_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(progress,status) \
       dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index 29bb8c11e0e1ef7acd80c2c137a1b20a9ccae88a..fdfcb5d0ad0b7e93e9584b4d598e5371c347966b 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -1171,8 +1171,8 @@ MagickExport MagickBooleanType DrawAffineImage(Image *image,
   height=(size_t) (floor(edge.y2+0.5)-ceil(edge.y1-0.5));
   width=(size_t) (floor(edge.x2+0.5)-ceil(edge.x1-0.5));
 #endif
-  source_view=AcquireVirtualCacheView(source);
-  image_view=AcquireAuthenticCacheView(image);
+  source_view=AcquireVirtualCacheView(source,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,width,height,1)
@@ -3266,7 +3266,7 @@ MagickExport MagickBooleanType DrawGradientImage(Image *image,
   height=bounding_box.height-bounding_box.y;
   width=bounding_box.width-bounding_box.x;
 #endif
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,width,height,1)
@@ -3872,7 +3872,7 @@ static MagickBooleanType DrawPolygonPrimitive(Image *image,
   bounds.y2=bounds.y2 < 0.0 ? 0.0 : (size_t) floor(bounds.y2+0.5) >=
     image->rows ? (double) image->rows-1 : bounds.y2;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   height=(size_t) (floor(bounds.y2+0.5)-ceil(bounds.y1-0.5));
   width=(size_t) (floor(bounds.x2+0.5)-ceil(bounds.x1-0.5));
@@ -4182,7 +4182,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
   status=MagickTrue;
   x=(ssize_t) ceil(primitive_info->point.x-0.5);
   y=(ssize_t) ceil(primitive_info->point.y-0.5);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   switch (primitive_info->primitive)
   {
     case PointPrimitive:

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index e189e53f84bd9fcf43669bafdfb50f0ac09207d9..5db0aa45b9c5b62499d6a24e440abb84ef877787 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -295,9 +295,9 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  edge_view=AcquireVirtualCacheView(edge_image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  edge_view=AcquireVirtualCacheView(edge_image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -620,9 +620,9 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  edge_view=AcquireVirtualCacheView(edge_image);
-  sharp_view=AcquireAuthenticCacheView(sharp_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  edge_view=AcquireVirtualCacheView(edge_image,exception);
+  sharp_view=AcquireAuthenticCacheView(sharp_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -949,8 +949,8 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
   status=MagickTrue;
   progress=0;
   center=(ssize_t) GetPixelChannels(image)*(width/2L);
-  image_view=AcquireVirtualCacheView(image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1074,8 +1074,8 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
     Blur columns.
   */
   center=(ssize_t) GetPixelChannels(blur_image)*(width/2L);
-  image_view=AcquireVirtualCacheView(blur_image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(blur_image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1421,8 +1421,8 @@ MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
     Reduce speckle in the image.
   */
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
-  despeckle_view=AcquireAuthenticCacheView(despeckle_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  despeckle_view=AcquireAuthenticCacheView(despeckle_image,exception);
   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
   {
     PixelChannel
@@ -1947,9 +1947,9 @@ MagickExport Image *MotionBlurImage(const Image *image,const double radius,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  motion_view=AcquireVirtualCacheView(image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  motion_view=AcquireVirtualCacheView(image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2723,9 +2723,9 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  radial_view=AcquireVirtualCacheView(image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  radial_view=AcquireVirtualCacheView(image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3033,9 +3033,9 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
   progress=0;
   center=(ssize_t) (GetPixelChannels(image)*(image->columns+width)*(width/2L)+
     GetPixelChannels(image)*(width/2L));
-  image_view=AcquireVirtualCacheView(image);
-  luminance_view=AcquireVirtualCacheView(luminance_image);
-  blur_view=AcquireAuthenticCacheView(blur_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  luminance_view=AcquireVirtualCacheView(luminance_image,exception);
+  blur_view=AcquireAuthenticCacheView(blur_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3299,8 +3299,8 @@ MagickExport Image *ShadeImage(const Image *image,const MagickBooleanType gray,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  shade_view=AcquireAuthenticCacheView(shade_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  shade_view=AcquireAuthenticCacheView(shade_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3625,8 +3625,8 @@ MagickExport Image *SpreadImage(const Image *image,const double radius,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
 #endif
-  image_view=AcquireVirtualCacheView(image);
-  spread_view=AcquireAuthenticCacheView(spread_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  spread_view=AcquireAuthenticCacheView(spread_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,key == ~0UL)
@@ -3767,8 +3767,8 @@ MagickExport Image *UnsharpMaskImage(const Image *image,const double radius,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  unsharp_view=AcquireAuthenticCacheView(unsharp_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  unsharp_view=AcquireAuthenticCacheView(unsharp_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index 3068cbfa37bde351d9ef240d4d1de66acc907750..c1025359cd2d66358642caadb363ad4eb87b0e55 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -342,7 +342,7 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image,
   status=MagickTrue;
   progress=0;
   adjust=(ssize_t) (clut_image->interpolate == IntegerInterpolatePixel ? 0 : 1);
-  clut_view=AcquireVirtualCacheView(clut_image);
+  clut_view=AcquireVirtualCacheView(clut_image,exception);
   for (i=0; i <= (ssize_t) MaxMap; i++)
   {
     GetPixelInfo(clut_image,clut_map+i);
@@ -351,7 +351,7 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image,
       (clut_image->rows-adjust),clut_map+i,exception);
   }
   clut_view=DestroyCacheView(clut_view);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -737,7 +737,7 @@ MagickExport MagickBooleanType ColorDecisionListImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -902,7 +902,7 @@ MagickExport MagickBooleanType ContrastImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1058,7 +1058,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   status=MagickTrue;
   (void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
     sizeof(*histogram));
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1198,7 +1198,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1348,8 +1348,8 @@ MagickExport Image *EnhanceImage(const Image *image,ExceptionInfo *exception)
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  enhance_view=AcquireAuthenticCacheView(enhance_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  enhance_view=AcquireAuthenticCacheView(enhance_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1552,7 +1552,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
   status=MagickTrue;
   (void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
     sizeof(*histogram));
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1668,7 +1668,7 @@ MagickExport MagickBooleanType EqualizeImage(Image *image,
     Equalize image.
   */
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1835,7 +1835,7 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2004,8 +2004,8 @@ MagickExport MagickBooleanType HaldClutImage(Image *image,
   cube_size=level*level;
   width=(double) hald_image->columns;
   GetPixelInfo(hald_image,&zero);
-  hald_view=AcquireVirtualCacheView(hald_image);
-  image_view=AcquireAuthenticCacheView(image);
+  hald_view=AcquireVirtualCacheView(hald_image,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2210,7 +2210,7 @@ MagickExport MagickBooleanType LevelImage(Image *image,const double black_point,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2375,7 +2375,7 @@ MagickExport MagickBooleanType LevelizeImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2647,7 +2647,7 @@ MagickExport MagickBooleanType LinearStretchImage(Image *image,
     Form histogram.
   */
   (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram));
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -2925,7 +2925,7 @@ MagickExport MagickBooleanType ModulateImage(Image *image,const char *modulate,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3082,7 +3082,7 @@ MagickExport MagickBooleanType NegateImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   if (grayscale != MagickFalse)
     {
       for (y=0; y < (ssize_t) image->rows; y++)
@@ -3456,7 +3456,7 @@ MagickExport MagickBooleanType SigmoidalContrastImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/feature.c b/MagickCore/feature.c
index fc8df1a2bf6d0482b5ad34575bc0dd504dc908ab..8368b5fcaeb981025b347d2a88730387921368e7 100644 (file)
--- a/MagickCore/feature.c
+++ b/MagickCore/feature.c
@@ -221,7 +221,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
     grays[i].black=(~0U);
   }
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -396,7 +396,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
     Initialize spatial dependence matrix.
   */
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum

diff --git a/MagickCore/fourier.c b/MagickCore/fourier.c
index a6497c9c97004e0159292b690f1d9773d1e0310a..6d068cd02ca665749132222c87ac20520e24d318 100644 (file)
--- a/MagickCore/fourier.c
+++ b/MagickCore/fourier.c
@@ -290,7 +290,7 @@ static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
           i++;
         }
     }
-  magnitude_view=AcquireAuthenticCacheView(magnitude_image);
+  magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
   i=0L;
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
@@ -343,7 +343,7 @@ static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
   }
   magnitude_view=DestroyCacheView(magnitude_view);
   i=0L;
-  phase_view=AcquireAuthenticCacheView(phase_image);
+  phase_view=AcquireAuthenticCacheView(phase_image,exception);
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
     q=GetCacheViewAuthenticPixels(phase_view,0L,y,fourier_info->height,1UL,
@@ -439,7 +439,7 @@ static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,
   ResetMagickMemory(source,0,fourier_info->height*fourier_info->width*
     sizeof(*source));
   i=0L;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0L,y,fourier_info->width,1UL,
@@ -855,7 +855,7 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
       return(MagickFalse);
     }
   i=0L;
-  magnitude_view=AcquireVirtualCacheView(magnitude_image);
+  magnitude_view=AcquireVirtualCacheView(magnitude_image,exception);
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
     p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,
@@ -898,7 +898,7 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
     }
   }
   i=0L;
-  phase_view=AcquireVirtualCacheView(phase_image);
+  phase_view=AcquireVirtualCacheView(phase_image,exception);
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
     p=GetCacheViewVirtualPixels(phase_view,0,y,fourier_info->width,1,
@@ -1055,7 +1055,7 @@ static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
     fftw_destroy_plan(fftw_c2r_plan);
   }
   i=0L;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0L; y < (ssize_t) fourier_info->height; y++)
   {
     if (y >= (ssize_t) image->rows)

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index 438df2d1b5bbf851369203921fd4e0d8e6f0598f..03603950500eae13c1f8a4039732e30a0bb41aea 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -189,7 +189,7 @@ MagickPrivate FxInfo *AcquireFxInfo(const Image *image,const char *expression,
   next=GetFirstImageInList(fx_info->images);
   for ( ; next != (Image *) NULL; next=next->next)
   {
-    fx_info->view[i]=AcquireVirtualCacheView(next);
+    fx_info->view[i]=AcquireVirtualCacheView(next,exception);
     i++;
   }
   fx_info->random_info=AcquireRandomInfo();
@@ -313,8 +313,8 @@ MagickExport Image *AddNoiseImage(const Image *image,const NoiseType noise_type,
   status=MagickTrue;
   progress=0;
   random_info=AcquireRandomInfoThreadSet();
-  image_view=AcquireVirtualCacheView(image);
-  noise_view=AcquireAuthenticCacheView(noise_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  noise_view=AcquireAuthenticCacheView(noise_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
@@ -476,8 +476,8 @@ MagickExport Image *BlueShiftImage(const Image *image,const double factor,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  shift_view=AcquireAuthenticCacheView(shift_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  shift_view=AcquireAuthenticCacheView(shift_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -739,8 +739,8 @@ MagickExport Image *ColorizeImage(const Image *image,const char *blend,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  colorize_view=AcquireAuthenticCacheView(colorize_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  colorize_view=AcquireAuthenticCacheView(colorize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -957,8 +957,8 @@ MagickExport Image *ColorMatrixImage(const Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  color_view=AcquireAuthenticCacheView(color_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  color_view=AcquireAuthenticCacheView(color_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3069,8 +3069,8 @@ MagickExport Image *FxImage(const Image *image,const char *expression,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  fx_view=AcquireAuthenticCacheView(fx_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  fx_view=AcquireAuthenticCacheView(fx_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3263,8 +3263,8 @@ MagickExport Image *ImplodeImage(const Image *image,const double amount,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  implode_view=AcquireAuthenticCacheView(implode_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  implode_view=AcquireAuthenticCacheView(implode_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3508,8 +3508,8 @@ MagickExport Image *MorphImages(const Image *image,const size_t number_frames,
           morph_images=DestroyImageList(morph_images);
           return((Image *) NULL);
         }
-      image_view=AcquireVirtualCacheView(morph_image);
-      morph_view=AcquireAuthenticCacheView(morph_images);
+      image_view=AcquireVirtualCacheView(morph_image,exception);
+      morph_view=AcquireAuthenticCacheView(morph_images,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3886,9 +3886,9 @@ MagickExport MagickBooleanType PlasmaImage(Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
     return(MagickFalse);
-  image_view=AcquireAuthenticCacheView(image);
-  u_view=AcquireVirtualCacheView(image);
-  v_view=AcquireVirtualCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
+  u_view=AcquireVirtualCacheView(image,exception);
+  v_view=AcquireVirtualCacheView(image,exception);
   random_info=AcquireRandomInfo();
   status=PlasmaImageProxy(image,image_view,u_view,v_view,random_info,segment,
     attenuate,depth,exception);
@@ -4159,8 +4159,8 @@ MagickExport Image *SepiaToneImage(const Image *image,const double threshold,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  sepia_view=AcquireAuthenticCacheView(sepia_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  sepia_view=AcquireAuthenticCacheView(sepia_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -4324,7 +4324,7 @@ MagickExport Image *ShadowImage(const Image *image,const double alpha,
     Shadow image.
   */
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(border_image);
+  image_view=AcquireAuthenticCacheView(border_image,exception);
   for (y=0; y < (ssize_t) border_image->rows; y++)
   {
     PixelInfo
@@ -4455,7 +4455,7 @@ MagickExport Image *SketchImage(const Image *image,const double radius,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
 #endif
-  random_view=AcquireAuthenticCacheView(random_image);
+  random_view=AcquireAuthenticCacheView(random_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,key == ~0UL)
@@ -4629,7 +4629,7 @@ MagickExport MagickBooleanType SolarizeImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -4796,8 +4796,8 @@ MagickExport Image *SteganoImage(const Image *image,const Image *watermark,
   depth=stegano_image->depth;
   k=stegano_image->offset;
   status=MagickTrue;
-  watermark_view=AcquireVirtualCacheView(watermark);
-  stegano_view=AcquireAuthenticCacheView(stegano_image);
+  watermark_view=AcquireVirtualCacheView(watermark,exception);
+  stegano_view=AcquireAuthenticCacheView(stegano_image,exception);
   for (i=(ssize_t) depth-1; (i >= 0) && (j < (ssize_t) depth); i--)
   {
     for (y=0; (y < (ssize_t) watermark->rows) && (j < (ssize_t) depth); y++)
@@ -5108,8 +5108,8 @@ MagickExport Image *SwirlImage(const Image *image,double degrees,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  swirl_view=AcquireAuthenticCacheView(swirl_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  swirl_view=AcquireAuthenticCacheView(swirl_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -5345,8 +5345,8 @@ MagickExport Image *TintImage(const Image *image,const char *blend,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  tint_view=AcquireAuthenticCacheView(tint_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  tint_view=AcquireAuthenticCacheView(tint_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -5644,8 +5644,8 @@ MagickExport Image *WaveImage(const Image *image,const double amplitude,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  wave_view=AcquireAuthenticCacheView(wave_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  wave_view=AcquireAuthenticCacheView(wave_image,exception);
   (void) SetCacheViewVirtualPixelMethod(image_view,
     BackgroundVirtualPixelMethod);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickCore/histogram.c b/MagickCore/histogram.c
index 7a1417c109e9f0d8d77a2122f6e8cc76e8f7a380..f244bcccd6458fba84ebe7ba2ad07c3a5d75718a 100644 (file)
--- a/MagickCore/histogram.c
+++ b/MagickCore/histogram.c
@@ -224,7 +224,7 @@ static CubeInfo *ClassifyImageColors(const Image *image,
     }
   GetPixelInfo(image,&pixel);
   GetPixelInfo(image,&target);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -686,7 +686,7 @@ MagickExport MagickBooleanType IsHistogramImage(const Image *image,
     }
   GetPixelInfo(image,&pixel);
   GetPixelInfo(image,&target);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -846,7 +846,7 @@ MagickExport MagickBooleanType IsPaletteImage(const Image *image,
     }
   GetPixelInfo(image,&pixel);
   GetPixelInfo(image,&target);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
@@ -1292,7 +1292,7 @@ MagickExport Image *UniqueImageColors(const Image *image,
       unique_image=DestroyImage(unique_image);
       return((Image *) NULL);
     }
-  unique_view=AcquireAuthenticCacheView(unique_image);
+  unique_view=AcquireAuthenticCacheView(unique_image,exception);
   UniqueColorsToImage(unique_image,unique_view,cube_info,cube_info->root,
     exception);
   unique_view=DestroyCacheView(unique_view);

diff --git a/MagickCore/image-view.c b/MagickCore/image-view.c
index 8a58cb3a5e40269ba7f56e0377451bff72824068..29353fc1ca9ad9a7efdf64a9d7cb8816f47df7e9 100644 (file)
--- a/MagickCore/image-view.c
+++ b/MagickCore/image-view.c
@@ -730,7 +730,7 @@ MagickExport ImageView *NewImageView(Image *image,ExceptionInfo *exception)
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
   image_view->description=ConstantString("ImageView");
   image_view->image=image;
-  image_view->view=AcquireVirtualCacheView(image_view->image);
+  image_view->view=AcquireVirtualCacheView(image_view->image,exception);
   image_view->extent.width=image->columns;
   image_view->extent.height=image->rows;
   image_view->extent.x=0;
@@ -785,7 +785,7 @@ MagickExport ImageView *NewImageViewRegion(Image *image,const ssize_t x,
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
   image_view->description=ConstantString("ImageView");
-  image_view->view=AcquireVirtualCacheView(image_view->image);
+  image_view->view=AcquireVirtualCacheView(image_view->image,exception);
   image_view->image=image;
   image_view->extent.width=width;
   image_view->extent.height=height;

diff --git a/MagickCore/image.c b/MagickCore/image.c
index 8f9135d7db90cbe42cb1c6ba2635cd2d6e6898ca..d829b9cefbedd6f597fee9f824e7e62ff1b6091f 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -519,7 +519,7 @@ MagickExport Image *AppendImages(const Image *images,
   x_offset=0;
   y_offset=0;
   next=images;
-  append_view=AcquireAuthenticCacheView(append_image);
+  append_view=AcquireAuthenticCacheView(append_image,exception);
   for (n=0; n < (MagickOffsetType) number_images; n++)
   {
     CacheView
@@ -538,7 +538,7 @@ MagickExport Image *AppendImages(const Image *images,
       x_offset-=geometry.x;
     else
       y_offset-=geometry.y;
-    image_view=AcquireVirtualCacheView(image);
+    image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(status) \
       dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1310,8 +1310,8 @@ MagickExport Image *GetImageMask(const Image *image,ExceptionInfo *exception)
   status=MagickTrue;
   (void) SetImageColorspace(mask_image,GRAYColorspace,exception);
   mask_image->mask=MagickFalse;
-  image_view=AcquireVirtualCacheView(image);
-  mask_view=AcquireAuthenticCacheView(mask_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  mask_view=AcquireAuthenticCacheView(mask_image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1650,7 +1650,7 @@ MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1905,7 +1905,7 @@ MagickExport Image *NewMagickImage(const ImageInfo *image_info,
   image->fuzz=background->fuzz;
   image->depth=background->depth;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2177,7 +2177,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
         break;
       if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
         break;
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2256,7 +2256,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
         break;
       if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
         break;
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2366,7 +2366,7 @@ MagickExport MagickBooleanType SetImageBackgroundColor(Image *image,
     Set image background color.
   */
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register Quantum
@@ -2482,7 +2482,7 @@ MagickExport MagickBooleanType SetImageColor(Image *image,
   image->fuzz=color->fuzz;
   image->depth=color->depth;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3056,8 +3056,8 @@ MagickExport MagickBooleanType SetImageMask(Image *image,const Image *mask,
     }
   status=MagickTrue;
   image->mask=MagickTrue;
-  mask_view=AcquireVirtualCacheView(mask);
-  image_view=AcquireAuthenticCacheView(image);
+  mask_view=AcquireVirtualCacheView(mask,exception);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -3136,7 +3136,7 @@ MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
   assert(image->signature == MagickSignature);
   image->alpha_trait=BlendPixelTrait;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3282,8 +3282,8 @@ static ssize_t SmushXGap(const Image *smush_image,const Image *images,
   GravityAdjustGeometry(left_image->columns,left_image->rows,
     left_image->gravity,&left_geometry);
   gap=right_image->columns;
-  left_view=AcquireVirtualCacheView(left_image);
-  right_view=AcquireVirtualCacheView(right_image);
+  left_view=AcquireVirtualCacheView(left_image,exception);
+  right_view=AcquireVirtualCacheView(right_image,exception);
   for (y=0; y < (ssize_t) smush_image->rows; y++)
   {
     for (x=(ssize_t) left_image->columns-1; x > 0; x--)
@@ -3353,8 +3353,8 @@ static ssize_t SmushYGap(const Image *smush_image,const Image *images,
   GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
     &top_geometry);
   gap=bottom_image->rows;
-  top_view=AcquireVirtualCacheView(top_image);
-  bottom_view=AcquireVirtualCacheView(bottom_image);
+  top_view=AcquireVirtualCacheView(top_image,exception);
+  bottom_view=AcquireVirtualCacheView(bottom_image,exception);
   for (x=0; x < (ssize_t) smush_image->columns; x++)
   {
     for (y=(ssize_t) top_image->rows-1; y > 0; y--)
@@ -3608,7 +3608,7 @@ MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
     return(MagickFalse);
   range_exception=MagickFalse;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(range_exception,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index b92e3af073d1d99f1cac0565c10bc9f48bbd5a61..32e39ae5d3a03073e64fa50ec5eef22f69b24970 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -2606,8 +2606,8 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
   changed=0;
   progress=0;
 
-  image_view=AcquireVirtualCacheView(image);
-  morphology_view=AcquireAuthenticCacheView(morphology_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  morphology_view=AcquireAuthenticCacheView(morphology_image,exception);
   virt_width=image->columns+kernel->width-1;
 
   /* Some methods (including convolve) needs use a reflected kernel.
@@ -3440,8 +3440,8 @@ static ssize_t MorphologyPrimitiveDirect(Image *image,
 
   /* DO NOT THREAD THIS CODE! */
   /* two views into same image (virtual, and actual) */
-  virt_view=AcquireVirtualCacheView(image);
-  auth_view=AcquireAuthenticCacheView(image);
+  virt_view=AcquireVirtualCacheView(image,exception);
+  auth_view=AcquireAuthenticCacheView(image,exception);
   virt_width=image->columns+kernel->width-1;
 
   for (y=0; y < (ssize_t) image->rows; y++)

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index 3e2476d3e3bdabf8c1cf6f1989545785659bc749..22697b89babe08c6297c69c62d142a9a18d66bfb 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -207,8 +207,8 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
   PushSegmentStack(y,x,x,1);
   PushSegmentStack(y+1,x,x,-1);
   GetPixelInfo(image,&pixel);
-  image_view=AcquireVirtualCacheView(image);
-  floodplane_view=AcquireAuthenticCacheView(floodplane_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
   while (s > segment_stack)
   {
     register const Quantum
@@ -587,8 +587,8 @@ MagickExport Image *OilPaintImage(const Image *image,const double radius,
   progress=0;
   center=(ssize_t) GetPixelChannels(image)*(image->columns+width)*(width/2L)+
     GetPixelChannels(image)*(width/2L);
-  image_view=AcquireVirtualCacheView(image);
-  paint_view=AcquireAuthenticCacheView(paint_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  paint_view=AcquireAuthenticCacheView(paint_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -784,7 +784,7 @@ MagickExport MagickBooleanType OpaquePaintImage(Image *image,
   status=MagickTrue;
   progress=0;
   GetPixelInfo(image,&zero);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -911,7 +911,7 @@ MagickExport MagickBooleanType TransparentPaintImage(Image *image,
   status=MagickTrue;
   progress=0;
   GetPixelInfo(image,&zero);
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1038,7 +1038,7 @@ MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index caef3d14bcd79050b26b6357ef04576e29f54cfd..8a7624e0e0386f1a76676d1c2491ac07d23eaf2e 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -4308,7 +4308,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
       excerpt_image=DestroyImage(excerpt_image);
       if (filter_image == (Image *) NULL)
         break;
-      filter_view=AcquireVirtualCacheView(filter_image);
+      filter_view=AcquireVirtualCacheView(filter_image,exception);
       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
       if (p == (const Quantum *) NULL)
         status=MagickFalse;
@@ -4847,7 +4847,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
         excerpt_source=DestroyImage(excerpt_source);
         if (filter_source == (Image *) NULL)
           continue;
-        filter_view=AcquireVirtualCacheView(filter_source);
+        filter_view=AcquireVirtualCacheView(filter_source,exception);
         p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
         if (p == (const Quantum *) NULL)
           status=MagickFalse;
@@ -5404,7 +5404,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
       excerpt_image=DestroyImage(excerpt_image);
       if (filter_image == (Image *) NULL)
         break;
-      filter_view=AcquireVirtualCacheView(filter_image);
+      filter_view=AcquireVirtualCacheView(filter_image,exception);
       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
       if (p != (const Quantum *) NULL)
         GetPixelInfoPixel(image,p,pixel);

diff --git a/MagickCore/prepress.c b/MagickCore/prepress.c
index a4a73a6f740150923481a88ec071cf61833b732e..db031cf596b52669a2c40b810cdeb7b463b7dc2f 100644 (file)
--- a/MagickCore/prepress.c
+++ b/MagickCore/prepress.c
@@ -110,7 +110,7 @@ MagickExport double GetImageTotalInkDensity(Image *image,
     }
   status=MagickTrue;
   total_ink_density=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/profile.c b/MagickCore/profile.c
index 87ec0c6b673a64f6769f8623e733e5fb04a65b8e..fbd7301c5222044acc1d7bbb785895100689c1c4 100644 (file)
--- a/MagickCore/profile.c
+++ b/MagickCore/profile.c
@@ -857,7 +857,7 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
               (void) SetImageColorspace(image,target_colorspace,exception);
             status=MagickTrue;
             progress=0;
-            image_view=AcquireAuthenticCacheView(image);
+            image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
             #pragma omp parallel for schedule(static,4) shared(status) \
               dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 1c35b0b922df2171c73b725dbdd1658c80e32aea..6503d46bdb6adc512dfc6c509d5556c13b5eca19 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -540,7 +540,7 @@ static MagickBooleanType AssignImageColors(Image *image,CubeInfo *cube_info,
         status;
 
       status=MagickTrue;
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -809,7 +809,7 @@ static MagickBooleanType ClassifyImageColors(CubeInfo *cube_info,
   midpoint.blue=(double) QuantumRange/2.0;
   midpoint.alpha=(double) QuantumRange/2.0;
   error.alpha=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1496,7 +1496,7 @@ static MagickBooleanType FloydSteinbergDither(Image *image,CubeInfo *cube_info,
   if (pixels == (RealPixelInfo **) NULL)
     return(MagickFalse);
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     const int
@@ -1959,7 +1959,7 @@ static MagickBooleanType DitherImage(Image *image,CubeInfo *cube_info,
     depth++;
   cube_info->offset=0;
   cube_info->span=(MagickSizeType) image->columns*image->rows;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   if (depth > 1)
     Riemersma(image,image_view,cube_info,depth-1,NorthGravity,exception);
   status=RiemersmaDither(image,image_view,cube_info,ForgetGravity,exception);
@@ -2219,7 +2219,7 @@ MagickExport MagickBooleanType GetImageQuantizeError(Image *image,
   maximum_error=0.0;
   mean_error_per_pixel=0.0;
   mean_error=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -2402,7 +2402,7 @@ MagickExport MagickBooleanType PosterizeImage(Image *image,const size_t levels,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2678,7 +2678,7 @@ static MagickBooleanType DirectToColormapImage(Image *image,
   if (image->colors != number_colors)
     return(MagickFalse);
   i=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     MagickBooleanType
@@ -3301,7 +3301,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
           image->filename);
       image->colors=0;
       status=MagickTrue;
-      image_view=AcquireAuthenticCacheView(image);
+      image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
       #pragma omp parallel for schedule(static,4) shared(status) \
         dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3378,7 +3378,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
   image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
   image->colormap=colormap;
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/resample.c b/MagickCore/resample.c
index 35c16cdc0d5bc886b7168af3951e419e0961fc3c..4366f883442194c803a8d3640ce5cc74d012ea5d 100644 (file)
--- a/MagickCore/resample.c
+++ b/MagickCore/resample.c
@@ -225,7 +225,7 @@ MagickExport ResampleFilter *AcquireResampleFilter(const Image *image,
 
   resample_filter->exception=exception;
   resample_filter->image=ReferenceImage((Image *) image);
-  resample_filter->view=AcquireVirtualCacheView(resample_filter->image);
+  resample_filter->view=AcquireVirtualCacheView(resample_filter->image,exception);
 
   resample_filter->debug=IsEventLogging();
   resample_filter->signature=MagickSignature;
@@ -488,7 +488,7 @@ MagickExport MagickBooleanType ResamplePixelColor(
               *pixel=resample_filter->average_pixel; /* FAILED */
               break;
             }
-          average_view=AcquireVirtualCacheView(average_image);
+          average_view=AcquireVirtualCacheView(average_image,exception);
           pixels=GetCacheViewVirtualPixels(average_view,0,0,1,1,
             resample_filter->exception);
           if (pixels == (const Quantum *) NULL) {

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 2f9fb859319321876a6150bceb9c0c41a0ade79b..224407168c865ecf67ea9d3deb5c1cc4ad5fdded 100644 (file)
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -1621,8 +1621,8 @@ MagickExport Image *InterpolativeResizeImage(const Image *image,
     }
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  resize_view=AcquireAuthenticCacheView(resize_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  resize_view=AcquireAuthenticCacheView(resize_image,exception);
   scale.x=(double) image->columns/resize_image->columns;
   scale.y=(double) image->rows/resize_image->rows;
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -1815,7 +1815,7 @@ MagickExport Image *LiquidRescaleImage(const Image *image,const size_t columns,
     return((Image *) NULL);
   status=MagickTrue;
   q=pixels;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1866,7 +1866,7 @@ MagickExport Image *LiquidRescaleImage(const Image *image,const size_t columns,
       rescale_image=DestroyImage(rescale_image);
       return((Image *) NULL);
     }
-  rescale_view=AcquireAuthenticCacheView(rescale_image);
+  rescale_view=AcquireAuthenticCacheView(rescale_image,exception);
   (void) lqr_carver_scan_reset(carver);
   while (lqr_carver_scan_ext(carver,&x_offset,&y_offset,(void **) &packet) != 0)
   {
@@ -2232,8 +2232,8 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
     }
   status=MagickTrue;
   scale=PerceptibleReciprocal(scale);
-  image_view=AcquireVirtualCacheView(image);
-  resize_view=AcquireAuthenticCacheView(resize_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  resize_view=AcquireAuthenticCacheView(resize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2446,8 +2446,8 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
   status=MagickTrue;
   scale=PerceptibleReciprocal(scale);
   (void) ResetMagickMemory(&zero,0,sizeof(zero));
-  image_view=AcquireVirtualCacheView(image);
-  resize_view=AcquireAuthenticCacheView(resize_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  resize_view=AcquireAuthenticCacheView(resize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2797,8 +2797,8 @@ MagickExport Image *SampleImage(const Image *image,const size_t columns,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  sample_view=AcquireAuthenticCacheView(sample_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  sample_view=AcquireAuthenticCacheView(sample_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -3013,8 +3013,8 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
   for (i=0; i < (ssize_t) (GetPixelChannels(image)*image->columns); i++)
     y_vector[i]=0.0;
   n=0;
-  image_view=AcquireVirtualCacheView(image);
-  scale_view=AcquireAuthenticCacheView(scale_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  scale_view=AcquireAuthenticCacheView(scale_image,exception);
   for (y=0; y < (ssize_t) scale_image->rows; y++)
   {
     register const Quantum

diff --git a/MagickCore/segment.c b/MagickCore/segment.c
index 6ecc1902aac896506c624cee8998cd741fb7fae5..2a35850c35c9add9f52ec10f70d507d5534fc6b0 100644 (file)
--- a/MagickCore/segment.c
+++ b/MagickCore/segment.c
@@ -355,7 +355,7 @@ static MagickBooleanType Classify(Image *image,short **extrema,
   status=MagickTrue;
   count=0;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -531,7 +531,7 @@ static MagickBooleanType Classify(Image *image,short **extrema,
   /*
     Do course grain classes.
   */
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/shear.c b/MagickCore/shear.c
index c2ddd7a1bc8c09b6592984f165b6c138951e7b9a..2694b24355255ce53e7d8859f2bc350b8096157e 100644 (file)
--- a/MagickCore/shear.c
+++ b/MagickCore/shear.c
@@ -651,7 +651,7 @@ static MagickBooleanType RadonTransform(const Image *image,
     bits[i]=(unsigned short) count;
   }
   status=MagickTrue;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -779,7 +779,7 @@ static void GetImageBackgroundColor(Image *image,const ssize_t offset,
     return;
   GetPixelInfo(image,&background);
   count=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register const Quantum
@@ -1001,8 +1001,8 @@ MagickExport Image *IntegralRotateImage(const Image *image,size_t rotations,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  rotate_view=AcquireAuthenticCacheView(rotate_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  rotate_view=AcquireAuthenticCacheView(rotate_image,exception);
   switch (rotations)
   {
     case 0:
@@ -1444,7 +1444,7 @@ static MagickBooleanType XShearImage(Image *image,const double degrees,
   status=MagickTrue;
   background=image->background_color;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,width,height,1)
@@ -1660,7 +1660,7 @@ static MagickBooleanType YShearImage(Image *image,const double degrees,
   status=MagickTrue;
   progress=0;
   background=image->background_color;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,width,height,1)

diff --git a/MagickCore/signature.c b/MagickCore/signature.c
index 184c2c4f11c72fddedbcb07d3ff0bac13ff32db5..4a93685d57d856c1611a5d1e69bc1f90e262c602 100644 (file)
--- a/MagickCore/signature.c
+++ b/MagickCore/signature.c
@@ -506,7 +506,7 @@ MagickExport MagickBooleanType SignatureImage(Image *image,
   signature=AcquireStringInfo(image->columns*GetPixelChannels(image)*
     sizeof(pixel));
   pixels=GetStringInfoDatum(signature);
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register ssize_t

diff --git a/MagickCore/statistic.c b/MagickCore/statistic.c
index 93410a10afdc835afa088cdcd39cc8764e6434b0..601dbd2dd49f41fe988f0c59539a68fa7045a90d 100644 (file)
--- a/MagickCore/statistic.c
+++ b/MagickCore/statistic.c
@@ -487,7 +487,7 @@ MagickExport Image *EvaluateImages(const Image *images,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
 #endif
-  evaluate_view=AcquireAuthenticCacheView(image);
+  evaluate_view=AcquireAuthenticCacheView(image,exception);
   if (op == MedianEvaluateOperator)
     {
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -542,7 +542,7 @@ MagickExport Image *EvaluateImages(const Image *images,
             register ssize_t
               i;
 
-            image_view=AcquireVirtualCacheView(next);
+            image_view=AcquireVirtualCacheView(next,exception);
             p=GetCacheViewVirtualPixels(image_view,x,y,1,1,exception);
             if (p == (const Quantum *) NULL)
               {
@@ -645,7 +645,7 @@ MagickExport Image *EvaluateImages(const Image *images,
           register const Quantum
             *p;
 
-          image_view=AcquireVirtualCacheView(next);
+          image_view=AcquireVirtualCacheView(next,exception);
           p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
           if (p == (const Quantum *) NULL)
             {
@@ -807,7 +807,7 @@ MagickExport MagickBooleanType EvaluateImage(Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
 #endif
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,key == ~0UL)
@@ -1036,7 +1036,7 @@ MagickExport MagickBooleanType FunctionImage(Image *image,
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1300,7 +1300,7 @@ MagickExport MagickBooleanType GetImageKurtosis(const Image *image,
   sum_squares=0.0;
   sum_cubes=0.0;
   sum_fourth_power=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1427,7 +1427,7 @@ MagickExport MagickBooleanType GetImageRange(const Image *image,double *minima,
   initialize=MagickTrue;
   *maxima=0.0;
   *minima=0.0;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status,initialize) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1820,7 +1820,7 @@ MagickExport Image *PolynomialImage(const Image *images,
   */
   status=MagickTrue;
   progress=0;
-  polynomial_view=AcquireAuthenticCacheView(image);
+  polynomial_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1870,7 +1870,7 @@ MagickExport Image *PolynomialImage(const Image *images,
 
       if (j >= (ssize_t) number_terms)
         continue;
-      image_view=AcquireVirtualCacheView(next);
+      image_view=AcquireVirtualCacheView(next,exception);
       p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
       if (p == (const Quantum *) NULL)
         {
@@ -2497,8 +2497,8 @@ MagickExport Image *StatisticImage(const Image *image,const StatisticType type,
     (MagickMax(height,1)/2L)+GetPixelChannels(image)*(MagickMax(width,1)/2L);
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  statistic_view=AcquireAuthenticCacheView(statistic_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  statistic_view=AcquireAuthenticCacheView(statistic_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index b21b1259382c5968d1c3bfa6ab864b4f745d55a0..cec9f3567dea3ad140296558fad3c43cc7ba6641 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -202,8 +202,8 @@ MagickExport Image *AdaptiveThresholdImage(const Image *image,
   status=MagickTrue;
   progress=0;
   number_pixels=(MagickSizeType) width*height;
-  image_view=AcquireVirtualCacheView(image);
-  threshold_view=AcquireAuthenticCacheView(threshold_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  threshold_view=AcquireAuthenticCacheView(threshold_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -408,7 +408,7 @@ MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -579,7 +579,7 @@ MagickExport MagickBooleanType BlackThresholdImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -737,7 +737,7 @@ MagickExport MagickBooleanType ClampImage(Image *image,ExceptionInfo *exception)
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1360,7 +1360,7 @@ MagickExport MagickBooleanType OrderedPosterizeImage(Image *image,
     return(MagickFalse);
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1534,7 +1534,7 @@ MagickExport MagickBooleanType PerceptibleImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1701,7 +1701,7 @@ MagickExport MagickBooleanType RandomThresholdImage(Image *image,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   key=GetRandomSecretKey(random_info[0]);
 #endif
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,key == ~0UL)
@@ -1881,7 +1881,7 @@ MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/transform.c b/MagickCore/transform.c
index 2539892c99b0aae353ba7c201f46f5721dd92b41..b5a04894c06ef9f24ab89982a984cad7a2341f89 100644 (file)
--- a/MagickCore/transform.c
+++ b/MagickCore/transform.c
@@ -157,8 +157,8 @@ MagickExport Image *ChopImage(const Image *image,const RectangleInfo *chop_info,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  chop_view=AcquireAuthenticCacheView(chop_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  chop_view=AcquireAuthenticCacheView(chop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -373,8 +373,8 @@ MagickExport Image *ConsolidateCMYKImages(const Image *images,
     (void) SetImageColorspace(cmyk_image,CMYKColorspace,exception);
     for (i=0; i < 4; i++)
     {
-      image_view=AcquireVirtualCacheView(images);
-      cmyk_view=AcquireAuthenticCacheView(cmyk_image);
+      image_view=AcquireVirtualCacheView(images,exception);
+      cmyk_view=AcquireAuthenticCacheView(cmyk_image,exception);
       for (y=0; y < (ssize_t) images->rows; y++)
       {
         register const Quantum
@@ -586,8 +586,8 @@ MagickExport Image *CropImage(const Image *image,const RectangleInfo *geometry,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  crop_view=AcquireAuthenticCacheView(crop_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  crop_view=AcquireAuthenticCacheView(crop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -948,8 +948,8 @@ MagickExport Image *ExcerptImage(const Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  excerpt_view=AcquireAuthenticCacheView(excerpt_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1156,8 +1156,8 @@ MagickExport Image *FlipImage(const Image *image,ExceptionInfo *exception)
   status=MagickTrue;
   progress=0;
   page=image->page;
-  image_view=AcquireVirtualCacheView(image);
-  flip_view=AcquireAuthenticCacheView(flip_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  flip_view=AcquireAuthenticCacheView(flip_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1303,8 +1303,8 @@ MagickExport Image *FlopImage(const Image *image,ExceptionInfo *exception)
   status=MagickTrue;
   progress=0;
   page=image->page;
-  image_view=AcquireVirtualCacheView(image);
-  flop_view=AcquireAuthenticCacheView(flop_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  flop_view=AcquireAuthenticCacheView(flop_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(NoBenefitFromParallelism)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -1433,8 +1433,8 @@ static inline MagickBooleanType CopyImageRegion(Image *destination,
     y;
 
   status=MagickTrue;
-  source_view=AcquireVirtualCacheView(source);
-  destination_view=AcquireAuthenticCacheView(destination);
+  source_view=AcquireVirtualCacheView(source,exception);
+  destination_view=AcquireAuthenticCacheView(destination,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(status) \
     dynamic_number_threads(source,columns,rows,1)
@@ -1762,8 +1762,8 @@ MagickExport Image *SpliceImage(const Image *image,
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  splice_view=AcquireAuthenticCacheView(splice_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  splice_view=AcquireAuthenticCacheView(splice_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2219,8 +2219,8 @@ MagickExport Image *TransposeImage(const Image *image,ExceptionInfo *exception)
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  transpose_view=AcquireAuthenticCacheView(transpose_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)
@@ -2369,8 +2369,8 @@ MagickExport Image *TransverseImage(const Image *image,ExceptionInfo *exception)
   */
   status=MagickTrue;
   progress=0;
-  image_view=AcquireVirtualCacheView(image);
-  transverse_view=AcquireAuthenticCacheView(transverse_image);
+  image_view=AcquireVirtualCacheView(image,exception);
+  transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,4) shared(progress,status) \
     dynamic_number_threads(image,image->columns,image->rows,1)

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index 2eeb76a3a7db93f4b4f02f8250b40d2184cb526e..8b0ba5210c5687d48e33b3615ff7766047c8b315 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -2227,7 +2227,7 @@ static void XDitherImage(Image *image,XImage *ximage,ExceptionInfo *exception)
   i=0;
   j=0;
   q=ximage->data;
-  image_view=AcquireVirtualCacheView(image);
+  image_view=AcquireVirtualCacheView(image,exception);
   for (y=0; y < (int) image->rows; y++)
   {
     p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) y,image->columns,1,
@@ -4366,7 +4366,7 @@ static Image *XGetWindowImage(Display *display,const Window window,
           composite_image->storage_class=PseudoClass;
         composite_image->columns=(size_t) ximage->width;
         composite_image->rows=(size_t) ximage->height;
-        composite_view=AcquireAuthenticCacheView(composite_image);
+        composite_view=AcquireAuthenticCacheView(composite_image,exception);
         switch (composite_image->storage_class)
         {
           case DirectClass:
@@ -5954,7 +5954,7 @@ static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
   pixels=window->pixel_info->pixels;
   q=(unsigned char *) ximage->data;
   x=0;
-  canvas_view=AcquireVirtualCacheView(canvas);
+  canvas_view=AcquireVirtualCacheView(canvas,exception);
   if (ximage->format == XYBitmap)
     {
       register unsigned short
@@ -6580,7 +6580,7 @@ static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
   pixels=window->pixel_info->pixels;
   q=(unsigned char *) ximage->data;
   x=0;
-  canvas_view=AcquireVirtualCacheView(canvas);
+  canvas_view=AcquireVirtualCacheView(canvas,exception);
   if (ximage->format == XYBitmap)
     {
       register unsigned short
@@ -8001,7 +8001,7 @@ MagickPrivate void XMakeStandardColormap(Display *display,
             diversity[i].index=(unsigned short) i;
             diversity[i].count=0;
           }
-          image_view=AcquireAuthenticCacheView(image);
+          image_view=AcquireAuthenticCacheView(image,exception);
           for (y=0; y < (int) image->rows; y++)
           {
             register int

diff --git a/MagickWand/magick-image.c b/MagickWand/magick-image.c
index 23d6d661bdd874ee748808b13db971632c1be3f6..de5f5af7a53f64ef4ecc0576450396e2b6e5ad41 100644 (file)
--- a/MagickWand/magick-image.c
+++ b/MagickWand/magick-image.c
@@ -5205,7 +5205,7 @@ WandExport MagickBooleanType MagickGetImagePixelColor(MagickWand *wand,
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
   if (wand->images == (Image *) NULL)
     ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  image_view=AcquireVirtualCacheView(wand->images);
+  image_view=AcquireVirtualCacheView(wand->images,wand->exception);
   p=GetCacheViewVirtualPixels(image_view,x,y,1,1,wand->exception);
   if (p == (const Quantum *) NULL)
     {

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index 03ef76a6e15698a976b91ba8bbab1c4bb397e5fd..74dfed2d86c44a54e3b1a7be2075e7db352ced25 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -1112,7 +1112,7 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
               break;
             if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse)
               return(MagickFalse);
-            mask_view=AcquireAuthenticCacheView(mask_image);
+            mask_view=AcquireAuthenticCacheView(mask_image,exception);
             for (y=0; y < (ssize_t) mask_image->rows; y++)
             {
               q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index a087790b6b0660c7c1cafb0f164f41d2a43a9029..9d75c3b784777d47f1c0cf54bd2a88caf219d74b 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -2004,7 +2004,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
             break;
           /* Create a write mask from cli_wand mask image */
           /* FUTURE: use Alpha operations instead and create a Grey Image */
-          mask_view=AcquireAuthenticCacheView(mask_image);
+          mask_view=AcquireAuthenticCacheView(mask_image,_exception);
           for (y=0; y < (ssize_t) mask_image->rows; y++)
           {
             q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,

diff --git a/MagickWand/pixel-iterator.c b/MagickWand/pixel-iterator.c
index 14732cc605ab8c7b2eb25729c1bf59f7391df89f..e15128ddd6e8d2650c1b4b5014530264741e1bcf 100644 (file)
--- a/MagickWand/pixel-iterator.c
+++ b/MagickWand/pixel-iterator.c
@@ -314,7 +314,7 @@ WandExport PixelIterator *NewPixelIterator(MagickWand *wand)
   if (image == (Image *) NULL)
     return((PixelIterator *) NULL);
   exception=AcquireExceptionInfo();
-  view=AcquireVirtualCacheView(image);
+  view=AcquireVirtualCacheView(image,exception);
   if (view == (CacheView *) NULL)
     return((PixelIterator *) NULL);
   iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));
@@ -433,7 +433,7 @@ WandExport PixelIterator *NewPixelRegionIterator(MagickWand *wand,
   if (image == (Image *) NULL)
     return((PixelIterator *) NULL);
   exception=AcquireExceptionInfo();
-  view=AcquireVirtualCacheView(image);
+  view=AcquireVirtualCacheView(image,exception);
   if (view == (CacheView *) NULL)
     return((PixelIterator *) NULL);
   iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));

diff --git a/MagickWand/wand-view.c b/MagickWand/wand-view.c
index 96a8a5a5a1a6275f6b85e9280fda6cc6a315a1e4..f854d6ab6283f578f389dc37a19431d067c2a7c2 100644 (file)
--- a/MagickWand/wand-view.c
+++ b/MagickWand/wand-view.c
@@ -765,7 +765,7 @@ WandExport WandView *NewWandView(MagickWand *wand)
   wand_view->description=ConstantString("WandView");
   wand_view->wand=wand;
   exception=AcquireExceptionInfo();
-  wand_view->view=AcquireVirtualCacheView(wand_view->wand->images);
+  wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
   wand_view->extent.width=wand->images->columns;
   wand_view->extent.height=wand->images->rows;
   wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width);
@@ -826,7 +826,7 @@ WandExport WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
     WandViewId,(double) wand_view->id);
   wand_view->description=ConstantString("WandView");
   exception=AcquireExceptionInfo();
-  wand_view->view=AcquireVirtualCacheView(wand_view->wand->images);
+  wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
   wand_view->wand=wand;
   wand_view->extent.width=width;
   wand_view->extent.height=height;

diff --git a/coders/msl.c b/coders/msl.c
index 09a7eb79b291a9941aa95077e6fd8154abc65f2c..289f287c3000cbeca72629f708a19b40f8ce44d7 100644 (file)
--- a/coders/msl.c
+++ b/coders/msl.c
@@ -1955,7 +1955,7 @@ static void MSLStartElement(void *context,const xmlChar *tag,
                       if (composite_image->alpha_trait == UndefinedPixelTrait)
                         (void) SetImageAlpha(composite_image,OpaqueAlpha,
                           &exception);
-                      composite_view=AcquireAuthenticCacheView(composite_image);
+                      composite_view=AcquireAuthenticCacheView(composite_image,exception);
                       for (y=0; y < (ssize_t) composite_image->rows ; y++)
                       {
                         q=GetCacheViewAuthenticPixels(composite_view,0,y,

diff --git a/coders/tiff.c b/coders/tiff.c
index 388c3c22842fd1411eba613b553011ed801faf4e..0b57bc3819b0a7fbeeacbbd5e936834c1d799e90 100644 (file)
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -439,7 +439,7 @@ static MagickBooleanType DecodeLabImage(Image *image,ExceptionInfo *exception)
     y;
 
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register Quantum
@@ -2302,7 +2302,7 @@ static MagickBooleanType EncodeLabImage(Image *image,ExceptionInfo *exception)
     y;
 
   status=MagickTrue;
-  image_view=AcquireAuthenticCacheView(image);
+  image_view=AcquireAuthenticCacheView(image,exception);
   for (y=0; y < (ssize_t) image->rows; y++)
   {
     register Quantum

diff --git a/filters/analyze.c b/filters/analyze.c
index e32fa85021fbd17750b30563c809f35c43ab0d41..de5f0da9b155aac239e404a651e1963d2b4260c6 100644 (file)
--- a/filters/analyze.c
+++ b/filters/analyze.c
@@ -143,7 +143,7 @@ ModuleExport size_t analyzeImage(Image **images,const int argc,
     saturation_skewness=0.0;
     area=0.0;
     status=MagickTrue;
-    image_view=AcquireVirtualCacheView(image);
+    image_view=AcquireVirtualCacheView(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
     #pragma omp parallel for schedule(static,4) shared(status) \
       dynamic_number_threads(image,image->columns,image->rows,1)