*QueueAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,
const size_t,ExceptionInfo *),
*SetPixelCacheNexusPixels(const CacheInfo *,const MapMode,
- const RectangleInfo *,const MagickBooleanType,NexusInfo *,
- ExceptionInfo *) magick_hot_spot;
+ const RectangleInfo *,const MagickBooleanType,NexusInfo *,ExceptionInfo *)
+ magick_hot_spot;
#if defined(MAGICKCORE_OPENCL_SUPPORT)
static void
if (cache_info->type == PingCache)
return(MagickTrue);
length=cache_info->number_channels*sizeof(*cache_info->channel_map);
- if ((cache_info->columns == clone_info->columns) &&
+ if ((cache_info->storage_class == clone_info->storage_class) &&
+ (cache_info->colorspace == clone_info->colorspace) &&
+ (cache_info->alpha_trait == clone_info->alpha_trait) &&
+ (cache_info->channels == clone_info->channels) &&
+ (cache_info->columns == clone_info->columns) &&
(cache_info->rows == clone_info->rows) &&
(cache_info->number_channels == clone_info->number_channels) &&
(memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) &&
else
{
if (clone != MagickFalse)
- status=ClonePixelCacheRepository(clone_info,cache_info,
- exception);
+ {
+ if (cache_info->file != -1)
+ (void) ClosePixelCacheOnDisk(cache_info);
+ status=ClonePixelCacheRepository(clone_info,cache_info,
+ exception);
+ }
if (status == MagickFalse)
clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
else
return(cache_info->methods.get_one_virtual_pixel_from_handler(image,
GetPixelCacheVirtualMethod(image),x,y,pixel,exception));
assert(id < (int) cache_info->number_threads);
- p=GetVirtualPixelsFromNexus(image,GetPixelCacheVirtualMethod(image),x,y,
+ p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
1UL,1UL,cache_info->nexus_info[id],exception);
return(CopyPixel(image,p,pixel));
}
assert(cache_info->signature == MagickCoreSignature);
assert(id < (int) cache_info->number_threads);
(void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x,y,1UL,1UL,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
cache_info->nexus_info[id],exception);
return(CopyPixel(image,p,pixel));
}
assert(cache_info->signature == MagickCoreSignature);
assert(id < (int) cache_info->number_threads);
GetPixelInfo(image,pixel);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x,y,1UL,1UL,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
cache_info->nexus_info[id],exception);
if (p == (const Quantum *) NULL)
return(MagickFalse);
% %
% %
% %
-+ G e t V i r t u a l P i x e l s F r o m N e x u s %
++ G e t V i r t u a l P i x e l C a c h e N e x u s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetVirtualPixelsFromNexus() gets virtual pixels from the in-memory or disk
+% GetVirtualPixelCacheNexus() gets virtual pixels from the in-memory or disk
% pixel cache as defined by the geometry parameters. A pointer to the pixels
% is returned if the pixels are transferred, otherwise a NULL is returned.
%
-% The format of the GetVirtualPixelsFromNexus() method is:
+% The format of the GetVirtualPixelCacheNexus() method is:
%
-% Quantum *GetVirtualPixelsFromNexus(const Image *image,
+% Quantum *GetVirtualPixelCacheNexus(const Image *image,
% const VirtualPixelMethod method,const ssize_t x,const ssize_t y,
% const size_t columns,const size_t rows,NexusInfo *nexus_info,
% ExceptionInfo *exception)
return(modulo);
}
-MagickPrivate const Quantum *GetVirtualPixelsFromNexus(const Image *image,
+MagickPrivate const Quantum *GetVirtualPixelCacheNexus(const Image *image,
const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
const size_t columns,const size_t rows,NexusInfo *nexus_info,
ExceptionInfo *exception)
region.height=rows;
pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,®ion,
((image->channels & WriteMaskChannel) != 0) ||
- ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
+ ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
nexus_info,exception);
if (pixels == (Quantum *) NULL)
return((const Quantum *) NULL);
case EdgeVirtualPixelMethod:
default:
{
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
EdgeX(x_offset,cache_info->columns),
EdgeY(y_offset,cache_info->rows),1UL,1UL,*virtual_nexus,
exception);
{
if (cache_info->random_info == (RandomInfo *) NULL)
cache_info->random_info=AcquireRandomInfo();
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
RandomX(cache_info->random_info,cache_info->columns),
RandomY(cache_info->random_info,cache_info->rows),1UL,1UL,
*virtual_nexus,exception);
}
case DitherVirtualPixelMethod:
{
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
DitherX(x_offset,cache_info->columns),
DitherY(y_offset,cache_info->rows),1UL,1UL,*virtual_nexus,
exception);
{
x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,y_modulo.remainder,1UL,1UL,*virtual_nexus,
exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
if ((y_modulo.quotient & 0x01) == 1L)
y_modulo.remainder=(ssize_t) cache_info->rows-
y_modulo.remainder-1L;
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,y_modulo.remainder,1UL,1UL,*virtual_nexus,
exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
case HorizontalTileEdgeVirtualPixelMethod:
{
x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,EdgeY(y_offset,cache_info->rows),1UL,1UL,
*virtual_nexus,exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
case VerticalTileEdgeVirtualPixelMethod:
{
y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
EdgeX(x_offset,cache_info->columns),y_modulo.remainder,1UL,1UL,
*virtual_nexus,exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
r=virtual_metacontent;
break;
}
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,y_modulo.remainder,1UL,1UL,*virtual_nexus,
exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
}
x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,y_modulo.remainder,1UL,1UL,*virtual_nexus,
exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
}
x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
x_modulo.remainder,y_modulo.remainder,1UL,1UL,*virtual_nexus,
exception);
r=GetVirtualMetacontentFromNexus(cache_info,*virtual_nexus);
/*
Transfer a run of pixels.
*/
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x_offset,y_offset,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x_offset,y_offset,
(size_t) length,1UL,*virtual_nexus,exception);
if (p == (const Quantum *) NULL)
break;
cache_info=(CacheInfo *) image->cache;
assert(cache_info->signature == MagickCoreSignature);
assert(id < (int) cache_info->number_threads);
- p=GetVirtualPixelsFromNexus(image,virtual_pixel_method,x,y,columns,rows,
+ p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,columns,rows,
cache_info->nexus_info[id],exception);
return(p);
}
return(cache_info->methods.get_virtual_pixel_handler(image,
GetPixelCacheVirtualMethod(image),x,y,columns,rows,exception));
assert(id < (int) cache_info->number_threads);
- p=GetVirtualPixelsFromNexus(image,GetPixelCacheVirtualMethod(image),x,y,
+ p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
columns,rows,cache_info->nexus_info[id],exception);
return(p);
}
region.height=rows;
pixels=SetPixelCacheNexusPixels(cache_info,WriteMode,®ion,
((image->channels & WriteMaskChannel) != 0) ||
- ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
+ ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
nexus_info,exception);
return(pixels);
}