//
// ImageMagick symbols used in implementation code
//
- using MagickCore::AcquireCacheView;
+ using MagickCore::AcquireAuthenticCacheView;
using MagickCore::AcquireExceptionInfo;
+ using MagickCore::AcquireVirtualCacheView;
using MagickCore::GetCacheViewVirtualPixels;
using MagickCore::AcquireImage;
using MagickCore::GetVirtualPixels;
// Construct pixel view using specified image.
Magick::Pixels::Pixels( Magick::Image &image_ )
: _image(image_),
- _view(AcquireCacheView(_image.image())),
+ _view(AcquireVirtualCacheView(_image.image(),&_exception)),
_x(0),
_y(0),
_columns(0),
Rasterize the glyph.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
p=bitmap->bitmap.buffer;
for (y=0; y < (ssize_t) bitmap->bitmap.rows; y++)
{
(void) SetImageAlphaChannel(annotate_image,OpaqueAlphaChannel,
exception);
fill_color=draw_info->fill;
- annotate_view=AcquireCacheView(annotate_image);
+ annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
for (y=0; y < (ssize_t) annotate_image->rows; y++)
{
register ssize_t
bounds.x=(ssize_t) image->columns;
bounds.y=(ssize_t) image->rows;
GetPixelInfo(image,&target[0]);
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
p=GetCacheViewVirtualPixels(image_view,0,0,1,1,exception);
if (p == (const Quantum *) NULL)
{
current_depth=(size_t *) RelinquishMagickMemory(current_depth);
return(depth);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
if (QuantumRange <= MaxMap)
{
if (IssRGBColorspace(image->colorspace) == MagickFalse)
return(MagickFalse);
type=BilevelType;
- image_view=AcquireCacheView(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);
if (IssRGBColorspace(image->colorspace) == MagickFalse)
return(MagickFalse);
type=BilevelType;
- image_view=AcquireCacheView(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);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (image->matte == MagickFalse)
return(MagickTrue);
- image_view=AcquireCacheView(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);
return(status);
}
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if !defined(MAGICKCORE_HDRI_SUPPORT)
if (QuantumRange <= MaxMap)
{
% %
% %
% %
-% A c q u i r e C a c h e V i e w %
+% A c q u i r e A u t h e n t i c C a c h e V i e w %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% AcquireCacheView() acquires a view into the pixel cache, using the
-% VirtualPixelMethod that is defined within the given image itself.
+% AcquireAuthenticCacheView() acquires an authentic view into the pixel cache.
%
-% The format of the AcquireCacheView method is:
+% The format of the AcquireAuthenticCacheView method is:
%
-% CacheView *AcquireCacheView(const Image *image)
+% CacheView *AcquireAuthenticCacheView(const Image *image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport CacheView *AcquireCacheView(const Image *image)
+MagickExport CacheView *AcquireAuthenticCacheView(const Image *image,
+ ExceptionInfo *exception)
+{
+ CacheView
+ *cache_view;
+
+ MagickBooleanType
+ status;
+
+ cache_view=AcquireVirtualCacheView(image,exception);
+ status=SyncImagePixelCache(cache_view->image,exception);
+ if (status == MagickFalse)
+ ThrowFatalException(CacheFatalError,"UnableToAcquireCacheView");
+ return(cache_view);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% A c q u i r e V i r t u a l C a c h e V i e w %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% AcquireVirtualCacheView() acquires a virtual view into the pixel cache,
+% using the VirtualPixelMethod that is defined within the given image itself.
+%
+% The format of the AcquireVirtualCacheView method is:
+%
+% CacheView *AcquireVirtualCacheView(const Image *image,
+% ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+MagickExport CacheView *AcquireVirtualCacheView(const Image *image,
+ ExceptionInfo *exception)
{
CacheView
*cache_view;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ (void) exception;
cache_view=(CacheView *) AcquireQuantumMemory(1,sizeof(*cache_view));
if (cache_view == (CacheView *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
% o x,y,columns,rows: These values define the perimeter of a region of
% pixels.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport Quantum *GetCacheViewAuthenticPixels(CacheView *cache_view,
const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,
CacheView;
extern MagickExport CacheView
- *AcquireCacheView(const Image *),
+ *AcquireAuthenticCacheView(const Image *,ExceptionInfo *),
+ *AcquireVirtualCacheView(const Image *,ExceptionInfo *),
*CloneCacheView(const CacheView *),
*DestroyCacheView(CacheView *);
assert(cache_info->signature == MagickSignature);
image->matte=MagickTrue;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(status)
+ #pragma omp parallel for schedule(static) shared(status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
y;
status=MagickTrue;
- source_view=AcquireCacheView(source_image);
- destination_view=AcquireCacheView(destination_image);
+ source_view=AcquireVirtualCacheView(source_image,exception);
+ destination_view=AcquireAuthenticCacheView(destination_image,exception);
height=MagickMin(source_image->rows,destination_image->rows);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
*/
status=MagickTrue;
progress=0;
- combine_view=AcquireCacheView(combine_image);
+ combine_view=AcquireAuthenticCacheView(combine_image,exception);
for (y=0; y < (ssize_t) combine_image->rows; y++)
{
CacheView
traits=GetPixelChannelMapTraits(combine_image,channel);
if (traits == UndefinedPixelTrait)
continue;
- image_view=AcquireCacheView(next);
+ image_view=AcquireVirtualCacheView(next,exception);
p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
continue;
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- separate_view=AcquireCacheView(separate_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ separate_view=AcquireAuthenticCacheView(separate_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
*/
quantum_type=GetQuantumType(image,exception);
pixels=GetQuantumPixels(quantum_info);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
*/
quantum_type=GetQuantumType(image,exception);
pixels=GetQuantumPixels(quantum_info);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
status=MagickTrue;
GetPixelInfo(image,&pixel);
GetPixelInfo(image,&target);
- image_view=AcquireCacheView(image);
- target_view=AcquireCacheView(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++)
if (image->storage_class == DirectClass)
(void) SetImageType(image,PaletteType,exception);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
pixels[(ssize_t) image->colormap[i].alpha]=(unsigned short) i;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
Quantum
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
return(MagickFalse);
}
GetPixelInfo(image,&zero);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
logmap[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*(reference_white+
log10(black+((MagickRealType) i/MaxMap)*(1.0-black))/((gamma/density)*
0.002/film_gamma))/1024.0));
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
/*
Convert DirectClass image.
*/
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
return(MagickFalse);
}
GetPixelInfo(image,&zero);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
logmap[i]=(Quantum) QuantumRange;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
/*
Convert DirectClass image.
*/
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
/*
Convert PseudoClass image.
*/
- image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
}
}
}
- image_view=DestroyCacheView(image_view);
(void) SyncImage(image,exception);
break;
}
Generate difference image.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(reconstruct_image);
- highlight_view=AcquireCacheView(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)
#endif
Compute the absolute difference in pixels between two images.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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)
#endif
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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)
#endif
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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)
#endif
area=0.0;
maximum_error=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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)
#endif
for (i=0; i <= MaxPixelChannels; i++)
distortion[i]=0.0;
area=1.0/((MagickRealType) image->columns*image->rows-1);
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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
y;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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)
#endif
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
- reconstruct_view=AcquireCacheView(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
*/
status=MagickTrue;
progress=0;
- similarity_view=AcquireCacheView(similarity_image);
+ similarity_view=AcquireAuthenticCacheView(similarity_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_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)
#endif
if ((y_offset+(ssize_t) composite_image->rows) >= (ssize_t) image->rows)
break;
status=MagickTrue;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_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)
#endif
*/
resample_filter=AcquireResampleFilter(image,exception);
SetResampleFilter(resample_filter,CubicFilter); /* was blur*2 */
- destination_view=AcquireCacheView(destination_image);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireVirtualCacheView(composite_image,exception);
+ destination_view=AcquireAuthenticCacheView(destination_image,exception);
for (y=0; y < (ssize_t) composite_image->rows; y++)
{
MagickBooleanType
GetPixelRed(composite_image,p),blur.y2*QuantumScale*
GetPixelGreen(composite_image,p));
(void) ResamplePixelColor(resample_filter,(double) x_offset+x,
- (double) y_offset+y,&pixel);
+ (double) y_offset+y,&pixel,exception);
SetPixelInfoPixel(destination_image,&pixel,q);
p+=GetPixelChannels(composite_image);
q+=GetPixelChannels(destination_image);
displacement/distortion map. -- Like a lens...
*/
GetPixelInfo(image,&pixel);
- image_view=AcquireCacheView(image);
- destination_view=AcquireCacheView(destination_image);
- composite_view=AcquireCacheView(composite_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
status=MagickTrue;
progress=0;
midpoint=((MagickRealType) QuantumRange+1.0)/2;
- image_view=AcquireCacheView(image);
- composite_view=AcquireCacheView(composite_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)
#endif
Tile texture onto the image background (optimized).
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- texture_view=AcquireCacheView(texture_image);
+ texture_view=AcquireVirtualCacheView(texture_image,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
image->resolution.x=204.0;
image->resolution.y=196.0;
image->units=PixelsPerInchResolution;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; ((y < (ssize_t) image->rows) && (null_lines < 3)); )
{
register Quantum
trough.alpha=matte.alpha;
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- frame_view=AcquireCacheView(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)
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
if ((x_offset >= (int) (*image)->columns) ||
(y_offset >= (int) (*image)->rows))
continue;
- image_view=AcquireCacheView(*image);
+ image_view=AcquireAuthenticCacheView(*image,exception);
switch (method)
{
case PointMethod:
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
image->matte=MagickTrue;
- image_view=AcquireCacheView(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,
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
image->matte=MagickTrue;
- image_view=AcquireCacheView(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,
return(MagickFalse);
if ((*image)->matte == MagickFalse)
(void) SetImageAlphaChannel(*image,OpaqueAlphaChannel,exception);
- image_view=AcquireCacheView(*image);
+ image_view=AcquireAuthenticCacheView(*image,exception);
switch (method)
{
case PointMethod:
*/
x_offset=(int) (width*(tile % (((int) image->columns-x)/width))+x);
y_offset=(int) (height*(tile/(((int) image->columns-x)/width))+y);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
(void) GetOneCacheViewVirtualPixelInfo(image_view,0,0,&pixel,exception);
for (i=0; i < (int) height; i++)
{
GetPixelInfo(distort_image,&zero);
resample_filter=AcquireResampleFilterThreadSet(image,
UndefinedVirtualPixelMethod,MagickFalse,exception);
- distort_view=AcquireCacheView(distort_image);
+ distort_view=AcquireAuthenticCacheView(distort_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
}
else {
/* resample the source image to find its correct color */
- (void) ResamplePixelColor(resample_filter[id],s.x,s.y,&pixel);
+ (void) ResamplePixelColor(resample_filter[id],s.x,s.y,&pixel,
+ exception);
/* if validity between 0.0 and 1.0 mix result with invalid pixel */
if ( validity < 1.0 ) {
/* Do a blend of sample color and invalid pixel */
status=MagickTrue;
progress=0;
- sparse_view=AcquireCacheView(sparse_image);
+ sparse_view=AcquireAuthenticCacheView(sparse_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
GetPixelInfo(image,&zero);
start=(ssize_t) ceil(edge.y1-0.5);
stop=(ssize_t) ceil(edge.y2-0.5);
- image_view=AcquireCacheView(image);
- source_view=AcquireCacheView(source);
+ source_view=AcquireVirtualCacheView(source,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
bounding_box=gradient->bounding_box;
status=MagickTrue;
GetPixelInfo(image,&zero);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
bounds.y2=bounds.y2 < 0.0 ? 0.0 : (size_t) floor(bounds.y2+0.5) >=
image->rows ? (double) image->rows-1.0 : bounds.y2;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
if (primitive_info->coordinates == 1)
{
/*
status=MagickTrue;
x=(ssize_t) ceil(primitive_info->point.x-0.5);
y=(ssize_t) ceil(primitive_info->point.y-0.5);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
switch (primitive_info->primitive)
{
case PointPrimitive:
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- edge_view=AcquireCacheView(edge_image);
- blur_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- edge_view=AcquireCacheView(edge_image);
- sharp_view=AcquireCacheView(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)
#endif
status=MagickTrue;
progress=0;
center=(ssize_t) GetPixelChannels(image)*(width/2L);
- image_view=AcquireCacheView(image);
- blur_view=AcquireCacheView(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)
#endif
Blur columns.
*/
center=(ssize_t) GetPixelChannels(blur_image)*(width/2L);
- image_view=AcquireCacheView(blur_image);
- blur_view=AcquireCacheView(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)
#endif
Reduce speckle in the image.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
- despeckle_view=AcquireCacheView(despeckle_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ despeckle_view=AcquireAuthenticCacheView(despeckle_image,exception);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- motion_view=AcquireCacheView(image);
- blur_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- radial_view=AcquireCacheView(image);
- blur_view=AcquireCacheView(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)
#endif
progress=0;
center=(ssize_t) (GetPixelChannels(image)*(image->columns+width)*(width/2L)+
GetPixelChannels(image)*(width/2L));
- image_view=AcquireCacheView(image);
- blur_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- shade_view=AcquireCacheView(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)
#endif
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- image_view=AcquireCacheView(image);
- spread_view=AcquireCacheView(spread_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ spread_view=AcquireAuthenticCacheView(spread_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) omp_concurrent(concurrent)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- unsharp_view=AcquireCacheView(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)
#endif
status=MagickTrue;
progress=0;
adjust=(ssize_t) (clut_image->interpolate == IntegerInterpolatePixel ? 0 : 1);
- clut_view=AcquireCacheView(clut_image);
+ clut_view=AcquireVirtualCacheView(clut_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4)
#endif
(clut_image->rows-adjust),clut_map+i,exception);
}
clut_view=DestroyCacheView(clut_view);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
status=MagickTrue;
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
p+=GetPixelChannels(image);
}
}
+ image_view=DestroyCacheView(image_view);
/*
Find the histogram boundaries by locating the black/white levels.
*/
*/
status=MagickTrue;
progress=0;
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- enhance_view=AcquireCacheView(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)
#endif
status=MagickTrue;
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*GetPixelChannels(image)*
sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
p+=GetPixelChannels(image);
}
}
+ image_view=DestroyCacheView(image_view);
/*
Integrate the histogram to get the equalization map.
*/
Equalize image.
*/
progress=0;
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
cube_size=level*level;
width=(double) hald_image->columns;
GetPixelInfo(hald_image,&zero);
- image_view=AcquireCacheView(image);
- hald_view=AcquireCacheView(hald_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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
Form histogram.
*/
(void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram));
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
if (grayscale != MagickFalse)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
grays[i].black=(~0U);
}
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
Initialize spatial dependence matrix.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
i++;
}
}
- magnitude_view=AcquireCacheView(magnitude_image);
- phase_view=AcquireCacheView(phase_image);
+ magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
i=0L;
for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
if (status == MagickFalse)
break;
}
+ magnitude_view=DestroyCacheView(magnitude_view);
i=0L;
+ 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,
break;
}
phase_view=DestroyCacheView(phase_view);
- magnitude_view=DestroyCacheView(magnitude_view);
phase_source=(double *) RelinquishMagickMemory(phase_source);
magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);
return(status);
ResetMagickMemory(source,0,fourier_info->height*fourier_info->width*
sizeof(*source));
i=0L;
- image_view=AcquireCacheView(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,
return(MagickFalse);
}
i=0L;
- magnitude_view=AcquireCacheView(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,
}
}
i=0L;
- phase_view=AcquireCacheView(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,
fftw_destroy_plan(fftw_c2r_plan);
}
i=0L;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
if (y >= (ssize_t) image->rows)
FxInfo;
extern MagickPrivate FxInfo
- *AcquireFxInfo(const Image *,const char *),
+ *AcquireFxInfo(const Image *,const char *,ExceptionInfo *),
*DestroyFxInfo(FxInfo *);
extern MagickPrivate MagickBooleanType
%
% The format of the AcquireFxInfo method is:
%
-% FxInfo *AcquireFxInfo(Image *image,const char *expression)
+% FxInfo *AcquireFxInfo(Image *image,const char *expression,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o expression: the expression.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickPrivate FxInfo *AcquireFxInfo(const Image *image,const char *expression)
+MagickPrivate FxInfo *AcquireFxInfo(const Image *image,const char *expression,
+ ExceptionInfo *exception)
{
char
fx_op[2];
next=GetFirstImageInList(fx_info->images);
for ( ; next != (Image *) NULL; next=next->next)
{
- fx_info->view[i]=AcquireCacheView(next);
+ fx_info->view[i]=AcquireVirtualCacheView(next,exception);
i++;
}
fx_info->random_info=AcquireRandomInfo();
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- image_view=AcquireCacheView(image);
- noise_view=AcquireCacheView(noise_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ noise_view=AcquireAuthenticCacheView(noise_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) omp_concurrent(concurrent)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- shift_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- colorize_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- color_view=AcquireCacheView(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)
#endif
fx_expression=FileToString(expression+1,~0,exception);
for (i=0; i < (ssize_t) number_threads; i++)
{
- fx_info[i]=AcquireFxInfo(image,fx_expression);
+ fx_info[i]=AcquireFxInfo(image,fx_expression,exception);
if (fx_info[i] == (FxInfo *) NULL)
return(DestroyFxThreadSet(fx_info));
(void) FxPreprocessExpression(fx_info[i],&alpha,fx_info[i]->exception);
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- fx_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- implode_view=AcquireCacheView(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)
#endif
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
}
- image_view=AcquireCacheView(morph_image);
- morph_view=AcquireCacheView(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)
#endif
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- image_view=AcquireCacheView(image);
- u_view=AcquireCacheView(image);
- v_view=AcquireCacheView(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);
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- sepia_view=AcquireCacheView(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)
#endif
Shadow image.
*/
status=MagickTrue;
- image_view=AcquireCacheView(border_image);
+ image_view=AcquireAuthenticCacheView(border_image,exception);
for (y=0; y < (ssize_t) border_image->rows; y++)
{
PixelInfo
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- random_view=AcquireCacheView(random_image);
+ random_view=AcquireAuthenticCacheView(random_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) omp_concurrent(concurrent)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
depth=stegano_image->depth;
k=stegano_image->offset;
status=MagickTrue;
- watermark_view=AcquireCacheView(watermark);
- stegano_view=AcquireCacheView(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++)
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- swirl_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- tint_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- wave_view=AcquireCacheView(wave_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ wave_view=AcquireAuthenticCacheView(wave_image,exception);
(void) SetCacheViewVirtualPixelMethod(image_view,
BackgroundVirtualPixelMethod);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
}
GetPixelInfo(image,&pixel);
GetPixelInfo(image,&target);
- image_view=AcquireCacheView(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);
}
GetPixelInfo(image,&pixel);
GetPixelInfo(image,&target);
- image_view=AcquireCacheView(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);
}
GetPixelInfo(image,&pixel);
GetPixelInfo(image,&target);
- image_view=AcquireCacheView(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);
unique_image=DestroyImage(unique_image);
return((Image *) NULL);
}
- unique_view=AcquireCacheView(unique_image);
+ unique_view=AcquireAuthenticCacheView(unique_image,exception);
UniqueColorsToImage(unique_image,unique_view,cube_info,cube_info->root,
exception);
unique_view=DestroyCacheView(unique_view);
%
% The format of the NewImageView method is:
%
-% ImageView *NewImageView(MagickCore *wand)
+% ImageView *NewImageView(MagickCore *wand,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
-% o wand: the wand.
+% o image: the image.
+%
+% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport ImageView *NewImageView(Image *image)
+MagickExport ImageView *NewImageView(Image *image,ExceptionInfo *exception)
{
ImageView
*image_view;
(void) ResetMagickMemory(image_view,0,sizeof(*image_view));
image_view->description=ConstantString("ImageView");
image_view->image=image;
- image_view->view=AcquireCacheView(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;
% The format of the NewImageViewRegion method is:
%
% ImageView *NewImageViewRegion(MagickCore *wand,const ssize_t x,
-% const ssize_t y,const size_t width,const size_t height)
+% const ssize_t y,const size_t width,const size_t height,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o x,y,columns,rows: These values define the perimeter of a extent of
% pixel_wands view.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport ImageView *NewImageViewRegion(Image *image,const ssize_t x,
- const ssize_t y,const size_t width,const size_t height)
+ const ssize_t y,const size_t width,const size_t height,
+ ExceptionInfo *exception)
{
ImageView
*image_view;
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(image_view,0,sizeof(*image_view));
image_view->description=ConstantString("ImageView");
- image_view->view=AcquireCacheView(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;
extern MagickExport ImageView
*CloneImageView(const ImageView *),
*DestroyImageView(ImageView *),
- *NewImageView(Image *),
+ *NewImageView(Image *,ExceptionInfo *),
*NewImageViewRegion(Image *,const ssize_t,const ssize_t,const size_t,
- const size_t);
+ const size_t,ExceptionInfo *);
extern MagickExport MagickBooleanType
DuplexTransferImageViewIterator(ImageView *,ImageView *,ImageView *,
x_offset=0;
y_offset=0;
next=images;
- append_view=AcquireCacheView(append_image);
+ append_view=AcquireAuthenticCacheView(append_image,exception);
for (n=0; n < (MagickOffsetType) number_images; n++)
{
CacheView
x_offset-=geometry.x;
else
y_offset-=geometry.y;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
status=MagickTrue;
mask_image->colorspace=GRAYColorspace;
mask_image->mask=MagickFalse;
- image_view=AcquireCacheView(image);
- mask_view=AcquireCacheView(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
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
image->fuzz=background->fuzz;
image->depth=background->depth;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
break;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
break;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
break;
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
break;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
Set image background color.
*/
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
image->fuzz=color->fuzz;
image->depth=color->depth;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
}
status=MagickTrue;
image->mask=MagickTrue;
- image_view=AcquireCacheView(image);
- mask_view=AcquireCacheView(mask);
+ mask_view=AcquireVirtualCacheView(mask,exception);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
assert(image->signature == MagickSignature);
image->matte=MagickTrue;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
GravityAdjustGeometry(left_image->columns,left_image->rows,
left_image->gravity,&left_geometry);
gap=right_image->columns;
- left_view=AcquireCacheView(left_image);
- right_view=AcquireCacheView(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--)
GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
&top_geometry);
gap=bottom_image->rows;
- top_view=AcquireCacheView(top_image);
- bottom_view=AcquireCacheView(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--)
{
#define SmushImageTag "Smush/Image"
- CacheView
- *smush_view;
-
const Image
*image;
status=MagickTrue;
x_offset=0;
y_offset=0;
- smush_view=AcquireCacheView(smush_image);
for (n=0; n < (MagickOffsetType) number_images; n++)
{
SetGeometry(smush_image,&geometry);
smush_image->columns=(size_t) x_offset;
else
smush_image->rows=(size_t) y_offset;
- smush_view=DestroyCacheView(smush_view);
if (status == MagickFalse)
smush_image=DestroyImage(smush_image);
return(smush_image);
return(MagickFalse);
range_exception=MagickFalse;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(range_exception,status)
#endif
/* #undef AUTOTRACE_DELEGATE */
/* Define if coders and filters are to be built as modules. */
-/* #undef BUILD_MODULES */
+#ifndef MAGICKCORE_BUILD_MODULES
+#define MAGICKCORE_BUILD_MODULES 1
+#endif
/* Define if you have the bzip2 library */
#ifndef MAGICKCORE_BZLIB_DELEGATE
/* #undef GS_DELEGATE */
/* Define if you have GVC library */
-#ifndef MAGICKCORE_GVC_DELEGATE
-#define MAGICKCORE_GVC_DELEGATE 1
-#endif
+/* #undef GVC_DELEGATE */
/* Define to 1 if you have the `acosh' function. */
#ifndef MAGICKCORE_HAVE_ACOSH
#endif
/* Define to 1 if you have the <CL/cl.h> header file. */
-/* #undef HAVE_CL_CL_H */
+#ifndef MAGICKCORE_HAVE_CL_CL_H
+#define MAGICKCORE_HAVE_CL_CL_H 1
+#endif
/* Define to 1 if you have the <complex.h> header file. */
#ifndef MAGICKCORE_HAVE_COMPLEX_H
#endif
/* Define if you have JBIG library */
-/* #undef JBIG_DELEGATE */
+#ifndef MAGICKCORE_JBIG_DELEGATE
+#define MAGICKCORE_JBIG_DELEGATE 1
+#endif
/* Define if you have JPEG version 2 "Jasper" library */
#ifndef MAGICKCORE_JP2_DELEGATE
/* Define to the system default library search path. */
#ifndef MAGICKCORE_LT_DLSEARCH_PATH
-#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/lib/llvm:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/qt-3.3/lib:/usr/lib64/tcl8.5/tclx8.4:/usr/lib64/tcl8.5:/usr/lib64/tracker-0.14:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
+#define MAGICKCORE_LT_DLSEARCH_PATH "/lib64:/usr/lib64:/lib:/usr/lib:/usr/lib64/atlas:/usr/local/cuda/lib64:/usr/local/cuda/lib:/usr/lib/llvm:/usr/lib64/llvm:/usr/local/lib:/usr/lib64/mysql:/usr/lib64/nvidia:/usr/lib64/tracker-0.14:/usr/lib/wine/:/usr/lib64/wine/:/usr/lib64/xulrunner-2"
#endif
/* The archive extension */
/* #undef LT_SHARED_EXT */
/* Define if you have LZMA library */
-#ifndef MAGICKCORE_LZMA_DELEGATE
-#define MAGICKCORE_LZMA_DELEGATE 1
-#endif
+/* #undef LZMA_DELEGATE */
/* Define to prepend to default font search path. */
/* #undef MAGICK_FONT_PATH */
/* #undef NO_MINUS_C_MINUS_O */
/* Define if you have OPENEXR library */
-/* #undef OPENEXR_DELEGATE */
+#ifndef MAGICKCORE_OPENEXR_DELEGATE
+#define MAGICKCORE_OPENEXR_DELEGATE 1
+#endif
/* Name of package */
#ifndef MAGICKCORE_PACKAGE
#endif
/* Define if you have RSVG library */
-/* #undef RSVG_DELEGATE */
+#ifndef MAGICKCORE_RSVG_DELEGATE
+#define MAGICKCORE_RSVG_DELEGATE 1
+#endif
/* Define to the type of arg 1 for `select'. */
#ifndef MAGICKCORE_SELECT_TYPE_ARG1
/* #undef _MINIX */
/* Define this for the OpenCL Accelerator */
-/* #undef _OPENCL */
+#ifndef MAGICKCORE__OPENCL
+#define MAGICKCORE__OPENCL 1
+#endif
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
changed=0;
progress=0;
- image_view=AcquireCacheView(image);
- morphology_view=AcquireCacheView(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.
/* DO NOT THREAD THIS CODE! */
/* two views into same image (virtual, and actual) */
- virt_view=AcquireCacheView(image);
- auth_view=AcquireCacheView(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++)
PushSegmentStack(y,x,x,1);
PushSegmentStack(y+1,x,x,-1);
GetPixelInfo(image,&pixel);
- image_view=AcquireCacheView(image);
- floodplane_view=AcquireCacheView(floodplane_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);
while (s > segment_stack)
{
register const Quantum
progress=0;
center=(ssize_t) GetPixelChannels(image)*(image->columns+width)*(width/2L)+
GetPixelChannels(image)*(width/2L);
- image_view=AcquireCacheView(image);
- paint_view=AcquireCacheView(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)
#endif
status=MagickTrue;
progress=0;
GetPixelInfo(image,&zero);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
status=MagickTrue;
progress=0;
GetPixelInfo(image,&zero);
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
- filter_view=AcquireCacheView(filter_image);
+ filter_view=AcquireVirtualCacheView(filter_image,exception);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p == (const Quantum *) NULL)
status=MagickFalse;
excerpt_source=DestroyImage(excerpt_source);
if (filter_source == (Image *) NULL)
continue;
- filter_view=AcquireCacheView(filter_source);
+ filter_view=AcquireVirtualCacheView(filter_source,exception);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p == (const Quantum *) NULL)
status=MagickFalse;
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
- filter_view=AcquireCacheView(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);
}
status=MagickTrue;
total_ink_density=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
(void) SetImageColorspace(image,target_colorspace,exception);
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
{
if (LocaleNCompare("fx:",property,3) == 0)
{
- fx_info=AcquireFxInfo(image,property+3);
+ fx_info=AcquireFxInfo(image,property+3,exception);
status=FxEvaluateChannelExpression(fx_info,IntensityPixelChannel,0,0,
&alpha,exception);
fx_info=DestroyFxInfo(fx_info);
pixel;
GetPixelInfo(image,&pixel);
- fx_info=AcquireFxInfo(image,property+6);
+ fx_info=AcquireFxInfo(image,property+6,exception);
status=FxEvaluateChannelExpression(fx_info,RedPixelChannel,0,0,
&alpha,exception);
pixel.red=(MagickRealType) QuantumRange*alpha;
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
midpoint.blue=(MagickRealType) QuantumRange/2.0;
midpoint.alpha=(MagickRealType) QuantumRange/2.0;
error.alpha=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
if (pixels == (RealPixelInfo **) NULL)
return(MagickFalse);
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
const int
depth++;
cube_info->offset=0;
cube_info->span=(MagickSizeType) image->columns*image->rows;
- image_view=AcquireCacheView(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);
maximum_error=0.0;
mean_error_per_pixel=0.0;
mean_error=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
if (image->colors != number_colors)
return(MagickFalse);
i=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
image->filename);
image->colors=0;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
image->colormap=colormap;
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
resample_filter->exception=exception;
resample_filter->image=ReferenceImage((Image *) image);
- resample_filter->view=AcquireCacheView(resample_filter->image);
+ resample_filter->view=AcquireVirtualCacheView(resample_filter->image,exception);
resample_filter->debug=IsEventLogging();
resample_filter->signature=MagickSignature;
% The format of the ResamplePixelColor method is:
%
% MagickBooleanType ResamplePixelColor(ResampleFilter *resample_filter,
-% const double u0,const double v0,PixelInfo *pixel)
+% const double u0,const double v0,PixelInfo *pixel,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o pixel: the resampled pixel is returned here.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType ResamplePixelColor(
ResampleFilter *resample_filter,const double u0,const double v0,
- PixelInfo *pixel)
+ PixelInfo *pixel,ExceptionInfo *exception)
{
MagickBooleanType
status;
*pixel=resample_filter->average_pixel; /* FAILED */
break;
}
- average_view=AcquireCacheView(average_image);
+ average_view=AcquireVirtualCacheView(average_image,exception);
pixels=GetCacheViewVirtualPixels(average_view,0,0,1,1,
resample_filter->exception);
if (pixels == (const Quantum *) NULL) {
extern MagickExport MagickBooleanType
ResamplePixelColor(ResampleFilter *,const double,const double,
- PixelInfo *),
+ PixelInfo *,ExceptionInfo *),
SetResampleFilterInterpolateMethod(ResampleFilter *,
const PixelInterpolateMethod),
SetResampleFilterVirtualPixelMethod(ResampleFilter *,
}
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- resize_view=AcquireCacheView(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)
return((Image *) NULL);
status=MagickTrue;
q=pixels;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
rescale_image=DestroyImage(rescale_image);
return((Image *) NULL);
}
- rescale_view=AcquireCacheView(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)
{
}
status=MagickTrue;
scale=1.0/scale;
- image_view=AcquireCacheView(image);
- resize_view=AcquireCacheView(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)
#endif
status=MagickTrue;
scale=1.0/scale;
(void) ResetMagickMemory(&zero,0,sizeof(zero));
- image_view=AcquireCacheView(image);
- resize_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- sample_view=AcquireCacheView(sample_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ sample_view=AcquireAuthenticCacheView(sample_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
for (i=0; i < (ssize_t) (GetPixelChannels(image)*image->columns); i++)
y_vector[i]=0.0;
n=0;
- image_view=AcquireCacheView(image);
- scale_view=AcquireCacheView(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
status=MagickTrue;
count=0;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
/*
Do course grain classes.
*/
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
bits[i]=(unsigned short) count;
}
status=MagickTrue;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status)
#endif
return;
GetPixelInfo(image,&background);
count=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- rotate_view=AcquireCacheView(rotate_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ rotate_view=AcquireAuthenticCacheView(rotate_image,exception);
switch (rotations)
{
case 0:
status=MagickTrue;
background=image->background_color;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
status=MagickTrue;
progress=0;
background=image->background_color;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
signature=AcquireStringInfo(image->columns*GetPixelChannels(image)*
sizeof(pixel));
pixels=GetStringInfoDatum(signature);
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- evaluate_view=AcquireCacheView(evaluate_image);
+ evaluate_view=AcquireAuthenticCacheView(evaluate_image,exception);
if (op == MedianEvaluateOperator)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
register ssize_t
i;
- image_view=AcquireCacheView(next);
+ image_view=AcquireVirtualCacheView(next,exception);
p=GetCacheViewVirtualPixels(image_view,x,y,1,1,exception);
if (p == (const Quantum *) NULL)
{
register const Quantum
*p;
- image_view=AcquireCacheView(next);
+ image_view=AcquireVirtualCacheView(next,exception);
p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
{
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) omp_concurrent(concurrent)
#endif
return(MagickFalse);
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status)
#endif
sum_squares=0.0;
sum_cubes=0.0;
sum_fourth_power=0.0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
status=MagickTrue;
*maxima=(-MagickHuge);
*minima=MagickHuge;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
(MagickMax(height,1)/2L)+GetPixelChannels(image)*(MagickMax(width,1)/2L);
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- statistic_view=AcquireCacheView(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)
#endif
status=MagickTrue;
progress=0;
number_pixels=(MagickSizeType) width*height;
- image_view=AcquireCacheView(image);
- threshold_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status)
#endif
return(MagickFalse);
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status)
#endif
random_info=AcquireRandomInfoThreadSet();
concurrent=GetRandomSecretKey(random_info[0]) == ~0UL ? MagickTrue :
MagickFalse;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) omp_concurrent(concurrent)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- chop_view=AcquireCacheView(chop_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ chop_view=AcquireAuthenticCacheView(chop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
(void) SetImageColorspace(cmyk_image,CMYKColorspace,exception);
for (i=0; i < 4; i++)
{
- image_view=AcquireCacheView(images);
- cmyk_view=AcquireCacheView(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
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- crop_view=AcquireCacheView(crop_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ crop_view=AcquireAuthenticCacheView(crop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- excerpt_view=AcquireCacheView(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)
#endif
status=MagickTrue;
progress=0;
page=image->page;
- image_view=AcquireCacheView(image);
- flip_view=AcquireCacheView(flip_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ flip_view=AcquireAuthenticCacheView(flip_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
status=MagickTrue;
progress=0;
page=image->page;
- image_view=AcquireCacheView(image);
- flop_view=AcquireCacheView(flop_image);
+ image_view=AcquireVirtualCacheView(image,exception);
+ flop_view=AcquireAuthenticCacheView(flop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status)
#endif
y;
status=MagickTrue;
- source_view=AcquireCacheView(source);
- destination_view=AcquireCacheView(destination);
+ source_view=AcquireVirtualCacheView(source,exception);
+ destination_view=AcquireAuthenticCacheView(destination,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- splice_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- transpose_view=AcquireCacheView(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)
#endif
*/
status=MagickTrue;
progress=0;
- image_view=AcquireCacheView(image);
- transverse_view=AcquireCacheView(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)
#endif
*/
#define MagickPackageName "ImageMagick"
#define MagickCopyright "Copyright (C) 1999-2012 ImageMagick Studio LLC"
-#define MagickSVNRevision "7561"
+#define MagickSVNRevision ""
#define MagickLibVersion 0x700
#define MagickLibVersionText "7.0.0"
#define MagickLibVersionNumber 7,0,0
#define MagickLibAddendum "-0"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
-#define MagickReleaseDate "2012-04-19"
+#define MagickReleaseDate "2012-04-20"
#define MagickChangeDate "20110801"
#define MagickAuthoritativeURL "http://www.imagemagick.org"
#if defined(MAGICKCORE_OPENMP_SUPPORT)
(ssize_t) y,&annotate_image->background_color,exception);
if (annotate_info->stencil == ForegroundStencil)
annotate_image->matte=MagickTrue;
- annotate_view=AcquireCacheView(annotate_image);
+ annotate_view=AcquireAuthenticCacheView(annotate_image,exception);
for (y=0; y < (int) annotate_image->rows; y++)
{
register int
i=0;
j=0;
q=ximage->data;
- image_view=AcquireCacheView(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,
if (SetImageStorageClass(draw_image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
draw_image->matte=MagickTrue;
- draw_view=AcquireCacheView(draw_image);
+ draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
/*
Composite text onto the image.
*/
- draw_view=AcquireCacheView(draw_image);
+ draw_view=AcquireAuthenticCacheView(draw_image,exception);
for (y=0; y < (int) draw_image->rows; y++)
{
register int
composite_image->storage_class=PseudoClass;
composite_image->columns=(size_t) ximage->width;
composite_image->rows=(size_t) ximage->height;
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireAuthenticCacheView(composite_image,exception);
switch (composite_image->storage_class)
{
case DirectClass:
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
- canvas_view=AcquireCacheView(canvas);
+ canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
- canvas_view=AcquireCacheView(canvas);
+ canvas_view=AcquireVirtualCacheView(canvas,exception);
if (ximage->format == XYBitmap)
{
register unsigned short
diversity[i].index=(unsigned short) i;
diversity[i].count=0;
}
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
for (y=0; y < (int) image->rows; y++)
{
register int
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- image_view=AcquireCacheView(wand->images);
+ image_view=AcquireVirtualCacheView(wand->images,wand->exception);
p=GetCacheViewVirtualPixels(image_view,x,y,1,1,wand->exception);
if (p == (const Quantum *) NULL)
{
break;
if (SetImageStorageClass(mask_image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
- mask_view=AcquireCacheView(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,
break;
/* Create a write mask from cli_wand mask image */
/* FUTURE: use Alpha operations instead and create a Grey Image */
- mask_view=AcquireCacheView(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,
const char
*quantum;
+ ExceptionInfo
+ *exception;
+
Image
*image;
image=GetImageFromMagickWand(wand);
if (image == (Image *) NULL)
return((PixelIterator *) NULL);
- view=AcquireCacheView(image);
+ exception=AcquireExceptionInfo();
+ view=AcquireVirtualCacheView(image,exception);
if (view == (CacheView *) NULL)
return((PixelIterator *) NULL);
iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));
iterator->id=AcquireWandId();
(void) FormatLocaleString(iterator->name,MaxTextExtent,"%s-%.20g",
PixelIteratorId,(double) iterator->id);
- iterator->exception=AcquireExceptionInfo();
+ iterator->exception=exception;
iterator->image=CloneImage(image,0,0,MagickTrue,iterator->exception);
iterator->view=view;
SetGeometry(image,&iterator->region);
const char
*quantum;
+ ExceptionInfo
+ *exception;
+
Image
*image;
image=GetImageFromMagickWand(wand);
if (image == (Image *) NULL)
return((PixelIterator *) NULL);
- view=AcquireCacheView(image);
+ exception=AcquireExceptionInfo();
+ view=AcquireVirtualCacheView(image,exception);
if (view == (CacheView *) NULL)
return((PixelIterator *) NULL);
iterator=(PixelIterator *) AcquireMagickMemory(sizeof(*iterator));
iterator->id=AcquireWandId();
(void) FormatLocaleString(iterator->name,MaxTextExtent,"%s-%.20g",
PixelIteratorId,(double) iterator->id);
- iterator->exception=AcquireExceptionInfo();
+ iterator->exception=exception;
iterator->view=view;
SetGeometry(image,&iterator->region);
iterator->region.width=width;
WandExport WandView *NewWandView(MagickWand *wand)
{
+ ExceptionInfo
+ *exception;
+
WandView
*wand_view;
WandViewId,(double) wand_view->id);
wand_view->description=ConstantString("WandView");
wand_view->wand=wand;
- wand_view->view=AcquireCacheView(wand_view->wand->images);
+ exception=AcquireExceptionInfo();
+ 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->number_threads=GetOpenMPMaximumThreads();
wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
wand_view->number_threads);
- wand_view->exception=AcquireExceptionInfo();
+ wand_view->exception=exception;
if (wand_view->pixel_wands == (PixelWand ***) NULL)
ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
WandExport WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
const ssize_t y,const size_t width,const size_t height)
{
+ ExceptionInfo
+ *exception;
+
WandView
*wand_view;
(void) FormatLocaleString(wand_view->name,MaxTextExtent,"%s-%.20g",
WandViewId,(double) wand_view->id);
wand_view->description=ConstantString("WandView");
- wand_view->view=AcquireCacheView(wand_view->wand->images);
+ exception=AcquireExceptionInfo();
+ wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
wand_view->wand=wand;
wand_view->extent.width=width;
wand_view->extent.height=height;
wand_view->extent.x=x;
wand_view->extent.y=y;
wand_view->number_threads=GetOpenMPMaximumThreads();
- wand_view->exception=AcquireExceptionInfo();
+ wand_view->exception=exception;
wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
wand_view->number_threads);
if (wand_view->pixel_wands == (PixelWand ***) NULL)
y=0;
items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
(void) items;
- image_view=AcquireCacheView(image);
+ image_view=AcquireAuthenticCacheView(image,exception);
q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
if (q != (Quantum *) NULL)
{
y=0;
items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
(void) items;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,exception);
if (q != (Quantum *) NULL)
{
y=0;
items=sscanf(attribute,"%*[^[][%ld%*[,/]%ld",&x,&y);
(void) items;
- image_view=AcquireCacheView(image);
+ image_view=AcquireVirtualCacheView(image,exception);
p=GetCacheViewVirtualPixels(image_view,x,y,1,1,exception);
if (p != (const Quantum *) NULL)
{
1.0);
if (composite_image->matte != MagickTrue)
(void) SetImageAlpha(composite_image,OpaqueAlpha,exception);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireAuthenticCacheView(composite_image,
+ exception);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
q=GetCacheViewAuthenticPixels(composite_view,0,y,(ssize_t)
if (composite_image->matte != MagickTrue)
(void) SetImageAlpha(composite_image,OpaqueAlpha,
&exception);
- composite_view=AcquireCacheView(composite_image);
+ composite_view=AcquireAuthenticCacheView(composite_image,
+ &exception);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
q=GetCacheViewAuthenticPixels(composite_view,0,y,
(void) sscanf(clone_info->filename,"%lx,%lx",¶m1,¶m2);
image_ptr=(Image **) param2;
if (*image_ptr != (Image *)NULL)
- image=CloneImage(*image_ptr,0,0,MagickFalse,exception);
+ image=CloneImage(*image_ptr,0,0,MagickFalse,&(*image_ptr)->exception);
#ifdef ALL_IMAGEINFO
image_info_ptr=(ImageInfo **) param1;
if (*image_info_ptr != (ImageInfo *)NULL)
SetImageInfo(clone_info,1,exception);
(void) CopyMagickString(image->magick,clone_info->magick,
MaxTextExtent);
- status=WriteStream(clone_info,image,fifo,exception);
+ status=WriteStream(clone_info,image,fifo);
if (status == MagickFalse)
CatchImageException(image);
}
SetImageInfo(clone_info,1,exception);
(void) CopyMagickString(image->magick,clone_info->magick,
MaxTextExtent);
- status=WriteStream(clone_info,image,SafeArrayFifo,exception);
+ status=WriteStream(clone_info,image,SafeArrayFifo);
if (status == MagickFalse)
CatchImageException(image);
}
projects / imagemagick / commitdiff