43#include "MagickCore/studio.h"
44#include "MagickCore/blob.h"
45#include "MagickCore/blob-private.h"
46#include "MagickCore/cache.h"
47#include "MagickCore/cache-private.h"
48#include "MagickCore/color-private.h"
49#include "MagickCore/colorspace-private.h"
50#include "MagickCore/composite-private.h"
51#include "MagickCore/distribute-cache-private.h"
52#include "MagickCore/exception.h"
53#include "MagickCore/exception-private.h"
54#include "MagickCore/geometry.h"
55#include "MagickCore/list.h"
56#include "MagickCore/log.h"
57#include "MagickCore/magick.h"
58#include "MagickCore/memory_.h"
59#include "MagickCore/memory-private.h"
60#include "MagickCore/nt-base-private.h"
61#include "MagickCore/option.h"
62#include "MagickCore/pixel.h"
63#include "MagickCore/pixel-accessor.h"
64#include "MagickCore/pixel-private.h"
65#include "MagickCore/policy.h"
66#include "MagickCore/policy-private.h"
67#include "MagickCore/quantum.h"
68#include "MagickCore/random_.h"
69#include "MagickCore/registry.h"
70#include "MagickCore/resource_.h"
71#include "MagickCore/semaphore.h"
72#include "MagickCore/splay-tree.h"
73#include "MagickCore/string_.h"
74#include "MagickCore/string-private.h"
75#include "MagickCore/timer-private.h"
76#include "MagickCore/thread-private.h"
77#include "MagickCore/utility.h"
78#include "MagickCore/utility-private.h"
79#if defined(MAGICKCORE_HAVE_ERRNO_H)
82#if defined(MAGICKCORE_HAVE_SYS_LOADAVG_H)
83# include <sys/loadavg.h>
85#if defined(MAGICKCORE_ZLIB_DELEGATE)
92#define CacheTick(offset,extent) QuantumTick((MagickOffsetType) offset,extent)
93#define IsFileDescriptorLimitExceeded() (GetMagickResource(FileResource) > \
94 GetMagickResourceLimit(FileResource) ? MagickTrue : MagickFalse)
109#if defined(__cplusplus) || defined(c_plusplus)
114 GetImagePixelCache(Image *,
const MagickBooleanType,ExceptionInfo *)
118 *GetVirtualPixelCache(
const Image *,
const VirtualPixelMethod,
const ssize_t,
119 const ssize_t,
const size_t,
const size_t,ExceptionInfo *),
120 *GetVirtualPixelsCache(
const Image *);
123 *GetVirtualMetacontentFromCache(
const Image *);
125static MagickBooleanType
126 GetOneAuthenticPixelFromCache(Image *,
const ssize_t,
const ssize_t,Quantum *,
128 GetOneVirtualPixelFromCache(
const Image *,
const VirtualPixelMethod,
129 const ssize_t,
const ssize_t,Quantum *,ExceptionInfo *),
130 OpenPixelCache(Image *,
const MapMode,ExceptionInfo *),
131 OpenPixelCacheOnDisk(CacheInfo *,
const MapMode,ExceptionInfo *),
132 ReadPixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
134 ReadPixelCacheMetacontent(CacheInfo *magick_restrict,
135 NexusInfo *magick_restrict,ExceptionInfo *),
136 SyncAuthenticPixelsCache(Image *,ExceptionInfo *),
137 WritePixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
139 WritePixelCacheMetacontent(CacheInfo *,NexusInfo *magick_restrict,
143 *GetAuthenticPixelsCache(Image *,
const ssize_t,
const ssize_t,
const size_t,
144 const size_t,ExceptionInfo *),
145 *QueueAuthenticPixelsCache(Image *,
const ssize_t,
const ssize_t,
const size_t,
146 const size_t,ExceptionInfo *),
147 *QueueAuthenticPixelCacheNexusInternal(Image *,
const ssize_t,
const ssize_t,
148 const size_t,
const size_t,
const MagickBooleanType,NexusInfo **,
150 *SetPixelCacheNexusPixels(
const CacheInfo *magick_restrict,
const MapMode,
151 const ssize_t,
const ssize_t,
const size_t,
const size_t,
152 const MagickBooleanType,NexusInfo *magick_restrict,ExceptionInfo *)
155#if defined(MAGICKCORE_OPENCL_SUPPORT)
157 CopyOpenCLBuffer(CacheInfo *magick_restrict);
160#if defined(__cplusplus) || defined(c_plusplus)
171 cache_anonymous_memory = (-1);
195MagickPrivate Cache AcquirePixelCache(
const size_t number_threads)
198 *magick_restrict cache_info;
203 cache_info=(CacheInfo *) AcquireAlignedMemory(1,
sizeof(*cache_info));
204 if (cache_info == (CacheInfo *) NULL)
205 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
206 (void) memset(cache_info,0,
sizeof(*cache_info));
207 cache_info->type=UndefinedCache;
208 cache_info->mode=IOMode;
209 cache_info->disk_mode=IOMode;
210 cache_info->colorspace=sRGBColorspace;
211 cache_info->file=(-1);
212 cache_info->id=GetMagickThreadId();
213 cache_info->number_threads=number_threads;
214 if (GetOpenMPMaximumThreads() > cache_info->number_threads)
215 cache_info->number_threads=GetOpenMPMaximumThreads();
216 if (cache_info->number_threads == 0)
217 cache_info->number_threads=1;
218 cache_info->nexus_info=AcquirePixelCacheNexus(cache_info->number_threads);
219 value=GetEnvironmentValue(
"MAGICK_SYNCHRONIZE");
220 if (value != (
const char *) NULL)
222 cache_info->synchronize=IsStringTrue(value);
223 value=DestroyString(value);
225 value=GetPolicyValue(
"cache:synchronize");
226 if (value != (
const char *) NULL)
228 cache_info->synchronize=IsStringTrue(value);
229 value=DestroyString(value);
231 cache_info->width_limit=MagickMin(GetMagickResourceLimit(WidthResource),
232 (MagickSizeType) MAGICK_SSIZE_MAX);
233 cache_info->height_limit=MagickMin(GetMagickResourceLimit(HeightResource),
234 (MagickSizeType) MAGICK_SSIZE_MAX);
235 cache_info->semaphore=AcquireSemaphoreInfo();
236 cache_info->reference_count=1;
237 cache_info->file_semaphore=AcquireSemaphoreInfo();
238 cache_info->debug=(GetLogEventMask() & CacheEvent) != 0 ? MagickTrue :
240 cache_info->signature=MagickCoreSignature;
241 return((Cache ) cache_info);
266MagickPrivate NexusInfo **AcquirePixelCacheNexus(
const size_t number_threads)
269 **magick_restrict nexus_info;
274 nexus_info=(NexusInfo **) MagickAssumeAligned(AcquireAlignedMemory(2*
275 number_threads,
sizeof(*nexus_info)));
276 if (nexus_info == (NexusInfo **) NULL)
277 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
278 *nexus_info=(NexusInfo *) AcquireQuantumMemory(number_threads,
279 2*
sizeof(**nexus_info));
280 if (*nexus_info == (NexusInfo *) NULL)
281 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
282 (void) memset(*nexus_info,0,2*number_threads*
sizeof(**nexus_info));
283 for (i=0; i < (ssize_t) (2*number_threads); i++)
285 nexus_info[i]=(*nexus_info+i);
286 if (i < (ssize_t) number_threads)
287 nexus_info[i]->virtual_nexus=(*nexus_info+number_threads+i);
288 nexus_info[i]->signature=MagickCoreSignature;
321MagickExport
void *AcquirePixelCachePixels(
const Image *image,
size_t *length,
322 ExceptionInfo *exception)
325 *magick_restrict cache_info;
327 assert(image != (
const Image *) NULL);
328 assert(image->signature == MagickCoreSignature);
329 assert(exception != (ExceptionInfo *) NULL);
330 assert(exception->signature == MagickCoreSignature);
331 assert(image->cache != (Cache) NULL);
333 cache_info=(CacheInfo *) image->cache;
334 assert(cache_info->signature == MagickCoreSignature);
336 if ((cache_info->type != MemoryCache) && (cache_info->type != MapCache))
337 return((
void *) NULL);
338 *length=(size_t) cache_info->length;
339 return(cache_info->pixels);
360MagickPrivate MagickBooleanType CacheComponentGenesis(
void)
363 cache_semaphore=AcquireSemaphoreInfo();
385MagickPrivate
void CacheComponentTerminus(
void)
389 ActivateSemaphoreInfo(&cache_semaphore);
390 RelinquishSemaphoreInfo(&cache_semaphore);
423static MagickBooleanType ClipPixelCacheNexus(Image *image,
424 NexusInfo *nexus_info,ExceptionInfo *exception)
427 *magick_restrict cache_info;
439 if (IsEventLogging() != MagickFalse)
440 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
441 if ((image->channels & WriteMaskChannel) == 0)
443 if ((nexus_info->region.width == 0) || (nexus_info->region.height == 0))
445 cache_info=(CacheInfo *) image->cache;
446 if (cache_info == (CacheInfo *) NULL)
448 p=GetAuthenticPixelCacheNexus(image,nexus_info->region.x,nexus_info->region.y,
449 nexus_info->region.width,nexus_info->region.height,
450 nexus_info->virtual_nexus,exception);
451 q=nexus_info->pixels;
452 if ((p == (Quantum *) NULL) || (q == (Quantum *) NULL))
454 for (y=0; y < (ssize_t) nexus_info->region.height; y++)
459 for (x=0; x < (ssize_t) nexus_info->region.width; x++)
467 mask=(double) GetPixelWriteMask(image,p);
468 if (fabs(mask) >= MagickEpsilon)
477 src_alpha=GetPixelAlpha(image,p);
478 mask_alpha=QuantumScale*mask*(double) src_alpha;
479 dst_alpha=(double) GetPixelAlpha(image,q);
480 for (i=0; i < (ssize_t) image->number_channels; i++)
485 PixelChannel channel = GetPixelChannelChannel(image,i);
486 if (channel == AlphaPixelChannel)
488 traits=GetPixelChannelTraits(image,channel);
489 if ((traits & UpdatePixelTrait) == 0)
491 q[i]=ClampToQuantum(MagickOver_((
double) p[i],mask_alpha,
492 (
double) q[i],dst_alpha));
494 SetPixelAlpha(image,src_alpha,q);
496 p+=(ptrdiff_t) GetPixelChannels(image);
497 q+=(ptrdiff_t) GetPixelChannels(image);
525MagickPrivate Cache ClonePixelCache(
const Cache cache)
528 *magick_restrict clone_info;
531 *magick_restrict cache_info;
533 assert(cache != NULL);
534 cache_info=(
const CacheInfo *) cache;
535 assert(cache_info->signature == MagickCoreSignature);
536 if (IsEventLogging() != MagickFalse)
537 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
538 cache_info->filename);
539 clone_info=(CacheInfo *) AcquirePixelCache(cache_info->number_threads);
540 clone_info->virtual_pixel_method=cache_info->virtual_pixel_method;
541 return((Cache ) clone_info);
569MagickPrivate
void ClonePixelCacheMethods(Cache clone,
const Cache cache)
572 *magick_restrict cache_info,
573 *magick_restrict source_info;
575 assert(clone != (Cache) NULL);
576 source_info=(CacheInfo *) clone;
577 assert(source_info->signature == MagickCoreSignature);
578 if (IsEventLogging() != MagickFalse)
579 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
580 source_info->filename);
581 assert(cache != (Cache) NULL);
582 cache_info=(CacheInfo *) cache;
583 assert(cache_info->signature == MagickCoreSignature);
584 source_info->methods=cache_info->methods;
616static MagickBooleanType ClonePixelCacheOnDisk(
617 CacheInfo *magick_restrict cache_info,CacheInfo *magick_restrict clone_info,
618 ExceptionInfo *exception)
638 if ((OpenPixelCacheOnDisk(cache_info,ReadMode,exception) == MagickFalse) ||
639 (OpenPixelCacheOnDisk(clone_info,IOMode,exception) == MagickFalse))
641 if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||
642 (lseek(clone_info->file,0,SEEK_SET) < 0))
644 quantum=(size_t) MagickMaxBufferExtent;
645 if ((fstat(cache_info->file,&file_stats) == 0) && (file_stats.st_size > 0))
647#if defined(MAGICKCORE_HAVE_LINUX_SENDFILE)
648 if (cache_info->length < 0x7ffff000)
652 count=sendfile(clone_info->file,cache_info->file,(off_t *) NULL,
653 (
size_t) cache_info->length);
654 }
while ((count < 0) && (errno == EINTR));
655 if (count == (ssize_t) cache_info->length)
659 if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||
660 (lseek(clone_info->file,0,SEEK_SET) < 0))
664 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
666 buffer=(
unsigned char *) AcquireQuantumMemory(quantum,
sizeof(*buffer));
667 if (buffer == (
unsigned char *) NULL)
670 while (extent < cache_info->length)
675 length=(size_t) MagickMin((MagickSizeType) quantum,cache_info->length-
677 count=MagickRead(cache_info->file,buffer,length);
680 buffer=(
unsigned char *) RelinquishMagickMemory(buffer);
688 while (offset < count)
690 number_bytes=MagickWrite(clone_info->file,buffer+offset,(
size_t) (count-
692 if (number_bytes <= 0)
694 buffer=(
unsigned char *) RelinquishMagickMemory(buffer);
697 offset+=number_bytes;
699 extent+=(MagickSizeType) offset;
702 buffer=(
unsigned char *) RelinquishMagickMemory(buffer);
703 return(extent == cache_info->length ? MagickTrue : MagickFalse);
706#if defined(MAGICKCORE_OPENMP_SUPPORT)
707static inline int GetCacheNumberThreads(
const CacheInfo *source,
708 const CacheInfo *destination,
const size_t chunk,
const int factor)
711 max_threads = (size_t) GetMagickResourceLimit(ThreadResource),
712 number_threads = 1UL,
713 workload_factor = 64UL << factor;
718 number_threads=(chunk <= workload_factor) ? 1UL :
719 (chunk >= (workload_factor << 6)) ? max_threads :
720 1UL+(chunk-workload_factor)*(max_threads-1L)/(((workload_factor << 6))-1L);
724 if (((source->type != MemoryCache) && (source->type != MapCache)) ||
725 ((destination->type != MemoryCache) && (destination->type != MapCache)))
726 number_threads=MagickMin(number_threads,4);
727 if (number_threads == 0)
729 return((
int) number_threads);
733static MagickBooleanType ClonePixelCacheRepository(
734 CacheInfo *magick_restrict clone_info,CacheInfo *magick_restrict cache_info,
735 ExceptionInfo *exception)
737#define cache_number_threads(source,destination,chunk,factor) \
738 num_threads(GetCacheNumberThreads((source),(destination),(chunk),(factor)))
745 **magick_restrict cache_nexus,
746 **magick_restrict clone_nexus;
754 assert(cache_info != (CacheInfo *) NULL);
755 assert(clone_info != (CacheInfo *) NULL);
756 assert(exception != (ExceptionInfo *) NULL);
757 if (cache_info->type == PingCache)
759 length=cache_info->number_channels*
sizeof(*cache_info->channel_map);
760 if ((cache_info->storage_class == clone_info->storage_class) &&
761 (cache_info->colorspace == clone_info->colorspace) &&
762 (cache_info->alpha_trait == clone_info->alpha_trait) &&
763 (cache_info->channels == clone_info->channels) &&
764 (cache_info->columns == clone_info->columns) &&
765 (cache_info->rows == clone_info->rows) &&
766 (cache_info->number_channels == clone_info->number_channels) &&
767 (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) &&
768 (cache_info->metacontent_extent == clone_info->metacontent_extent))
773 if (((cache_info->type == MemoryCache) ||
774 (cache_info->type == MapCache)) &&
775 ((clone_info->type == MemoryCache) || (clone_info->type == MapCache)))
777 (void) memcpy(clone_info->pixels,cache_info->pixels,
778 cache_info->number_channels*cache_info->columns*cache_info->rows*
779 sizeof(*cache_info->pixels));
780 if ((cache_info->metacontent_extent != 0) &&
781 (clone_info->metacontent_extent != 0))
782 (void) memcpy(clone_info->metacontent,cache_info->metacontent,
783 cache_info->columns*cache_info->rows*
784 clone_info->metacontent_extent*
sizeof(
unsigned char));
787 if ((cache_info->type == DiskCache) && (clone_info->type == DiskCache))
788 return(ClonePixelCacheOnDisk(cache_info,clone_info,exception));
793 cache_nexus=AcquirePixelCacheNexus(cache_info->number_threads);
794 clone_nexus=AcquirePixelCacheNexus(clone_info->number_threads);
795 length=cache_info->number_channels*
sizeof(*cache_info->channel_map);
796 optimize=(cache_info->number_channels == clone_info->number_channels) &&
797 (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) ?
798 MagickTrue : MagickFalse;
799 length=(size_t) MagickMin(cache_info->number_channels*cache_info->columns,
800 clone_info->number_channels*clone_info->columns);
802#if defined(MAGICKCORE_OPENMP_SUPPORT)
803 #pragma omp parallel for schedule(static) shared(status) \
804 cache_number_threads(cache_info,clone_info,cache_info->rows,3)
806 for (y=0; y < (ssize_t) cache_info->rows; y++)
809 id = GetOpenMPThreadId();
817 if (status == MagickFalse)
819 if (y >= (ssize_t) clone_info->rows)
821 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,
822 cache_info->columns,1,MagickFalse,cache_nexus[
id],exception);
823 if (pixels == (Quantum *) NULL)
828 if (ReadPixelCachePixels(cache_info,cache_nexus[
id],exception) == MagickFalse)
833 pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,
834 clone_info->columns,1,MagickTrue,clone_nexus[
id],exception);
835 if (pixels == (Quantum *) NULL)
840 (void) memset(clone_nexus[
id]->pixels,0,(
size_t) clone_nexus[
id]->length);
841 if (optimize != MagickFalse)
842 (void) memcpy(clone_nexus[
id]->pixels,cache_nexus[
id]->pixels,length*
855 p=cache_nexus[id]->pixels;
856 q=clone_nexus[id]->pixels;
857 for (x=0; x < (ssize_t) cache_info->columns; x++)
862 if (x == (ssize_t) clone_info->columns)
864 for (i=0; i < (ssize_t) clone_info->number_channels; i++)
872 channel=clone_info->channel_map[i].channel;
873 traits=cache_info->channel_map[channel].traits;
874 if (traits != UndefinedPixelTrait)
875 *q=(*(p+cache_info->channel_map[channel].offset));
878 p+=(ptrdiff_t) cache_info->number_channels;
881 if (WritePixelCachePixels(clone_info,clone_nexus[
id],exception) == MagickFalse)
884 if ((status != MagickFalse) && (cache_info->metacontent_extent != 0) &&
885 (clone_info->metacontent_extent != 0))
894 columns=(size_t) MagickMin(cache_info->columns,clone_info->columns);
895 metacontent_length=(size_t) MagickMin(cache_info->metacontent_extent,
896 clone_info->metacontent_extent);
897#if defined(MAGICKCORE_OPENMP_SUPPORT)
898 #pragma omp parallel for schedule(static) shared(status) \
899 cache_number_threads(cache_info,clone_info,cache_info->rows,3)
901 for (y=0; y < (ssize_t) cache_info->rows; y++)
904 id = GetOpenMPThreadId();
909 if (status == MagickFalse)
911 if (y >= (ssize_t) clone_info->rows)
913 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,
914 cache_info->columns,1,MagickFalse,cache_nexus[
id],exception);
915 if (pixels == (Quantum *) NULL)
920 if (ReadPixelCacheMetacontent(cache_info,cache_nexus[
id],exception) == MagickFalse)
925 pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,
926 clone_info->columns,1,MagickTrue,clone_nexus[
id],exception);
927 if (pixels == (Quantum *) NULL)
932 if ((clone_nexus[
id]->metacontent != (
void *) NULL) &&
933 (cache_nexus[
id]->metacontent != (
void *) NULL))
935 if ((cache_info->metacontent_extent == clone_info->metacontent_extent) &&
936 (cache_info->columns == clone_info->columns))
937 (void) memcpy(clone_nexus[
id]->metacontent,
938 cache_nexus[
id]->metacontent,columns*metacontent_length);
950 (void) memset(clone_nexus[
id]->metacontent,0,
951 clone_info->columns*clone_info->metacontent_extent);
952 p=(
const unsigned char *) cache_nexus[
id]->metacontent;
953 q=(
unsigned char *) clone_nexus[
id]->metacontent;
954 for (x=0; x < (ssize_t) columns; x++)
956 (void) memcpy(q,p,metacontent_length);
957 p+=(ptrdiff_t) cache_info->metacontent_extent;
958 q+=(ptrdiff_t) clone_info->metacontent_extent;
962 if (WritePixelCacheMetacontent(clone_info,clone_nexus[
id],exception) == MagickFalse)
966 clone_nexus=DestroyPixelCacheNexus(clone_nexus,clone_info->number_threads);
967 cache_nexus=DestroyPixelCacheNexus(cache_nexus,cache_info->number_threads);
968 if (cache_info->debug != MagickFalse)
971 message[MagickPathExtent];
973 (void) FormatLocaleString(message,MagickPathExtent,
"%s => %s",
974 CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) cache_info->type),
975 CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) clone_info->type));
976 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",message);
1003static void DestroyImagePixelCache(Image *image)
1005 assert(image != (Image *) NULL);
1006 assert(image->signature == MagickCoreSignature);
1007 if (IsEventLogging() != MagickFalse)
1008 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1009 if (image->cache != (
void *) NULL)
1010 image->cache=DestroyPixelCache(image->cache);
1035MagickExport
void DestroyImagePixels(Image *image)
1038 *magick_restrict cache_info;
1040 assert(image != (
const Image *) NULL);
1041 assert(image->signature == MagickCoreSignature);
1042 if (IsEventLogging() != MagickFalse)
1043 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1044 if (image->cache == (Cache) NULL)
1046 cache_info=(CacheInfo *) image->cache;
1047 assert(cache_info->signature == MagickCoreSignature);
1048 if (cache_info->methods.destroy_pixel_handler != (DestroyPixelHandler) NULL)
1050 cache_info->methods.destroy_pixel_handler(image);
1053 image->cache=DestroyPixelCache(image->cache);
1079static MagickBooleanType ClosePixelCacheOnDisk(CacheInfo *cache_info)
1085 if (cache_info->file != -1)
1087 status=close_utf8(cache_info->file);
1088 cache_info->file=(-1);
1089 RelinquishMagickResource(FileResource,1);
1091 return(status == -1 ? MagickFalse : MagickTrue);
1094static inline void RelinquishPixelCachePixels(CacheInfo *cache_info)
1096 switch (cache_info->type)
1100 (void) ShredMagickMemory(cache_info->pixels,(
size_t) cache_info->length);
1101#if defined(MAGICKCORE_OPENCL_SUPPORT)
1102 if (cache_info->opencl != (MagickCLCacheInfo) NULL)
1104 cache_info->opencl=RelinquishMagickCLCacheInfo(cache_info->opencl,
1106 cache_info->pixels=(Quantum *) NULL;
1110 if (cache_info->mapped == MagickFalse)
1111 cache_info->pixels=(Quantum *) RelinquishAlignedMemory(
1112 cache_info->pixels);
1115 (void) UnmapBlob(cache_info->pixels,(
size_t) cache_info->length);
1116 cache_info->pixels=(Quantum *) NULL;
1118 RelinquishMagickResource(MemoryResource,cache_info->length);
1123 (void) UnmapBlob(cache_info->pixels,(
size_t) cache_info->length);
1124 cache_info->pixels=(Quantum *) NULL;
1125 if ((cache_info->mode != ReadMode) && (cache_info->mode != PersistMode))
1126 (void) RelinquishUniqueFileResource(cache_info->cache_filename);
1127 *cache_info->cache_filename=
'\0';
1128 RelinquishMagickResource(MapResource,cache_info->length);
1133 if (cache_info->file != -1)
1134 (void) ClosePixelCacheOnDisk(cache_info);
1135 if ((cache_info->mode != ReadMode) && (cache_info->mode != PersistMode))
1136 (void) RelinquishUniqueFileResource(cache_info->cache_filename);
1137 *cache_info->cache_filename=
'\0';
1138 RelinquishMagickResource(DiskResource,cache_info->length);
1141 case DistributedCache:
1143 *cache_info->cache_filename=
'\0';
1144 (void) RelinquishDistributePixelCache((DistributeCacheInfo *)
1145 cache_info->server_info);
1151 cache_info->type=UndefinedCache;
1152 cache_info->mapped=MagickFalse;
1153 cache_info->metacontent=(
void *) NULL;
1156MagickPrivate Cache DestroyPixelCache(Cache cache)
1159 *magick_restrict cache_info;
1161 assert(cache != (Cache) NULL);
1162 cache_info=(CacheInfo *) cache;
1163 assert(cache_info->signature == MagickCoreSignature);
1164 if (IsEventLogging() != MagickFalse)
1165 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1166 cache_info->filename);
1167 LockSemaphoreInfo(cache_info->semaphore);
1168 cache_info->reference_count--;
1169 if (cache_info->reference_count != 0)
1171 UnlockSemaphoreInfo(cache_info->semaphore);
1172 return((Cache) NULL);
1174 UnlockSemaphoreInfo(cache_info->semaphore);
1175 if (cache_info->debug != MagickFalse)
1178 message[MagickPathExtent];
1180 (void) FormatLocaleString(message,MagickPathExtent,
"destroy %s",
1181 cache_info->filename);
1182 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",message);
1184 RelinquishPixelCachePixels(cache_info);
1185 if (cache_info->server_info != (DistributeCacheInfo *) NULL)
1186 cache_info->server_info=DestroyDistributeCacheInfo((DistributeCacheInfo *)
1187 cache_info->server_info);
1188 if (cache_info->nexus_info != (NexusInfo **) NULL)
1189 cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
1190 cache_info->number_threads);
1191 if (cache_info->random_info != (RandomInfo *) NULL)
1192 cache_info->random_info=DestroyRandomInfo(cache_info->random_info);
1194 RelinquishSemaphoreInfo(&cache_info->file_semaphore);
1196 RelinquishSemaphoreInfo(&cache_info->semaphore);
1197 cache_info->signature=(~MagickCoreSignature);
1198 cache_info=(CacheInfo *) RelinquishAlignedMemory(cache_info);
1229static inline void RelinquishCacheNexusPixels(NexusInfo *nexus_info)
1231 if (nexus_info->mapped == MagickFalse)
1232 (void) RelinquishAlignedMemory(nexus_info->cache);
1234 (
void) UnmapBlob(nexus_info->cache,(
size_t) nexus_info->length);
1235 nexus_info->cache=(Quantum *) NULL;
1236 nexus_info->pixels=(Quantum *) NULL;
1237 nexus_info->metacontent=(
void *) NULL;
1238 nexus_info->length=0;
1239 nexus_info->mapped=MagickFalse;
1242MagickPrivate NexusInfo **DestroyPixelCacheNexus(NexusInfo **nexus_info,
1243 const size_t number_threads)
1248 assert(nexus_info != (NexusInfo **) NULL);
1249 for (i=0; i < (ssize_t) (2*number_threads); i++)
1251 if (nexus_info[i]->cache != (Quantum *) NULL)
1252 RelinquishCacheNexusPixels(nexus_info[i]);
1253 nexus_info[i]->signature=(~MagickCoreSignature);
1255 *nexus_info=(NexusInfo *) RelinquishMagickMemory(*nexus_info);
1256 nexus_info=(NexusInfo **) RelinquishAlignedMemory(nexus_info);
1285MagickExport
void *GetAuthenticMetacontent(
const Image *image)
1288 *magick_restrict cache_info;
1291 id = GetOpenMPThreadId();
1293 assert(image != (
const Image *) NULL);
1294 assert(image->signature == MagickCoreSignature);
1295 assert(image->cache != (Cache) NULL);
1296 cache_info=(CacheInfo *) image->cache;
1297 assert(cache_info->signature == MagickCoreSignature);
1298 if (cache_info->methods.get_authentic_metacontent_from_handler !=
1299 (GetAuthenticMetacontentFromHandler) NULL)
1304 metacontent=cache_info->methods.
1305 get_authentic_metacontent_from_handler(image);
1306 return(metacontent);
1308 assert(
id < (
int) cache_info->number_threads);
1309 return(cache_info->nexus_info[
id]->metacontent);
1336static void *GetAuthenticMetacontentFromCache(
const Image *image)
1339 *magick_restrict cache_info;
1342 id = GetOpenMPThreadId();
1344 assert(image != (
const Image *) NULL);
1345 assert(image->signature == MagickCoreSignature);
1346 assert(image->cache != (Cache) NULL);
1347 cache_info=(CacheInfo *) image->cache;
1348 assert(cache_info->signature == MagickCoreSignature);
1349 assert(
id < (
int) cache_info->number_threads);
1350 return(cache_info->nexus_info[
id]->metacontent);
1353#if defined(MAGICKCORE_OPENCL_SUPPORT)
1382MagickPrivate cl_mem GetAuthenticOpenCLBuffer(
const Image *image,
1383 MagickCLDevice device,ExceptionInfo *exception)
1386 *magick_restrict cache_info;
1391 assert(image != (
const Image *) NULL);
1392 assert(device != (
const MagickCLDevice) NULL);
1393 cache_info=(CacheInfo *) image->cache;
1394 if ((cache_info->type == UndefinedCache) || (cache_info->reference_count > 1))
1396 if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
1397 return((cl_mem) NULL);
1398 cache_info=(CacheInfo *) image->cache;
1400 if ((cache_info->type != MemoryCache) || (cache_info->mapped != MagickFalse))
1401 return((cl_mem) NULL);
1402 LockSemaphoreInfo(cache_info->semaphore);
1403 if ((cache_info->opencl != (MagickCLCacheInfo) NULL) &&
1404 (cache_info->opencl->device->context != device->context))
1405 cache_info->opencl=CopyMagickCLCacheInfo(cache_info->opencl);
1406 if (cache_info->opencl == (MagickCLCacheInfo) NULL)
1408 assert(cache_info->pixels != (Quantum *) NULL);
1409 cache_info->opencl=AcquireMagickCLCacheInfo(device,cache_info->pixels,
1410 cache_info->length);
1412 buffer=(cl_mem) NULL;
1413 if (cache_info->opencl != (MagickCLCacheInfo) NULL)
1415 assert(cache_info->opencl->pixels == cache_info->pixels);
1416 RetainOpenCLMemObject(cache_info->opencl->buffer);
1417 buffer=cache_info->opencl->buffer;
1419 UnlockSemaphoreInfo(cache_info->semaphore);
1459MagickPrivate Quantum *GetAuthenticPixelCacheNexus(Image *image,
const ssize_t x,
1460 const ssize_t y,
const size_t columns,
const size_t rows,NexusInfo *nexus_info,
1461 ExceptionInfo *exception)
1464 *magick_restrict cache_info;
1467 *magick_restrict pixels;
1472 assert(image != (Image *) NULL);
1473 assert(image->signature == MagickCoreSignature);
1474 pixels=QueueAuthenticPixelCacheNexusInternal(image,x,y,columns,rows,
1475 MagickTrue,&nexus_info,exception);
1476 if ((pixels == (Quantum *) NULL) || (nexus_info == (NexusInfo *) NULL))
1477 return((Quantum *) NULL);
1478 cache_info=(CacheInfo *) image->cache;
1479 assert(cache_info->signature == MagickCoreSignature);
1480 assert(nexus_info->signature == MagickCoreSignature);
1481 if (nexus_info->authentic_pixel_cache != MagickFalse)
1483 if (ReadPixelCachePixels(cache_info,nexus_info,exception) == MagickFalse)
1484 return((Quantum *) NULL);
1485 if (cache_info->metacontent_extent != 0)
1486 if (ReadPixelCacheMetacontent(cache_info,nexus_info,exception) == MagickFalse)
1487 return((Quantum *) NULL);
1514static Quantum *GetAuthenticPixelsFromCache(
const Image *image)
1517 *magick_restrict cache_info;
1520 id = GetOpenMPThreadId();
1522 assert(image != (
const Image *) NULL);
1523 assert(image->signature == MagickCoreSignature);
1524 assert(image->cache != (Cache) NULL);
1525 cache_info=(CacheInfo *) image->cache;
1526 assert(cache_info->signature == MagickCoreSignature);
1527 assert(
id < (
int) cache_info->number_threads);
1528 return(cache_info->nexus_info[
id]->pixels);
1555MagickExport Quantum *GetAuthenticPixelQueue(
const Image *image)
1558 *magick_restrict cache_info;
1561 id = GetOpenMPThreadId();
1563 assert(image != (
const Image *) NULL);
1564 assert(image->signature == MagickCoreSignature);
1565 assert(image->cache != (Cache) NULL);
1566 cache_info=(CacheInfo *) image->cache;
1567 assert(cache_info->signature == MagickCoreSignature);
1568 if (cache_info->methods.get_authentic_pixels_from_handler !=
1569 (GetAuthenticPixelsFromHandler) NULL)
1570 return(cache_info->methods.get_authentic_pixels_from_handler(image));
1571 assert(
id < (
int) cache_info->number_threads);
1572 return(cache_info->nexus_info[
id]->pixels);
1620MagickExport Quantum *GetAuthenticPixels(Image *image,
const ssize_t x,
1621 const ssize_t y,
const size_t columns,
const size_t rows,
1622 ExceptionInfo *exception)
1625 *magick_restrict cache_info;
1628 id = GetOpenMPThreadId();
1633 assert(image != (Image *) NULL);
1634 assert(image->signature == MagickCoreSignature);
1635 assert(image->cache != (Cache) NULL);
1636 cache_info=(CacheInfo *) image->cache;
1637 assert(cache_info->signature == MagickCoreSignature);
1638 if (cache_info->methods.get_authentic_pixels_handler !=
1639 (GetAuthenticPixelsHandler) NULL)
1641 pixels=cache_info->methods.get_authentic_pixels_handler(image,x,y,columns,
1645 assert(
id < (
int) cache_info->number_threads);
1646 pixels=GetAuthenticPixelCacheNexus(image,x,y,columns,rows,
1647 cache_info->nexus_info[
id],exception);
1682static Quantum *GetAuthenticPixelsCache(Image *image,
const ssize_t x,
1683 const ssize_t y,
const size_t columns,
const size_t rows,
1684 ExceptionInfo *exception)
1687 *magick_restrict cache_info;
1690 id = GetOpenMPThreadId();
1693 *magick_restrict pixels;
1695 assert(image != (
const Image *) NULL);
1696 assert(image->signature == MagickCoreSignature);
1697 assert(image->cache != (Cache) NULL);
1698 cache_info=(CacheInfo *) image->cache;
1699 if (cache_info == (Cache) NULL)
1700 return((Quantum *) NULL);
1701 assert(cache_info->signature == MagickCoreSignature);
1702 assert(
id < (
int) cache_info->number_threads);
1703 pixels=GetAuthenticPixelCacheNexus(image,x,y,columns,rows,
1704 cache_info->nexus_info[
id],exception);
1731MagickExport MagickSizeType GetImageExtent(
const Image *image)
1734 *magick_restrict cache_info;
1737 id = GetOpenMPThreadId();
1739 assert(image != (Image *) NULL);
1740 assert(image->signature == MagickCoreSignature);
1741 if (IsEventLogging() != MagickFalse)
1742 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1743 assert(image->cache != (Cache) NULL);
1744 cache_info=(CacheInfo *) image->cache;
1745 assert(cache_info->signature == MagickCoreSignature);
1746 assert(
id < (
int) cache_info->number_threads);
1747 return(GetPixelCacheNexusExtent(cache_info,cache_info->nexus_info[
id]));
1780static MagickBooleanType GetDynamicThrottlePolicy(
void)
1782 static MagickBooleanType
1783 check_policy = MagickTrue;
1785 static MagickBooleanType
1786 dynamic_throttle = MagickFalse;
1788 if (check_policy != MagickFalse)
1790 char *value = GetPolicyValue(
"resource:dynamic-throttle");
1791 if (value != (
char *) NULL)
1793 dynamic_throttle=IsStringTrue(value);
1794 value=DestroyString(value);
1796 check_policy=MagickFalse;
1798 return(dynamic_throttle);
1801static inline MagickBooleanType ValidatePixelCacheMorphology(
1802 const Image *magick_restrict image)
1805 *magick_restrict cache_info;
1807 const PixelChannelMap
1814 cache_info=(CacheInfo *) image->cache;
1815 p=image->channel_map;
1816 q=cache_info->channel_map;
1817 if ((image->storage_class != cache_info->storage_class) ||
1818 (image->colorspace != cache_info->colorspace) ||
1819 (image->alpha_trait != cache_info->alpha_trait) ||
1820 (image->channels != cache_info->channels) ||
1821 (image->columns != cache_info->columns) ||
1822 (image->rows != cache_info->rows) ||
1823 (image->number_channels != cache_info->number_channels) ||
1824 (memcmp(p,q,image->number_channels*
sizeof(*p)) != 0) ||
1825 (image->metacontent_extent != cache_info->metacontent_extent) ||
1826 (cache_info->nexus_info == (NexusInfo **) NULL))
1827 return(MagickFalse);
1831static Cache GetImagePixelCache(Image *image,
const MagickBooleanType clone,
1832 ExceptionInfo *exception)
1835 *magick_restrict cache_info;
1839 status = MagickTrue;
1841 static MagickSizeType
1842 cpu_throttle = MagickResourceInfinity,
1845 if (IsImageTTLExpired(image) != MagickFalse)
1850 (void) ThrowMagickException(exception,GetMagickModule(),
1851 ResourceLimitError,
"TimeLimitExceeded",
"`%s'",image->filename);
1852 return((Cache) NULL);
1854 if (cpu_throttle == MagickResourceInfinity)
1855 cpu_throttle=GetMagickResourceLimit(ThrottleResource);
1856 if ((GetDynamicThrottlePolicy() != MagickFalse) && ((cycles % 65536) == 0))
1869#if defined(MAGICKCORE_HAVE_GETLOADAVG)
1870 if (getloadavg(&load_average,1) != 1)
1873 load=MagickMax(load_average-(
double) GetOpenMPMaximumThreads(),0.0);
1874 cpu_throttle=(MagickSizeType) (max_delay*(1.0-exp(-sensitivity*load)));
1876 if ((cpu_throttle != 0) && ((cycles % 4096) == 0))
1877 MagickDelay(cpu_throttle);
1879 LockSemaphoreInfo(image->semaphore);
1880 assert(image->cache != (Cache) NULL);
1881 cache_info=(CacheInfo *) image->cache;
1882#if defined(MAGICKCORE_OPENCL_SUPPORT)
1883 CopyOpenCLBuffer(cache_info);
1885 destroy=MagickFalse;
1886 if ((cache_info->reference_count > 1) || (cache_info->mode == ReadMode))
1888 LockSemaphoreInfo(cache_info->semaphore);
1889 if ((cache_info->reference_count > 1) || (cache_info->mode == ReadMode))
1900 clone_image=(*image);
1901 clone_image.semaphore=AcquireSemaphoreInfo();
1902 clone_image.reference_count=1;
1903 clone_image.cache=ClonePixelCache(cache_info);
1904 clone_info=(CacheInfo *) clone_image.cache;
1905 status=OpenPixelCache(&clone_image,IOMode,exception);
1906 if (status == MagickFalse)
1907 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
1910 if (clone != MagickFalse)
1911 status=ClonePixelCacheRepository(clone_info,cache_info,
1913 if (status == MagickFalse)
1914 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
1918 image->cache=clone_info;
1921 RelinquishSemaphoreInfo(&clone_image.semaphore);
1923 UnlockSemaphoreInfo(cache_info->semaphore);
1925 if (destroy != MagickFalse)
1926 cache_info=(CacheInfo *) DestroyPixelCache(cache_info);
1927 if (status != MagickFalse)
1932 if (ValidatePixelCacheMorphology(image) == MagickFalse)
1934 image->type=UndefinedType;
1935 status=OpenPixelCache(image,IOMode,exception);
1936 cache_info=(CacheInfo *) image->cache;
1937 if (cache_info->file != -1)
1938 (void) ClosePixelCacheOnDisk(cache_info);
1941 UnlockSemaphoreInfo(image->semaphore);
1942 if (status == MagickFalse)
1943 return((Cache) NULL);
1944 return(image->cache);
1970MagickExport CacheType GetImagePixelCacheType(
const Image *image)
1973 *magick_restrict cache_info;
1975 assert(image != (Image *) NULL);
1976 assert(image->signature == MagickCoreSignature);
1977 assert(image->cache != (Cache) NULL);
1978 cache_info=(CacheInfo *) image->cache;
1979 assert(cache_info->signature == MagickCoreSignature);
1980 return(cache_info->type);
2014static inline MagickBooleanType CopyPixel(
const Image *image,
2015 const Quantum *source,Quantum *destination)
2020 if (source == (
const Quantum *) NULL)
2022 destination[RedPixelChannel]=ClampToQuantum(image->background_color.red);
2023 destination[GreenPixelChannel]=ClampToQuantum(
2024 image->background_color.green);
2025 destination[BluePixelChannel]=ClampToQuantum(
2026 image->background_color.blue);
2027 destination[BlackPixelChannel]=ClampToQuantum(
2028 image->background_color.black);
2029 destination[AlphaPixelChannel]=ClampToQuantum(
2030 image->background_color.alpha);
2031 return(MagickFalse);
2033 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
2035 PixelChannel channel = GetPixelChannelChannel(image,i);
2036 destination[channel]=source[i];
2041MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
2042 const ssize_t x,
const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
2045 *magick_restrict cache_info;
2050 assert(image != (Image *) NULL);
2051 assert(image->signature == MagickCoreSignature);
2052 assert(image->cache != (Cache) NULL);
2053 cache_info=(CacheInfo *) image->cache;
2054 assert(cache_info->signature == MagickCoreSignature);
2055 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
2056 if (cache_info->methods.get_one_authentic_pixel_from_handler != (GetOneAuthenticPixelFromHandler) NULL)
2057 return(cache_info->methods.get_one_authentic_pixel_from_handler(image,x,y,pixel,exception));
2058 q=GetAuthenticPixelsCache(image,x,y,1UL,1UL,exception);
2059 return(CopyPixel(image,q,pixel));
2093static MagickBooleanType GetOneAuthenticPixelFromCache(Image *image,
2094 const ssize_t x,
const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
2097 *magick_restrict cache_info;
2100 id = GetOpenMPThreadId();
2105 assert(image != (
const Image *) NULL);
2106 assert(image->signature == MagickCoreSignature);
2107 assert(image->cache != (Cache) NULL);
2108 cache_info=(CacheInfo *) image->cache;
2109 assert(cache_info->signature == MagickCoreSignature);
2110 assert(
id < (
int) cache_info->number_threads);
2111 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
2112 q=GetAuthenticPixelCacheNexus(image,x,y,1UL,1UL,cache_info->nexus_info[
id],
2114 return(CopyPixel(image,q,pixel));
2148MagickExport MagickBooleanType GetOneVirtualPixel(
const Image *image,
2149 const ssize_t x,
const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
2152 *magick_restrict cache_info;
2155 id = GetOpenMPThreadId();
2160 assert(image != (
const Image *) NULL);
2161 assert(image->signature == MagickCoreSignature);
2162 assert(image->cache != (Cache) NULL);
2163 cache_info=(CacheInfo *) image->cache;
2164 assert(cache_info->signature == MagickCoreSignature);
2165 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
2166 if (cache_info->methods.get_one_virtual_pixel_from_handler !=
2167 (GetOneVirtualPixelFromHandler) NULL)
2168 return(cache_info->methods.get_one_virtual_pixel_from_handler(image,
2169 GetPixelCacheVirtualMethod(image),x,y,pixel,exception));
2170 assert(
id < (
int) cache_info->number_threads);
2171 p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
2172 1UL,1UL,cache_info->nexus_info[
id],exception);
2173 return(CopyPixel(image,p,pixel));
2210static MagickBooleanType GetOneVirtualPixelFromCache(
const Image *image,
2211 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
2212 Quantum *pixel,ExceptionInfo *exception)
2215 *magick_restrict cache_info;
2218 id = GetOpenMPThreadId();
2223 assert(image != (
const Image *) NULL);
2224 assert(image->signature == MagickCoreSignature);
2225 assert(image->cache != (Cache) NULL);
2226 cache_info=(CacheInfo *) image->cache;
2227 assert(cache_info->signature == MagickCoreSignature);
2228 assert(
id < (
int) cache_info->number_threads);
2229 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
2230 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
2231 cache_info->nexus_info[
id],exception);
2232 return(CopyPixel(image,p,pixel));
2269MagickExport MagickBooleanType GetOneVirtualPixelInfo(
const Image *image,
2270 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
2271 PixelInfo *pixel,ExceptionInfo *exception)
2274 *magick_restrict cache_info;
2277 id = GetOpenMPThreadId();
2282 assert(image != (
const Image *) NULL);
2283 assert(image->signature == MagickCoreSignature);
2284 assert(image->cache != (Cache) NULL);
2285 cache_info=(CacheInfo *) image->cache;
2286 assert(cache_info->signature == MagickCoreSignature);
2287 assert(
id < (
int) cache_info->number_threads);
2288 GetPixelInfo(image,pixel);
2289 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
2290 cache_info->nexus_info[
id],exception);
2291 if (p == (
const Quantum *) NULL)
2292 return(MagickFalse);
2293 GetPixelInfoPixel(image,p,pixel);
2319MagickPrivate ColorspaceType GetPixelCacheColorspace(
const Cache cache)
2322 *magick_restrict cache_info;
2324 assert(cache != (Cache) NULL);
2325 cache_info=(CacheInfo *) cache;
2326 assert(cache_info->signature == MagickCoreSignature);
2327 if (IsEventLogging() != MagickFalse)
2328 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2329 cache_info->filename);
2330 return(cache_info->colorspace);
2356MagickExport
const char *GetPixelCacheFilename(
const Image *image)
2359 *magick_restrict cache_info;
2361 assert(image != (
const Image *) NULL);
2362 assert(image->signature == MagickCoreSignature);
2363 assert(image->cache != (Cache) NULL);
2364 cache_info=(CacheInfo *) image->cache;
2365 assert(cache_info->signature == MagickCoreSignature);
2366 return(cache_info->cache_filename);
2391MagickPrivate
void GetPixelCacheMethods(CacheMethods *cache_methods)
2393 assert(cache_methods != (CacheMethods *) NULL);
2394 (void) memset(cache_methods,0,
sizeof(*cache_methods));
2395 cache_methods->get_virtual_pixel_handler=GetVirtualPixelCache;
2396 cache_methods->get_virtual_pixels_handler=GetVirtualPixelsCache;
2397 cache_methods->get_virtual_metacontent_from_handler=
2398 GetVirtualMetacontentFromCache;
2399 cache_methods->get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromCache;
2400 cache_methods->get_authentic_pixels_handler=GetAuthenticPixelsCache;
2401 cache_methods->get_authentic_metacontent_from_handler=
2402 GetAuthenticMetacontentFromCache;
2403 cache_methods->get_authentic_pixels_from_handler=GetAuthenticPixelsFromCache;
2404 cache_methods->get_one_authentic_pixel_from_handler=
2405 GetOneAuthenticPixelFromCache;
2406 cache_methods->queue_authentic_pixels_handler=QueueAuthenticPixelsCache;
2407 cache_methods->sync_authentic_pixels_handler=SyncAuthenticPixelsCache;
2408 cache_methods->destroy_pixel_handler=DestroyImagePixelCache;
2436MagickPrivate MagickSizeType GetPixelCacheNexusExtent(
const Cache cache,
2437 NexusInfo *magick_restrict nexus_info)
2440 *magick_restrict cache_info;
2445 assert(cache != NULL);
2446 cache_info=(CacheInfo *) cache;
2447 assert(cache_info->signature == MagickCoreSignature);
2448 extent=(MagickSizeType) nexus_info->region.width*nexus_info->region.height;
2450 return((MagickSizeType) cache_info->columns*cache_info->rows);
2481MagickExport
void *GetPixelCachePixels(Image *image,MagickSizeType *length,
2482 ExceptionInfo *magick_unused(exception))
2485 *magick_restrict cache_info;
2487 assert(image != (
const Image *) NULL);
2488 assert(image->signature == MagickCoreSignature);
2489 assert(image->cache != (Cache) NULL);
2490 assert(length != (MagickSizeType *) NULL);
2491 magick_unreferenced(exception);
2492 cache_info=(CacheInfo *) image->cache;
2493 assert(cache_info->signature == MagickCoreSignature);
2494 *length=cache_info->length;
2495 if ((cache_info->type != MemoryCache) && (cache_info->type != MapCache))
2496 return((
void *) NULL);
2497 return((
void *) cache_info->pixels);
2524MagickPrivate ClassType GetPixelCacheStorageClass(
const Cache cache)
2527 *magick_restrict cache_info;
2529 assert(cache != (Cache) NULL);
2530 cache_info=(CacheInfo *) cache;
2531 assert(cache_info->signature == MagickCoreSignature);
2532 if (IsEventLogging() != MagickFalse)
2533 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2534 cache_info->filename);
2535 return(cache_info->storage_class);
2565MagickPrivate
void GetPixelCacheTileSize(
const Image *image,
size_t *width,
2569 *magick_restrict cache_info;
2571 assert(image != (Image *) NULL);
2572 assert(image->signature == MagickCoreSignature);
2573 if (IsEventLogging() != MagickFalse)
2574 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2575 cache_info=(CacheInfo *) image->cache;
2576 assert(cache_info->signature == MagickCoreSignature);
2577 *width=2048UL/(MagickMax(cache_info->number_channels,1)*
sizeof(Quantum));
2578 if (GetImagePixelCacheType(image) == DiskCache)
2579 *width=8192UL/(MagickMax(cache_info->number_channels,1)*
sizeof(Quantum));
2607MagickPrivate VirtualPixelMethod GetPixelCacheVirtualMethod(
const Image *image)
2610 *magick_restrict cache_info;
2612 assert(image != (Image *) NULL);
2613 assert(image->signature == MagickCoreSignature);
2614 assert(image->cache != (Cache) NULL);
2615 cache_info=(CacheInfo *) image->cache;
2616 assert(cache_info->signature == MagickCoreSignature);
2617 return(cache_info->virtual_pixel_method);
2643static const void *GetVirtualMetacontentFromCache(
const Image *image)
2646 *magick_restrict cache_info;
2649 id = GetOpenMPThreadId();
2652 *magick_restrict metacontent;
2654 assert(image != (
const Image *) NULL);
2655 assert(image->signature == MagickCoreSignature);
2656 assert(image->cache != (Cache) NULL);
2657 cache_info=(CacheInfo *) image->cache;
2658 assert(cache_info->signature == MagickCoreSignature);
2659 assert(
id < (
int) cache_info->number_threads);
2660 metacontent=GetVirtualMetacontentFromNexus(cache_info,
2661 cache_info->nexus_info[
id]);
2662 return(metacontent);
2691MagickPrivate
const void *GetVirtualMetacontentFromNexus(
const Cache cache,
2692 NexusInfo *magick_restrict nexus_info)
2695 *magick_restrict cache_info;
2697 assert(cache != (Cache) NULL);
2698 cache_info=(CacheInfo *) cache;
2699 assert(cache_info->signature == MagickCoreSignature);
2700 if (cache_info->storage_class == UndefinedClass)
2701 return((
void *) NULL);
2702 return(nexus_info->metacontent);
2729MagickExport
const void *GetVirtualMetacontent(
const Image *image)
2732 *magick_restrict cache_info;
2735 id = GetOpenMPThreadId();
2738 *magick_restrict metacontent;
2740 assert(image != (
const Image *) NULL);
2741 assert(image->signature == MagickCoreSignature);
2742 assert(image->cache != (Cache) NULL);
2743 cache_info=(CacheInfo *) image->cache;
2744 assert(cache_info->signature == MagickCoreSignature);
2745 if (cache_info->methods.get_virtual_metacontent_from_handler != (GetVirtualMetacontentFromHandler) NULL)
2747 metacontent=cache_info->methods.get_virtual_metacontent_from_handler(
2749 if (metacontent != (
const void *) NULL)
2750 return(metacontent);
2752 assert(
id < (
int) cache_info->number_threads);
2753 metacontent=GetVirtualMetacontentFromNexus(cache_info,
2754 cache_info->nexus_info[
id]);
2755 return(metacontent);
2798 0, 48, 12, 60, 3, 51, 15, 63,
2799 32, 16, 44, 28, 35, 19, 47, 31,
2800 8, 56, 4, 52, 11, 59, 7, 55,
2801 40, 24, 36, 20, 43, 27, 39, 23,
2802 2, 50, 14, 62, 1, 49, 13, 61,
2803 34, 18, 46, 30, 33, 17, 45, 29,
2804 10, 58, 6, 54, 9, 57, 5, 53,
2805 42, 26, 38, 22, 41, 25, 37, 21
2808static inline ssize_t DitherX(
const ssize_t x,
const size_t columns)
2813 index=x+DitherMatrix[x & 0x07]-32L;
2816 if (index >= (ssize_t) columns)
2817 return((ssize_t) columns-1L);
2821static inline ssize_t DitherY(
const ssize_t y,
const size_t rows)
2826 index=y+DitherMatrix[y & 0x07]-32L;
2829 if (index >= (ssize_t) rows)
2830 return((ssize_t) rows-1L);
2834static inline ssize_t EdgeX(
const ssize_t x,
const size_t columns)
2838 if (x >= (ssize_t) columns)
2839 return((ssize_t) (columns-1));
2843static inline ssize_t EdgeY(
const ssize_t y,
const size_t rows)
2847 if (y >= (ssize_t) rows)
2848 return((ssize_t) (rows-1));
2852static inline MagickBooleanType IsOffsetOverflow(
const MagickOffsetType x,
2853 const MagickOffsetType y)
2855 if (((y > 0) && (x > ((MagickOffsetType) MAGICK_SSIZE_MAX-y))) ||
2856 ((y < 0) && (x < ((MagickOffsetType) MAGICK_SSIZE_MIN-y))))
2857 return(MagickFalse);
2861static inline ssize_t RandomX(RandomInfo *random_info,
const size_t columns)
2866 x=(double) columns*GetPseudoRandomValue(random_info);
2867 return(CastDoubleToSsizeT(x));
2870static inline ssize_t RandomY(RandomInfo *random_info,
const size_t rows)
2875 y=(double) rows*GetPseudoRandomValue(random_info);
2876 return(CastDoubleToSsizeT(y));
2879static inline MagickModulo VirtualPixelModulo(
const ssize_t offset,
2880 const size_t extent)
2885 modulo.quotient=offset;
2889 modulo.quotient=offset/((ssize_t) extent);
2890 modulo.remainder=offset % ((ssize_t) extent);
2892 if ((modulo.remainder != 0) && ((offset ^ ((ssize_t) extent)) < 0))
2895 modulo.remainder+=((ssize_t) extent);
2900MagickPrivate
const Quantum *GetVirtualPixelCacheNexus(
const Image *image,
2901 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
2902 const size_t columns,
const size_t rows,NexusInfo *nexus_info,
2903 ExceptionInfo *exception)
2906 *magick_restrict cache_info;
2922 *magick_restrict virtual_nexus;
2925 *magick_restrict pixels,
2927 virtual_pixel[MaxPixelChannels];
2938 *magick_restrict virtual_metacontent;
2943 assert(image != (
const Image *) NULL);
2944 assert(image->signature == MagickCoreSignature);
2945 assert(image->cache != (Cache) NULL);
2946 cache_info=(CacheInfo *) image->cache;
2947 assert(cache_info->signature == MagickCoreSignature);
2948 if (cache_info->type == UndefinedCache)
2949 return((
const Quantum *) NULL);
2950#if defined(MAGICKCORE_OPENCL_SUPPORT)
2951 CopyOpenCLBuffer(cache_info);
2953 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,x,y,columns,rows,
2954 ((image->channels & WriteMaskChannel) != 0) ||
2955 ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
2956 nexus_info,exception);
2957 if (pixels == (Quantum *) NULL)
2958 return((
const Quantum *) NULL);
2959 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
2960 return((
const Quantum *) NULL);
2961 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns;
2962 if (IsOffsetOverflow(offset,(MagickOffsetType) nexus_info->region.x) == MagickFalse)
2963 return((
const Quantum *) NULL);
2964 offset+=nexus_info->region.x;
2965 length=(MagickSizeType) (nexus_info->region.height-1L)*cache_info->columns+
2966 nexus_info->region.width-1L;
2967 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
2968 if ((offset >= 0) && (((MagickSizeType) offset+length) < number_pixels))
2969 if ((x >= 0) && ((x+(ssize_t) columns-1) < (ssize_t) cache_info->columns) &&
2970 (y >= 0) && ((y+(ssize_t) rows-1) < (ssize_t) cache_info->rows))
2978 if (nexus_info->authentic_pixel_cache != MagickFalse)
2980 status=ReadPixelCachePixels(cache_info,nexus_info,exception);
2981 if (status == MagickFalse)
2982 return((
const Quantum *) NULL);
2983 if (cache_info->metacontent_extent != 0)
2985 status=ReadPixelCacheMetacontent(cache_info,nexus_info,exception);
2986 if (status == MagickFalse)
2987 return((
const Quantum *) NULL);
2994 virtual_nexus=nexus_info->virtual_nexus;
2996 s=(
unsigned char *) nexus_info->metacontent;
2997 (void) memset(virtual_pixel,0,cache_info->number_channels*
2998 sizeof(*virtual_pixel));
2999 virtual_metacontent=(
void *) NULL;
3000 switch (virtual_pixel_method)
3002 case BackgroundVirtualPixelMethod:
3003 case BlackVirtualPixelMethod:
3004 case GrayVirtualPixelMethod:
3005 case TransparentVirtualPixelMethod:
3006 case MaskVirtualPixelMethod:
3007 case WhiteVirtualPixelMethod:
3008 case EdgeVirtualPixelMethod:
3009 case CheckerTileVirtualPixelMethod:
3010 case HorizontalTileVirtualPixelMethod:
3011 case VerticalTileVirtualPixelMethod:
3013 if (cache_info->metacontent_extent != 0)
3018 virtual_metacontent=(
void *) AcquireQuantumMemory(1,
3019 cache_info->metacontent_extent);
3020 if (virtual_metacontent == (
void *) NULL)
3022 (void) ThrowMagickException(exception,GetMagickModule(),
3023 CacheError,
"UnableToGetCacheNexus",
"`%s'",image->filename);
3024 return((
const Quantum *) NULL);
3026 (void) memset(virtual_metacontent,0,cache_info->metacontent_extent);
3028 switch (virtual_pixel_method)
3030 case BlackVirtualPixelMethod:
3032 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
3033 SetPixelChannel(image,(PixelChannel) i,(Quantum) 0,virtual_pixel);
3034 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
3037 case GrayVirtualPixelMethod:
3039 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
3040 SetPixelChannel(image,(PixelChannel) i,QuantumRange/2,
3042 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
3045 case TransparentVirtualPixelMethod:
3047 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
3048 SetPixelChannel(image,(PixelChannel) i,(Quantum) 0,virtual_pixel);
3049 SetPixelAlpha(image,TransparentAlpha,virtual_pixel);
3052 case MaskVirtualPixelMethod:
3053 case WhiteVirtualPixelMethod:
3055 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
3056 SetPixelChannel(image,(PixelChannel) i,QuantumRange,virtual_pixel);
3057 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
3062 SetPixelRed(image,ClampToQuantum(image->background_color.red),
3064 SetPixelGreen(image,ClampToQuantum(image->background_color.green),
3066 SetPixelBlue(image,ClampToQuantum(image->background_color.blue),
3068 SetPixelBlack(image,ClampToQuantum(image->background_color.black),
3070 SetPixelAlpha(image,ClampToQuantum(image->background_color.alpha),
3080 for (v=0; v < (ssize_t) rows; v++)
3086 if ((virtual_pixel_method == EdgeVirtualPixelMethod) ||
3087 (virtual_pixel_method == UndefinedVirtualPixelMethod))
3088 y_offset=EdgeY(y_offset,cache_info->rows);
3089 for (u=0; u < (ssize_t) columns; u+=(ssize_t) length)
3095 length=(MagickSizeType) MagickMin((ssize_t) cache_info->columns-
3096 x_offset,(ssize_t) columns-u);
3097 if (((x_offset < 0) || (x_offset >= (ssize_t) cache_info->columns)) ||
3098 ((y_offset < 0) || (y_offset >= (ssize_t) cache_info->rows)) ||
3108 length=(MagickSizeType) 1;
3109 switch (virtual_pixel_method)
3111 case EdgeVirtualPixelMethod:
3114 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3115 EdgeX(x_offset,cache_info->columns),
3116 EdgeY(y_offset,cache_info->rows),1UL,1UL,virtual_nexus,
3118 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3121 case RandomVirtualPixelMethod:
3123 if (cache_info->random_info == (RandomInfo *) NULL)
3125 LockSemaphoreInfo(cache_info->semaphore);
3126 if (cache_info->random_info == (RandomInfo *) NULL)
3127 cache_info->random_info=AcquireRandomInfo();
3128 UnlockSemaphoreInfo(cache_info->semaphore);
3130 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3131 RandomX(cache_info->random_info,cache_info->columns),
3132 RandomY(cache_info->random_info,cache_info->rows),1UL,1UL,
3133 virtual_nexus,exception);
3134 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3137 case DitherVirtualPixelMethod:
3139 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3140 DitherX(x_offset,cache_info->columns),
3141 DitherY(y_offset,cache_info->rows),1UL,1UL,virtual_nexus,
3143 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3146 case TileVirtualPixelMethod:
3148 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3149 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3150 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3151 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3153 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3156 case MirrorVirtualPixelMethod:
3158 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3159 if ((x_modulo.quotient & 0x01) == 1L)
3160 x_modulo.remainder=(ssize_t) cache_info->columns-
3161 x_modulo.remainder-1L;
3162 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3163 if ((y_modulo.quotient & 0x01) == 1L)
3164 y_modulo.remainder=(ssize_t) cache_info->rows-
3165 y_modulo.remainder-1L;
3166 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3167 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3169 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3172 case HorizontalTileEdgeVirtualPixelMethod:
3174 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3175 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3176 x_modulo.remainder,EdgeY(y_offset,cache_info->rows),1UL,1UL,
3177 virtual_nexus,exception);
3178 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3181 case VerticalTileEdgeVirtualPixelMethod:
3183 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3184 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3185 EdgeX(x_offset,cache_info->columns),y_modulo.remainder,1UL,1UL,
3186 virtual_nexus,exception);
3187 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3190 case BackgroundVirtualPixelMethod:
3191 case BlackVirtualPixelMethod:
3192 case GrayVirtualPixelMethod:
3193 case TransparentVirtualPixelMethod:
3194 case MaskVirtualPixelMethod:
3195 case WhiteVirtualPixelMethod:
3198 r=virtual_metacontent;
3201 case CheckerTileVirtualPixelMethod:
3203 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3204 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3205 if (((x_modulo.quotient ^ y_modulo.quotient) & 0x01) != 0L)
3208 r=virtual_metacontent;
3211 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3212 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3214 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3217 case HorizontalTileVirtualPixelMethod:
3219 if ((y_offset < 0) || (y_offset >= (ssize_t) cache_info->rows))
3222 r=virtual_metacontent;
3225 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3226 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3227 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3228 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3230 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3233 case VerticalTileVirtualPixelMethod:
3235 if ((x_offset < 0) || (x_offset >= (ssize_t) cache_info->columns))
3238 r=virtual_metacontent;
3241 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3242 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3243 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3244 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3246 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3250 if (p == (
const Quantum *) NULL)
3252 (void) memcpy(q,p,(
size_t) (cache_info->number_channels*length*
3254 q+=(ptrdiff_t) cache_info->number_channels;
3255 if ((s != (
void *) NULL) && (r != (
const void *) NULL))
3257 (void) memcpy(s,r,(
size_t) cache_info->metacontent_extent);
3258 s+=(ptrdiff_t) cache_info->metacontent_extent;
3265 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x_offset,y_offset,
3266 (
size_t) length,1UL,virtual_nexus,exception);
3267 if (p == (
const Quantum *) NULL)
3269 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3270 (void) memcpy(q,p,(
size_t) (cache_info->number_channels*length*
3272 q+=(ptrdiff_t) (cache_info->number_channels*length);
3273 if ((r != (
void *) NULL) && (s != (
const void *) NULL))
3275 (void) memcpy(s,r,(
size_t) (length*cache_info->metacontent_extent));
3276 s+=(ptrdiff_t) (length*cache_info->metacontent_extent);
3279 if (u < (ssize_t) columns)
3285 if (virtual_metacontent != (
void *) NULL)
3286 virtual_metacontent=(
void *) RelinquishMagickMemory(virtual_metacontent);
3287 if (v < (ssize_t) rows)
3288 return((
const Quantum *) NULL);
3326static const Quantum *GetVirtualPixelCache(
const Image *image,
3327 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
3328 const size_t columns,
const size_t rows,ExceptionInfo *exception)
3331 *magick_restrict cache_info;
3334 id = GetOpenMPThreadId();
3339 assert(image != (
const Image *) NULL);
3340 assert(image->signature == MagickCoreSignature);
3341 assert(image->cache != (Cache) NULL);
3342 cache_info=(CacheInfo *) image->cache;
3343 assert(cache_info->signature == MagickCoreSignature);
3344 assert(
id < (
int) cache_info->number_threads);
3345 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,columns,rows,
3346 cache_info->nexus_info[
id],exception);
3373MagickExport
const Quantum *GetVirtualPixelQueue(
const Image *image)
3376 *magick_restrict cache_info;
3379 id = GetOpenMPThreadId();
3381 assert(image != (
const Image *) NULL);
3382 assert(image->signature == MagickCoreSignature);
3383 assert(image->cache != (Cache) NULL);
3384 cache_info=(CacheInfo *) image->cache;
3385 assert(cache_info->signature == MagickCoreSignature);
3386 if (cache_info->methods.get_virtual_pixels_handler != (GetVirtualPixelsHandler) NULL)
3387 return(cache_info->methods.get_virtual_pixels_handler(image));
3388 assert(
id < (
int) cache_info->number_threads);
3389 return(GetVirtualPixelsNexus(cache_info,cache_info->nexus_info[
id]));
3440MagickExport
const Quantum *GetVirtualPixels(
const Image *image,
3441 const ssize_t x,
const ssize_t y,
const size_t columns,
const size_t rows,
3442 ExceptionInfo *exception)
3445 *magick_restrict cache_info;
3448 id = GetOpenMPThreadId();
3453 assert(image != (
const Image *) NULL);
3454 assert(image->signature == MagickCoreSignature);
3455 assert(image->cache != (Cache) NULL);
3456 cache_info=(CacheInfo *) image->cache;
3457 assert(cache_info->signature == MagickCoreSignature);
3458 if (cache_info->methods.get_virtual_pixel_handler !=
3459 (GetVirtualPixelHandler) NULL)
3460 return(cache_info->methods.get_virtual_pixel_handler(image,
3461 GetPixelCacheVirtualMethod(image),x,y,columns,rows,exception));
3462 assert(
id < (
int) cache_info->number_threads);
3463 p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
3464 columns,rows,cache_info->nexus_info[
id],exception);
3491static const Quantum *GetVirtualPixelsCache(
const Image *image)
3494 *magick_restrict cache_info;
3497 id = GetOpenMPThreadId();
3499 assert(image != (
const Image *) NULL);
3500 assert(image->signature == MagickCoreSignature);
3501 assert(image->cache != (Cache) NULL);
3502 cache_info=(CacheInfo *) image->cache;
3503 assert(cache_info->signature == MagickCoreSignature);
3504 assert(
id < (
int) cache_info->number_threads);
3505 return(GetVirtualPixelsNexus(image->cache,cache_info->nexus_info[
id]));
3534MagickPrivate
const Quantum *GetVirtualPixelsNexus(
const Cache cache,
3535 NexusInfo *magick_restrict nexus_info)
3538 *magick_restrict cache_info;
3540 assert(cache != (Cache) NULL);
3541 cache_info=(CacheInfo *) cache;
3542 assert(cache_info->signature == MagickCoreSignature);
3543 if (cache_info->storage_class == UndefinedClass)
3544 return((Quantum *) NULL);
3545 return((
const Quantum *) nexus_info->pixels);
3578static inline Quantum ApplyPixelCompositeMask(
const Quantum p,
3579 const MagickRealType alpha,
const Quantum q,
const MagickRealType beta)
3584 if (fabs((
double) (alpha-(
double) TransparentAlpha)) < MagickEpsilon)
3586 gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
3587 gamma=MagickSafeReciprocal(gamma);
3588 return(ClampToQuantum(gamma*MagickOver_((
double) p,alpha,(
double) q,beta)));
3591static MagickBooleanType MaskPixelCacheNexus(Image *image,NexusInfo *nexus_info,
3592 ExceptionInfo *exception)
3595 *magick_restrict cache_info;
3607 if (IsEventLogging() != MagickFalse)
3608 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3609 if ((image->channels & CompositeMaskChannel) == 0)
3611 if ((nexus_info->region.width == 0) || (nexus_info->region.height == 0))
3613 cache_info=(CacheInfo *) image->cache;
3614 if (cache_info == (Cache) NULL)
3615 return(MagickFalse);
3616 p=GetAuthenticPixelCacheNexus(image,nexus_info->region.x,nexus_info->region.y,
3617 nexus_info->region.width,nexus_info->region.height,
3618 nexus_info->virtual_nexus,exception);
3619 q=nexus_info->pixels;
3620 if ((p == (Quantum *) NULL) || (q == (Quantum *) NULL))
3621 return(MagickFalse);
3622 for (y=0; y < (ssize_t) nexus_info->region.height; y++)
3627 for (x=0; x < (ssize_t) nexus_info->region.width; x++)
3635 alpha=(double) GetPixelCompositeMask(image,p);
3636 for (i=0; i < (ssize_t) image->number_channels; i++)
3638 PixelChannel channel = GetPixelChannelChannel(image,i);
3639 PixelTrait traits = GetPixelChannelTraits(image,channel);
3640 if ((traits & UpdatePixelTrait) == 0)
3642 q[i]=ApplyPixelCompositeMask(q[i],alpha,p[i],GetPixelAlpha(image,p));
3644 p+=(ptrdiff_t) GetPixelChannels(image);
3645 q+=(ptrdiff_t) GetPixelChannels(image);
3682static inline MagickBooleanType CacheOverflowSanityCheckGetSize(
3683 const MagickSizeType count,
const size_t quantum,MagickSizeType *
const extent)
3688 if ((count == 0) || (quantum == 0))
3690 length=count*quantum;
3691 if (quantum != (length/count))
3698 return(MagickFalse);
3701static MagickBooleanType OpenPixelCacheOnDisk(CacheInfo *cache_info,
3702 const MapMode mode,ExceptionInfo *exception)
3710 if ((cache_info->file != -1) && (cache_info->disk_mode == mode))
3712 if (*cache_info->cache_filename ==
'\0')
3713 file=AcquireUniqueFileResource(cache_info->cache_filename);
3719 if (IsPathAuthorized(ReadPolicyRights,cache_info->cache_filename) == MagickFalse)
3722 ThrowFileException(exception,OptionWarning,
"NotAuthorized",
3723 cache_info->cache_filename);
3724 return(MagickFalse);
3726 file=open_utf8(cache_info->cache_filename,O_RDONLY | O_CLOEXEC |
3732 if (IsPathAuthorized(WritePolicyRights,cache_info->cache_filename) == MagickFalse)
3735 ThrowFileException(exception,OptionWarning,
"NotAuthorized",
3736 cache_info->cache_filename);
3737 return(MagickFalse);
3739 file=open_utf8(cache_info->cache_filename,O_WRONLY | O_CLOEXEC |
3740 O_CREAT | O_BINARY | O_EXCL,S_MODE);
3742 file=open_utf8(cache_info->cache_filename,O_WRONLY | O_CLOEXEC |
3749 if ((IsPathAuthorized(ReadPolicyRights,cache_info->cache_filename) == MagickFalse) ||
3750 (IsPathAuthorized(WritePolicyRights,cache_info->cache_filename) == MagickFalse))
3753 ThrowFileException(exception,OptionWarning,
"NotAuthorized",
3754 cache_info->cache_filename);
3755 return(MagickFalse);
3757 file=open_utf8(cache_info->cache_filename,O_RDWR | O_CLOEXEC |
3758 O_CREAT | O_BINARY | O_EXCL,S_MODE);
3760 file=open_utf8(cache_info->cache_filename,O_RDWR | O_CLOEXEC |
3766 return(MagickFalse);
3767 (void) AcquireMagickResource(FileResource,1);
3768 if (cache_info->file != -1)
3769 (void) ClosePixelCacheOnDisk(cache_info);
3770 cache_info->file=file;
3771 cache_info->disk_mode=mode;
3775static inline MagickOffsetType WritePixelCacheRegion(
3776 const CacheInfo *magick_restrict cache_info,
const MagickOffsetType offset,
3777 const MagickSizeType length,
const unsigned char *magick_restrict buffer)
3785#if !defined(MAGICKCORE_HAVE_PWRITE)
3786 if (lseek(cache_info->file,offset,SEEK_SET) < 0)
3787 return((MagickOffsetType) -1);
3789 for (i=0; i < (MagickOffsetType) length; i+=count)
3794 extent=(size_t) MagickMin(length-(MagickSizeType) i,MagickMaxBufferExtent);
3795#if defined(MAGICKCORE_HAVE_PWRITE)
3796 count=pwrite(cache_info->file,buffer+i,extent,(off_t) (offset+i));
3797 if ((count < 0) && (errno == EINTR))
3803 count=MagickWrite(cache_info->file,buffer+i,extent);
3811static MagickBooleanType SetPixelCacheExtent(Image *image,MagickSizeType length)
3814 *magick_restrict cache_info;
3819 cache_info=(CacheInfo *) image->cache;
3820 if (cache_info->debug != MagickFalse)
3823 format[MagickPathExtent],
3824 message[MagickPathExtent];
3826 (void) FormatMagickSize(length,MagickFalse,
"B",MagickPathExtent,format);
3827 (void) FormatLocaleString(message,MagickPathExtent,
3828 "extend %s (%s[%d], disk, %s)",cache_info->filename,
3829 cache_info->cache_filename,cache_info->file,format);
3830 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",message);
3832 if (length != (MagickSizeType) ((MagickOffsetType) length))
3833 return(MagickFalse);
3834 offset=(MagickOffsetType) lseek(cache_info->file,0,SEEK_END);
3836 return(MagickFalse);
3837 if ((MagickSizeType) offset < length)
3843 extent=(MagickOffsetType) length-1;
3844 count=WritePixelCacheRegion(cache_info,extent,1,(
const unsigned char *)
3847 return(MagickFalse);
3848#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
3849 if (cache_info->synchronize != MagickFalse)
3850 if (posix_fallocate(cache_info->file,offset,extent-offset) != 0)
3851 return(MagickFalse);
3854 offset=(MagickOffsetType) lseek(cache_info->file,0,SEEK_SET);
3856 return(MagickFalse);
3860static MagickBooleanType OpenPixelCache(Image *image,
const MapMode mode,
3861 ExceptionInfo *exception)
3864 *magick_restrict cache_info,
3868 format[MagickPathExtent],
3869 message[MagickPathExtent];
3886 assert(image != (
const Image *) NULL);
3887 assert(image->signature == MagickCoreSignature);
3888 assert(image->cache != (Cache) NULL);
3889 if (IsEventLogging() != MagickFalse)
3890 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3891 if (cache_anonymous_memory < 0)
3899 cache_anonymous_memory=0;
3900 value=GetPolicyValue(
"pixel-cache-memory");
3901 if (value == (
char *) NULL)
3902 value=GetPolicyValue(
"cache:memory-map");
3903 if (LocaleCompare(value,
"anonymous") == 0)
3905#if defined(MAGICKCORE_HAVE_MMAP) && defined(MAP_ANONYMOUS)
3906 cache_anonymous_memory=1;
3908 (void) ThrowMagickException(exception,GetMagickModule(),
3909 MissingDelegateError,
"DelegateLibrarySupportNotBuiltIn",
3910 "`%s' (policy requires anonymous memory mapping)",image->filename);
3913 value=DestroyString(value);
3915 if ((image->columns == 0) || (image->rows == 0))
3916 ThrowBinaryException(CacheError,
"NoPixelsDefinedInCache",image->filename);
3917 cache_info=(CacheInfo *) image->cache;
3918 assert(cache_info->signature == MagickCoreSignature);
3919 if (((MagickSizeType) image->columns > cache_info->width_limit) ||
3920 ((MagickSizeType) image->rows > cache_info->height_limit))
3922 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3923 "WidthOrHeightExceedsLimit",
"`%s' (%.17gx%.17g) > (%.17gx%.17g)",
3924 image->filename, (
double) image->columns, (
double) image->rows,
3925 (
double) cache_info->width_limit,(
double) cache_info->height_limit);
3926 return(MagickFalse);
3928 if (GetMagickResourceLimit(ListLengthResource) != MagickResourceInfinity)
3930 length=GetImageListLength(image);
3931 if (AcquireMagickResource(ListLengthResource,length) == MagickFalse)
3932 ThrowBinaryException(ResourceLimitError,
"ListLengthExceedsLimit",
3935 source_info=(*cache_info);
3936 source_info.file=(-1);
3937 (void) FormatLocaleString(cache_info->filename,MagickPathExtent,
"%s[%.17g]",
3938 image->filename,(
double) image->scene);
3939 cache_info->storage_class=image->storage_class;
3940 cache_info->colorspace=image->colorspace;
3941 cache_info->alpha_trait=image->alpha_trait;
3942 cache_info->channels=image->channels;
3943 cache_info->rows=image->rows;
3944 cache_info->columns=image->columns;
3945 status=ResetPixelChannelMap(image,exception);
3946 if (status == MagickFalse)
3947 return(MagickFalse);
3948 cache_info->number_channels=GetPixelChannels(image);
3949 (void) memcpy(cache_info->channel_map,image->channel_map,MaxPixelChannels*
3950 sizeof(*image->channel_map));
3951 cache_info->metacontent_extent=image->metacontent_extent;
3952 cache_info->mode=mode;
3953 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
3954 packet_size=MagickMax(cache_info->number_channels,1)*
sizeof(Quantum);
3955 if (cache_info->metacontent_extent != 0)
3957 if (HeapOverflowCheckAdd(packet_size,cache_info->metacontent_extent) != MagickFalse)
3959 cache_info->storage_class=UndefinedClass;
3960 cache_info->length=0;
3961 ThrowBinaryException(ResourceLimitError,
"PixelCacheAllocationFailed",
3964 packet_size+=cache_info->metacontent_extent;
3966 if (CacheOverflowSanityCheckGetSize(number_pixels,packet_size,&length) != MagickFalse)
3968 cache_info->storage_class=UndefinedClass;
3969 cache_info->length=0;
3970 ThrowBinaryException(ResourceLimitError,
"PixelCacheAllocationFailed",
3973 columns=(size_t) (length/cache_info->rows/packet_size);
3974 if ((cache_info->columns != columns) || ((ssize_t) cache_info->columns < 0) ||
3975 ((ssize_t) cache_info->rows < 0))
3977 cache_info->storage_class=UndefinedClass;
3978 cache_info->length=0;
3979 ThrowBinaryException(ResourceLimitError,
"PixelCacheAllocationFailed",
3982 cache_info->length=length;
3983 if (image->ping != MagickFalse)
3985 cache_info->type=PingCache;
3988 status=AcquireMagickResource(AreaResource,(MagickSizeType)
3989 cache_info->columns*cache_info->rows);
3990 if (cache_info->mode == PersistMode)
3992 length=number_pixels*(cache_info->number_channels*
sizeof(Quantum)+
3993 cache_info->metacontent_extent);
3994 if ((status != MagickFalse) &&
3995 (length == (MagickSizeType) ((
size_t) length)) &&
3996 ((cache_info->type == UndefinedCache) ||
3997 (cache_info->type == MemoryCache)))
3999 status=AcquireMagickResource(MemoryResource,cache_info->length);
4000 if (status != MagickFalse)
4003 if (cache_anonymous_memory <= 0)
4005 cache_info->mapped=MagickFalse;
4006 cache_info->pixels=(Quantum *) MagickAssumeAligned(
4007 AcquireAlignedMemory(1,(
size_t) cache_info->length));
4011 cache_info->mapped=MagickTrue;
4012 cache_info->pixels=(Quantum *) MapBlob(-1,IOMode,0,(
size_t)
4013 cache_info->length);
4015 if (cache_info->pixels == (Quantum *) NULL)
4017 RelinquishMagickResource(MemoryResource,cache_info->length);
4018 cache_info->mapped=source_info.mapped;
4019 cache_info->pixels=source_info.pixels;
4026 cache_info->type=MemoryCache;
4027 cache_info->metacontent=(
void *) NULL;
4028 if (cache_info->metacontent_extent != 0)
4029 cache_info->metacontent=(
void *) (cache_info->pixels+
4030 cache_info->number_channels*number_pixels);
4031 if ((source_info.storage_class != UndefinedClass) &&
4034 status=ClonePixelCacheRepository(cache_info,&source_info,
4036 RelinquishPixelCachePixels(&source_info);
4038 if (cache_info->debug != MagickFalse)
4040 (void) FormatMagickSize(cache_info->length,MagickTrue,
"B",
4041 MagickPathExtent,format);
4042 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4044 (void) FormatLocaleString(message,MagickPathExtent,
4045 "open %s (%s %s, %.17gx%.17gx%.17g %s)",
4046 cache_info->filename,cache_info->mapped != MagickFalse ?
4047 "Anonymous" :
"Heap",type,(
double) cache_info->columns,
4048 (
double) cache_info->rows,(
double)
4049 cache_info->number_channels,format);
4050 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",
4053 cache_info->storage_class=image->storage_class;
4056 if ((source_info.storage_class != UndefinedClass) &&
4058 RelinquishPixelCachePixels(&source_info);
4059 cache_info->type=UndefinedCache;
4060 return(MagickFalse);
4066 status=AcquireMagickResource(DiskResource,cache_info->length);
4067 hosts=(
const char *) GetImageRegistry(StringRegistryType,
"cache:hosts",
4069 if ((status == MagickFalse) && (hosts != (
const char *) NULL))
4077 server_info=AcquireDistributeCacheInfo(exception);
4078 if (server_info != (DistributeCacheInfo *) NULL)
4080 status=OpenDistributePixelCache(server_info,image);
4081 if (status == MagickFalse)
4083 ThrowFileException(exception,CacheError,
"UnableToOpenPixelCache",
4084 GetDistributeCacheHostname(server_info));
4085 server_info=DestroyDistributeCacheInfo(server_info);
4093 cache_info->type=DistributedCache;
4094 cache_info->server_info=server_info;
4095 (void) FormatLocaleString(cache_info->cache_filename,
4096 MagickPathExtent,
"%s:%d",GetDistributeCacheHostname(
4097 (DistributeCacheInfo *) cache_info->server_info),
4098 GetDistributeCachePort((DistributeCacheInfo *)
4099 cache_info->server_info));
4100 if ((source_info.storage_class != UndefinedClass) &&
4103 status=ClonePixelCacheRepository(cache_info,&source_info,
4105 RelinquishPixelCachePixels(&source_info);
4107 if (cache_info->debug != MagickFalse)
4109 (void) FormatMagickSize(cache_info->length,MagickFalse,
"B",
4110 MagickPathExtent,format);
4111 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4113 (void) FormatLocaleString(message,MagickPathExtent,
4114 "open %s (%s[%d], %s, %.17gx%.17gx%.17g %s)",
4115 cache_info->filename,cache_info->cache_filename,
4116 GetDistributeCacheFile((DistributeCacheInfo *)
4117 cache_info->server_info),type,(
double) cache_info->columns,
4118 (
double) cache_info->rows,(
double)
4119 cache_info->number_channels,format);
4120 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",
4125 if ((source_info.storage_class != UndefinedClass) &&
4127 RelinquishPixelCachePixels(&source_info);
4128 cache_info->type=UndefinedCache;
4129 return(MagickFalse);
4134 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4135 RelinquishPixelCachePixels(&source_info);
4136 cache_info->type=UndefinedCache;
4137 (void) memset(image->channel_map,0,MaxPixelChannels*
4138 sizeof(*image->channel_map));
4139 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4140 "CacheResourcesExhausted",
"`%s'",image->filename);
4141 return(MagickFalse);
4146 if (status == MagickFalse)
4148 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4149 RelinquishPixelCachePixels(&source_info);
4150 cache_info->type=UndefinedCache;
4151 (void) memset(image->channel_map,0,MaxPixelChannels*
4152 sizeof(*image->channel_map));
4153 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4154 "CacheResourcesExhausted",
"`%s'",image->filename);
4155 return(MagickFalse);
4157 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode) &&
4158 (cache_info->mode != PersistMode))
4160 (void) ClosePixelCacheOnDisk(cache_info);
4161 *cache_info->cache_filename=
'\0';
4163 if (OpenPixelCacheOnDisk(cache_info,mode,exception) == MagickFalse)
4165 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4166 RelinquishPixelCachePixels(&source_info);
4167 cache_info->type=UndefinedCache;
4168 ThrowFileException(exception,CacheError,
"UnableToOpenPixelCache",
4170 return(MagickFalse);
4172 status=SetPixelCacheExtent(image,(MagickSizeType) cache_info->offset+
4173 cache_info->length);
4174 if (status == MagickFalse)
4176 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4177 RelinquishPixelCachePixels(&source_info);
4178 cache_info->type=UndefinedCache;
4179 ThrowFileException(exception,CacheError,
"UnableToExtendCache",
4181 return(MagickFalse);
4183 cache_info->type=DiskCache;
4184 length=number_pixels*(cache_info->number_channels*
sizeof(Quantum)+
4185 cache_info->metacontent_extent);
4186 if (length == (MagickSizeType) ((
size_t) length))
4188 status=AcquireMagickResource(MapResource,cache_info->length);
4189 if (status != MagickFalse)
4191 cache_info->pixels=(Quantum *) MapBlob(cache_info->file,mode,
4192 cache_info->offset,(
size_t) cache_info->length);
4193 if (cache_info->pixels == (Quantum *) NULL)
4195 cache_info->mapped=source_info.mapped;
4196 cache_info->pixels=source_info.pixels;
4197 RelinquishMagickResource(MapResource,cache_info->length);
4204 (void) ClosePixelCacheOnDisk(cache_info);
4205 cache_info->type=MapCache;
4206 cache_info->mapped=MagickTrue;
4207 cache_info->metacontent=(
void *) NULL;
4208 if (cache_info->metacontent_extent != 0)
4209 cache_info->metacontent=(
void *) (cache_info->pixels+
4210 cache_info->number_channels*number_pixels);
4211 if ((source_info.storage_class != UndefinedClass) &&
4214 status=ClonePixelCacheRepository(cache_info,&source_info,
4216 RelinquishPixelCachePixels(&source_info);
4218 if (cache_info->debug != MagickFalse)
4220 (void) FormatMagickSize(cache_info->length,MagickTrue,
"B",
4221 MagickPathExtent,format);
4222 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4224 (void) FormatLocaleString(message,MagickPathExtent,
4225 "open %s (%s[%d], %s, %.17gx%.17gx%.17g %s)",
4226 cache_info->filename,cache_info->cache_filename,
4227 cache_info->file,type,(
double) cache_info->columns,
4228 (
double) cache_info->rows,(
double)
4229 cache_info->number_channels,format);
4230 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",
4235 if ((source_info.storage_class != UndefinedClass) &&
4237 RelinquishPixelCachePixels(&source_info);
4238 cache_info->type=UndefinedCache;
4239 return(MagickFalse);
4246 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4248 status=ClonePixelCacheRepository(cache_info,&source_info,exception);
4249 RelinquishPixelCachePixels(&source_info);
4251 if (cache_info->debug != MagickFalse)
4253 (void) FormatMagickSize(cache_info->length,MagickFalse,
"B",
4254 MagickPathExtent,format);
4255 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4257 (void) FormatLocaleString(message,MagickPathExtent,
4258 "open %s (%s[%d], %s, %.17gx%.17gx%.17g %s)",cache_info->filename,
4259 cache_info->cache_filename,cache_info->file,type,(
double)
4260 cache_info->columns,(
double) cache_info->rows,(
double)
4261 cache_info->number_channels,format);
4262 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
"%s",message);
4266 cache_info->type=UndefinedCache;
4267 return(MagickFalse);
4309MagickExport MagickBooleanType PersistPixelCache(Image *image,
4310 const char *filename,
const MagickBooleanType attach,MagickOffsetType *offset,
4311 ExceptionInfo *exception)
4314 *magick_restrict cache_info,
4315 *magick_restrict clone_info;
4323 assert(image != (Image *) NULL);
4324 assert(image->signature == MagickCoreSignature);
4325 if (IsEventLogging() != MagickFalse)
4326 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4327 assert(image->cache != (
void *) NULL);
4328 assert(filename != (
const char *) NULL);
4329 assert(offset != (MagickOffsetType *) NULL);
4330 page_size=GetMagickPageSize();
4331 cache_info=(CacheInfo *) image->cache;
4332 assert(cache_info->signature == MagickCoreSignature);
4333#if defined(MAGICKCORE_OPENCL_SUPPORT)
4334 CopyOpenCLBuffer(cache_info);
4336 if (attach != MagickFalse)
4341 if (cache_info->debug != MagickFalse)
4342 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
4343 "attach persistent cache");
4344 (void) CopyMagickString(cache_info->cache_filename,filename,
4346 cache_info->type=MapCache;
4347 cache_info->offset=(*offset);
4348 if (OpenPixelCache(image,ReadMode,exception) == MagickFalse)
4349 return(MagickFalse);
4350 *offset=(*offset+(MagickOffsetType) cache_info->length+page_size-
4351 ((MagickOffsetType) cache_info->length % page_size));
4357 status=AcquireMagickResource(DiskResource,cache_info->length);
4358 if (status == MagickFalse)
4360 cache_info->type=UndefinedCache;
4361 (void) memset(image->channel_map,0,MaxPixelChannels*
4362 sizeof(*image->channel_map));
4363 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4364 "CacheResourcesExhausted",
"`%s'",image->filename);
4365 return(MagickFalse);
4367 clone_info=(CacheInfo *) ClonePixelCache(cache_info);
4368 clone_info->type=DiskCache;
4369 (void) CopyMagickString(clone_info->cache_filename,filename,MagickPathExtent);
4370 clone_info->file=(-1);
4371 clone_info->storage_class=cache_info->storage_class;
4372 clone_info->colorspace=cache_info->colorspace;
4373 clone_info->alpha_trait=cache_info->alpha_trait;
4374 clone_info->channels=cache_info->channels;
4375 clone_info->columns=cache_info->columns;
4376 clone_info->rows=cache_info->rows;
4377 clone_info->number_channels=cache_info->number_channels;
4378 clone_info->metacontent_extent=cache_info->metacontent_extent;
4379 clone_info->mode=PersistMode;
4380 clone_info->length=cache_info->length;
4381 (void) memcpy(clone_info->channel_map,cache_info->channel_map,
4382 MaxPixelChannels*
sizeof(*cache_info->channel_map));
4383 clone_info->offset=(*offset);
4384 status=OpenPixelCacheOnDisk(clone_info,WriteMode,exception);
4385 if (status != MagickFalse)
4386 status=ClonePixelCacheRepository(clone_info,cache_info,exception);
4387 *offset=(*offset+(MagickOffsetType) cache_info->length+page_size-
4388 ((MagickOffsetType) cache_info->length % page_size));
4389 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
4432static inline ssize_t GetPixelCacheNexusIndex(
4433 const CacheInfo *magick_restrict cache_info,
4434 const NexusInfo *magick_restrict nexus_info)
4437 *magick_restrict base;
4445 if ((cache_info == (
const CacheInfo *) NULL) ||
4446 (cache_info->nexus_info == (NexusInfo **) NULL) ||
4447 (nexus_info == (
const NexusInfo *) NULL))
4449 base=(*cache_info->nexus_info);
4450 number_nexus=2*cache_info->number_threads;
4451 if ((nexus_info < base) || (nexus_info >= (base+number_nexus)))
4453 if (cache_info->nexus_info[nexus_info-base] != nexus_info)
4455 return((ssize_t) (nexus_info-base));
4458static Quantum *QueueAuthenticPixelCacheNexusInternal(Image *image,
4459 const ssize_t x,
const ssize_t y,
const size_t columns,
const size_t rows,
4460 const MagickBooleanType clone,NexusInfo **nexus_info,ExceptionInfo *exception)
4463 *magick_restrict cache_info,
4464 *magick_restrict source_info;
4473 *magick_restrict pixels;
4484 assert(image != (
const Image *) NULL);
4485 assert(image->signature == MagickCoreSignature);
4486 assert(image->cache != (Cache) NULL);
4487 assert(nexus_info != (NexusInfo **) NULL);
4488 source_info=(CacheInfo *) image->cache;
4489 source_threads=source_info->number_threads;
4490 nexus_index=GetPixelCacheNexusIndex(source_info,*nexus_info);
4491 cache_info=(CacheInfo *) GetImagePixelCache(image,clone,exception);
4492 if (cache_info == (Cache) NULL)
4494 if ((nexus_index >= 0) && ((CacheInfo *) image->cache != source_info))
4495 *nexus_info=(NexusInfo *) NULL;
4496 return((Quantum *) NULL);
4498 assert(cache_info->signature == MagickCoreSignature);
4499 if ((nexus_index >= 0) && (cache_info != source_info))
4502 *magick_restrict live_nexus;
4507 live_nexus=(NexusInfo *) NULL;
4508 if ((cache_info->nexus_info != (NexusInfo **) NULL) &&
4509 (source_threads <= cache_info->number_threads))
4511 if (nexus_index < (ssize_t) source_threads)
4512 live_nexus=cache_info->nexus_info[nexus_index];
4514 live_nexus=cache_info->nexus_info[nexus_index-(ssize_t)
4515 source_threads]->virtual_nexus;
4517 *nexus_info=live_nexus;
4518 if (live_nexus == (NexusInfo *) NULL)
4520 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4521 "UnableToGetCacheNexus",
"`%s'",image->filename);
4522 return((Quantum *) NULL);
4525 if (*nexus_info == (NexusInfo *) NULL)
4526 return((Quantum *) NULL);
4527 if ((columns == 0) || (rows == 0) ||
4528 (cache_info->columns == 0) || (cache_info->rows == 0) ||
4529 (x < 0) || (y < 0) ||
4530 (x >= (ssize_t) cache_info->columns) ||
4531 (y >= (ssize_t) cache_info->rows))
4533 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4534 "PixelsAreNotAuthentic",
"`%s'",image->filename);
4535 return((Quantum *) NULL);
4537 if (IsValidPixelOffset(y,cache_info->columns) == MagickFalse)
4538 return((Quantum *) NULL);
4539 offset=y*(MagickOffsetType) cache_info->columns;
4540 if (IsOffsetOverflow(offset,(MagickOffsetType) x) == MagickFalse)
4541 return((Quantum *) NULL);
4544 return((Quantum *) NULL);
4545 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
4546 if (((MagickSizeType) rows-1) > ((MagickSizeType) MAGICK_SSIZE_MAX/cache_info->columns))
4547 return((Quantum *) NULL);
4548 offset+=((MagickOffsetType) rows-1)*(MagickOffsetType) cache_info->columns;
4549 if (IsOffsetOverflow(offset,(MagickOffsetType) columns-1) == MagickFalse)
4550 return((Quantum *) NULL);
4551 offset+=(MagickOffsetType) columns-1;
4552 if ((MagickSizeType) offset >= number_pixels)
4553 return((Quantum *) NULL);
4557 pixels=SetPixelCacheNexusPixels(cache_info,WriteMode,x,y,columns,rows,
4558 ((image->channels & WriteMaskChannel) != 0) ||
4559 ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
4560 *nexus_info,exception);
4564MagickPrivate Quantum *QueueAuthenticPixelCacheNexus(Image *image,
4565 const ssize_t x,
const ssize_t y,
const size_t columns,
const size_t rows,
4566 const MagickBooleanType clone,NexusInfo *nexus_info,ExceptionInfo *exception)
4568 return(QueueAuthenticPixelCacheNexusInternal(image,x,y,columns,rows,clone,
4569 &nexus_info,exception));
4605static Quantum *QueueAuthenticPixelsCache(Image *image,
const ssize_t x,
4606 const ssize_t y,
const size_t columns,
const size_t rows,
4607 ExceptionInfo *exception)
4610 *magick_restrict cache_info;
4613 id = GetOpenMPThreadId();
4616 *magick_restrict pixels;
4618 assert(image != (
const Image *) NULL);
4619 assert(image->signature == MagickCoreSignature);
4620 assert(image->cache != (Cache) NULL);
4621 cache_info=(CacheInfo *) image->cache;
4622 assert(cache_info->signature == MagickCoreSignature);
4623 assert(
id < (
int) cache_info->number_threads);
4624 pixels=QueueAuthenticPixelCacheNexus(image,x,y,columns,rows,MagickFalse,
4625 cache_info->nexus_info[
id],exception);
4685MagickExport Quantum *QueueAuthenticPixels(Image *image,
const ssize_t x,
4686 const ssize_t y,
const size_t columns,
const size_t rows,
4687 ExceptionInfo *exception)
4690 *magick_restrict cache_info;
4693 id = GetOpenMPThreadId();
4696 *magick_restrict pixels;
4698 assert(image != (Image *) NULL);
4699 assert(image->signature == MagickCoreSignature);
4700 assert(image->cache != (Cache) NULL);
4701 cache_info=(CacheInfo *) image->cache;
4702 assert(cache_info->signature == MagickCoreSignature);
4703 if (cache_info->methods.queue_authentic_pixels_handler !=
4704 (QueueAuthenticPixelsHandler) NULL)
4706 pixels=cache_info->methods.queue_authentic_pixels_handler(image,x,y,
4707 columns,rows,exception);
4710 assert(
id < (
int) cache_info->number_threads);
4711 pixels=QueueAuthenticPixelCacheNexus(image,x,y,columns,rows,MagickFalse,
4712 cache_info->nexus_info[
id],exception);
4745static inline MagickOffsetType ReadPixelCacheRegion(
4746 const CacheInfo *magick_restrict cache_info,
const MagickOffsetType offset,
4747 const MagickSizeType length,
unsigned char *magick_restrict buffer)
4755#if !defined(MAGICKCORE_HAVE_PREAD)
4756 if (lseek(cache_info->file,offset,SEEK_SET) < 0)
4757 return((MagickOffsetType) -1);
4759 for (i=0; i < (MagickOffsetType) length; i+=count)
4764 extent=(size_t) MagickMin(length-(MagickSizeType) i,
4765 (
size_t) MagickMaxBufferExtent);
4766#if defined(MAGICKCORE_HAVE_PREAD)
4767 count=pread(cache_info->file,buffer+i,extent,(off_t) (offset+i));
4768 if ((count < 0) && (errno == EINTR))
4774 count=MagickRead(cache_info->file,buffer+i,extent);
4782static MagickBooleanType ReadPixelCacheMetacontent(
4783 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
4784 ExceptionInfo *exception)
4803 if (cache_info->metacontent_extent == 0)
4804 return(MagickFalse);
4805 if (nexus_info->authentic_pixel_cache != MagickFalse)
4807 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
4808 return(MagickFalse);
4809 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
4810 nexus_info->region.x;
4811 length=(MagickSizeType) nexus_info->region.width*
4812 cache_info->metacontent_extent;
4813 extent=length*nexus_info->region.height;
4814 rows=nexus_info->region.height;
4816 q=(
unsigned char *) nexus_info->metacontent;
4817 switch (cache_info->type)
4828 if ((cache_info->columns == nexus_info->region.width) &&
4829 (extent == (MagickSizeType) ((
size_t) extent)))
4834 p=(
unsigned char *) cache_info->metacontent+offset*(MagickOffsetType)
4835 cache_info->metacontent_extent;
4836 for (y=0; y < (ssize_t) rows; y++)
4838 (void) memcpy(q,p,(
size_t) length);
4839 p+=(ptrdiff_t) (cache_info->metacontent_extent*cache_info->columns);
4840 q+=(ptrdiff_t) (cache_info->metacontent_extent*
4841 nexus_info->region.width);
4850 LockSemaphoreInfo(cache_info->file_semaphore);
4851 if (OpenPixelCacheOnDisk(cache_info,IOMode,exception) == MagickFalse)
4853 ThrowFileException(exception,FileOpenError,
"UnableToOpenFile",
4854 cache_info->cache_filename);
4855 UnlockSemaphoreInfo(cache_info->file_semaphore);
4856 return(MagickFalse);
4858 if ((cache_info->columns == nexus_info->region.width) &&
4859 (extent <= MagickMaxBufferExtent))
4864 extent=(MagickSizeType) cache_info->columns*cache_info->rows;
4865 for (y=0; y < (ssize_t) rows; y++)
4867 count=ReadPixelCacheRegion(cache_info,cache_info->offset+
4868 (MagickOffsetType) extent*(MagickOffsetType)
4869 cache_info->number_channels*(MagickOffsetType)
sizeof(Quantum)+offset*
4870 (MagickOffsetType) cache_info->metacontent_extent,length,
4871 (
unsigned char *) q);
4872 if (count != (MagickOffsetType) length)
4874 offset+=(MagickOffsetType) cache_info->columns;
4875 q+=(ptrdiff_t) (cache_info->metacontent_extent*
4876 nexus_info->region.width);
4878 if (IsFileDescriptorLimitExceeded() != MagickFalse)
4879 (void) ClosePixelCacheOnDisk(cache_info);
4880 UnlockSemaphoreInfo(cache_info->file_semaphore);
4883 case DistributedCache:
4891 LockSemaphoreInfo(cache_info->file_semaphore);
4892 region=nexus_info->region;
4893 if ((cache_info->columns != nexus_info->region.width) ||
4894 (extent > MagickMaxBufferExtent))
4901 for (y=0; y < (ssize_t) rows; y++)
4903 count=ReadDistributePixelCacheMetacontent((DistributeCacheInfo *)
4904 cache_info->server_info,®ion,length,(
unsigned char *) q);
4905 if (count != (MagickOffsetType) length)
4907 q+=(ptrdiff_t) (cache_info->metacontent_extent*
4908 nexus_info->region.width);
4911 UnlockSemaphoreInfo(cache_info->file_semaphore);
4917 if (y < (ssize_t) rows)
4919 ThrowFileException(exception,CacheError,
"UnableToReadPixelCache",
4920 cache_info->cache_filename);
4921 return(MagickFalse);
4923 if ((cache_info->debug != MagickFalse) &&
4924 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
4925 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
4926 "%s[%.17gx%.17g%+.20g%+.20g]",cache_info->filename,(
double)
4927 nexus_info->region.width,(
double) nexus_info->region.height,(
double)
4928 nexus_info->region.x,(
double) nexus_info->region.y);
4960static MagickBooleanType ReadPixelCachePixels(
4961 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
4962 ExceptionInfo *exception)
4982 if (nexus_info->authentic_pixel_cache != MagickFalse)
4984 if (cache_info->columns == 0)
4985 return(MagickFalse);
4986 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
4987 return(MagickFalse);
4988 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns;
4989 if ((offset/(ssize_t) cache_info->columns) != nexus_info->region.y)
4990 return(MagickFalse);
4991 offset+=nexus_info->region.x;
4992 number_channels=cache_info->number_channels;
4993 length=(MagickSizeType) number_channels*nexus_info->region.width*
4995 if ((length/number_channels/
sizeof(Quantum)) != nexus_info->region.width)
4996 return(MagickFalse);
4997 rows=nexus_info->region.height;
4999 if ((extent == 0) || ((extent/length) != rows))
5000 return(MagickFalse);
5002 q=nexus_info->pixels;
5003 switch (cache_info->type)
5014 if ((cache_info->columns == nexus_info->region.width) &&
5015 (extent == (MagickSizeType) ((
size_t) extent)))
5020 p=cache_info->pixels+(MagickOffsetType) cache_info->number_channels*
5022 for (y=0; y < (ssize_t) rows; y++)
5024 (void) memcpy(q,p,(
size_t) length);
5025 p+=(ptrdiff_t) (cache_info->number_channels*cache_info->columns);
5026 q+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
5035 LockSemaphoreInfo(cache_info->file_semaphore);
5036 if (OpenPixelCacheOnDisk(cache_info,IOMode,exception) == MagickFalse)
5038 ThrowFileException(exception,FileOpenError,
"UnableToOpenFile",
5039 cache_info->cache_filename);
5040 UnlockSemaphoreInfo(cache_info->file_semaphore);
5041 return(MagickFalse);
5043 if ((cache_info->columns == nexus_info->region.width) &&
5044 (extent <= MagickMaxBufferExtent))
5049 for (y=0; y < (ssize_t) rows; y++)
5051 count=ReadPixelCacheRegion(cache_info,cache_info->offset+offset*
5052 (MagickOffsetType) cache_info->number_channels*(MagickOffsetType)
5053 sizeof(*q),length,(
unsigned char *) q);
5054 if (count != (MagickOffsetType) length)
5056 offset+=(MagickOffsetType) cache_info->columns;
5057 q+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
5059 if (IsFileDescriptorLimitExceeded() != MagickFalse)
5060 (void) ClosePixelCacheOnDisk(cache_info);
5061 UnlockSemaphoreInfo(cache_info->file_semaphore);
5064 case DistributedCache:
5072 LockSemaphoreInfo(cache_info->file_semaphore);
5073 region=nexus_info->region;
5074 if ((cache_info->columns != nexus_info->region.width) ||
5075 (extent > MagickMaxBufferExtent))
5082 for (y=0; y < (ssize_t) rows; y++)
5084 count=ReadDistributePixelCachePixels((DistributeCacheInfo *)
5085 cache_info->server_info,®ion,length,(
unsigned char *) q);
5086 if (count != (MagickOffsetType) length)
5088 q+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
5091 UnlockSemaphoreInfo(cache_info->file_semaphore);
5097 if (y < (ssize_t) rows)
5099 ThrowFileException(exception,CacheError,
"UnableToReadPixelCache",
5100 cache_info->cache_filename);
5101 return(MagickFalse);
5103 if ((cache_info->debug != MagickFalse) &&
5104 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
5105 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
5106 "%s[%.17gx%.17g%+.20g%+.20g]",cache_info->filename,(
double)
5107 nexus_info->region.width,(
double) nexus_info->region.height,(
double)
5108 nexus_info->region.x,(
double) nexus_info->region.y);
5135MagickPrivate Cache ReferencePixelCache(Cache cache)
5138 *magick_restrict cache_info;
5140 assert(cache != (Cache *) NULL);
5141 cache_info=(CacheInfo *) cache;
5142 assert(cache_info->signature == MagickCoreSignature);
5143 LockSemaphoreInfo(cache_info->semaphore);
5144 cache_info->reference_count++;
5145 UnlockSemaphoreInfo(cache_info->semaphore);
5171MagickPrivate
void ResetPixelCacheChannels(Image *image)
5174 *magick_restrict cache_info;
5176 assert(image != (
const Image *) NULL);
5177 assert(image->signature == MagickCoreSignature);
5178 assert(image->cache != (Cache) NULL);
5179 cache_info=(CacheInfo *) image->cache;
5180 assert(cache_info->signature == MagickCoreSignature);
5181 cache_info->number_channels=GetPixelChannels(image);
5202MagickPrivate
void ResetCacheAnonymousMemory(
void)
5204 cache_anonymous_memory=0;
5236MagickExport MagickBooleanType ReshapePixelCache(Image *image,
5237 const size_t columns,
const size_t rows,ExceptionInfo *exception)
5245 assert(image != (Image *) NULL);
5246 assert(image->signature == MagickCoreSignature);
5247 if (IsEventLogging() != MagickFalse)
5248 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
5249 assert(image->cache != (
void *) NULL);
5250 extent=(MagickSizeType) columns*rows;
5251 if (extent > ((MagickSizeType) image->columns*image->rows))
5252 ThrowBinaryException(ImageError,
"WidthOrHeightExceedsLimit",
5254 image->columns=columns;
5256 cache_info=(CacheInfo *) image->cache;
5257 cache_info->columns=columns;
5258 cache_info->rows=rows;
5259 return(SyncImagePixelCache(image,exception));
5286MagickPrivate
void SetPixelCacheMethods(Cache cache,CacheMethods *cache_methods)
5289 *magick_restrict cache_info;
5291 GetOneAuthenticPixelFromHandler
5292 get_one_authentic_pixel_from_handler;
5294 GetOneVirtualPixelFromHandler
5295 get_one_virtual_pixel_from_handler;
5300 assert(cache != (Cache) NULL);
5301 assert(cache_methods != (CacheMethods *) NULL);
5302 cache_info=(CacheInfo *) cache;
5303 assert(cache_info->signature == MagickCoreSignature);
5304 if (IsEventLogging() != MagickFalse)
5305 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
5306 cache_info->filename);
5307 if (cache_methods->get_virtual_pixel_handler != (GetVirtualPixelHandler) NULL)
5308 cache_info->methods.get_virtual_pixel_handler=
5309 cache_methods->get_virtual_pixel_handler;
5310 if (cache_methods->destroy_pixel_handler != (DestroyPixelHandler) NULL)
5311 cache_info->methods.destroy_pixel_handler=
5312 cache_methods->destroy_pixel_handler;
5313 if (cache_methods->get_virtual_metacontent_from_handler !=
5314 (GetVirtualMetacontentFromHandler) NULL)
5315 cache_info->methods.get_virtual_metacontent_from_handler=
5316 cache_methods->get_virtual_metacontent_from_handler;
5317 if (cache_methods->get_authentic_pixels_handler !=
5318 (GetAuthenticPixelsHandler) NULL)
5319 cache_info->methods.get_authentic_pixels_handler=
5320 cache_methods->get_authentic_pixels_handler;
5321 if (cache_methods->queue_authentic_pixels_handler !=
5322 (QueueAuthenticPixelsHandler) NULL)
5323 cache_info->methods.queue_authentic_pixels_handler=
5324 cache_methods->queue_authentic_pixels_handler;
5325 if (cache_methods->sync_authentic_pixels_handler !=
5326 (SyncAuthenticPixelsHandler) NULL)
5327 cache_info->methods.sync_authentic_pixels_handler=
5328 cache_methods->sync_authentic_pixels_handler;
5329 if (cache_methods->get_authentic_pixels_from_handler !=
5330 (GetAuthenticPixelsFromHandler) NULL)
5331 cache_info->methods.get_authentic_pixels_from_handler=
5332 cache_methods->get_authentic_pixels_from_handler;
5333 if (cache_methods->get_authentic_metacontent_from_handler !=
5334 (GetAuthenticMetacontentFromHandler) NULL)
5335 cache_info->methods.get_authentic_metacontent_from_handler=
5336 cache_methods->get_authentic_metacontent_from_handler;
5337 get_one_virtual_pixel_from_handler=
5338 cache_methods->get_one_virtual_pixel_from_handler;
5339 if (get_one_virtual_pixel_from_handler !=
5340 (GetOneVirtualPixelFromHandler) NULL)
5341 cache_info->methods.get_one_virtual_pixel_from_handler=
5342 get_one_virtual_pixel_from_handler;
5343 get_one_authentic_pixel_from_handler=
5344 cache_methods->get_one_authentic_pixel_from_handler;
5345 if (get_one_authentic_pixel_from_handler !=
5346 (GetOneAuthenticPixelFromHandler) NULL)
5347 cache_info->methods.get_one_authentic_pixel_from_handler=
5348 get_one_authentic_pixel_from_handler;
5389static inline MagickBooleanType AcquireCacheNexusPixels(
5390 const CacheInfo *magick_restrict cache_info,
const MagickSizeType length,
5391 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
5393 nexus_info->length=0;
5394 nexus_info->mapped=MagickFalse;
5395 if (length != (MagickSizeType) ((
size_t) length))
5397 (void) ThrowMagickException(exception,GetMagickModule(),
5398 ResourceLimitError,
"PixelCacheAllocationFailed",
"`%s'",
5399 cache_info->filename);
5400 return(MagickFalse);
5402 if (cache_anonymous_memory <= 0)
5404 nexus_info->cache=(Quantum *) MagickAssumeAligned(AcquireAlignedMemory(1,
5406 if (nexus_info->cache != (Quantum *) NULL)
5407 (void) memset(nexus_info->cache,0,(
size_t) length);
5411 nexus_info->cache=(Quantum *) MapBlob(-1,IOMode,0,(
size_t) length);
5412 if (nexus_info->cache != (Quantum *) NULL)
5413 nexus_info->mapped=MagickTrue;
5415 if (nexus_info->cache == (Quantum *) NULL)
5417 (void) ThrowMagickException(exception,GetMagickModule(),
5418 ResourceLimitError,
"PixelCacheAllocationFailed",
"`%s'",
5419 cache_info->filename);
5420 return(MagickFalse);
5422 nexus_info->length=length;
5426static inline void PrefetchPixelCacheNexusPixels(
const NexusInfo *nexus_info,
5429 if (nexus_info->length < CACHE_LINE_SIZE)
5431 if (mode == ReadMode)
5433 MagickCachePrefetch((
unsigned char *) nexus_info->pixels+CACHE_LINE_SIZE,
5437 MagickCachePrefetch((
unsigned char *) nexus_info->pixels+CACHE_LINE_SIZE,1,1);
5440static Quantum *SetPixelCacheNexusPixels(
5441 const CacheInfo *magick_restrict cache_info,
const MapMode mode,
5442 const ssize_t x,
const ssize_t y,
const size_t width,
const size_t height,
5443 const MagickBooleanType buffered,NexusInfo *magick_restrict nexus_info,
5444 ExceptionInfo *exception)
5453 assert(cache_info != (
const CacheInfo *) NULL);
5454 assert(cache_info->signature == MagickCoreSignature);
5455 if (cache_info->type == UndefinedCache)
5456 return((Quantum *) NULL);
5457 assert(nexus_info->signature == MagickCoreSignature);
5458 (void) memset(&nexus_info->region,0,
sizeof(nexus_info->region));
5459 if ((width == 0) || (height == 0))
5461 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
5462 "NoPixelsDefinedInCache",
"`%s'",cache_info->filename);
5463 return((Quantum *) NULL);
5465 if (((MagickSizeType) width > cache_info->width_limit) ||
5466 ((MagickSizeType) height > cache_info->height_limit))
5468 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
5469 "WidthOrHeightExceedsLimit",
"`%s'",cache_info->filename);
5470 return((Quantum *) NULL);
5472 if ((IsValidPixelOffset(x,width) == MagickFalse) ||
5473 (IsValidPixelOffset(y,height) == MagickFalse))
5475 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
5476 "InvalidPixel",
"`%s'",cache_info->filename);
5477 return((Quantum *) NULL);
5479 if (((cache_info->type == MemoryCache) || (cache_info->type == MapCache)) &&
5480 (buffered == MagickFalse))
5482 if (((x >= 0) && (y >= 0) &&
5483 (((ssize_t) height+y-1) < (ssize_t) cache_info->rows)) &&
5484 (((x == 0) && (width == cache_info->columns)) || ((height == 1) &&
5485 (((ssize_t) width+x-1) < (ssize_t) cache_info->columns))))
5493 if (IsValidPixelOffset(y,cache_info->columns) == MagickFalse)
5494 return((Quantum *) NULL);
5495 offset=y*(MagickOffsetType) cache_info->columns+x;
5496 nexus_info->pixels=cache_info->pixels+(MagickOffsetType)
5497 cache_info->number_channels*offset;
5498 nexus_info->metacontent=(
void *) NULL;
5499 if (cache_info->metacontent_extent != 0)
5500 nexus_info->metacontent=(
unsigned char *) cache_info->metacontent+
5501 offset*(MagickOffsetType) cache_info->metacontent_extent;
5502 nexus_info->region.width=width;
5503 nexus_info->region.height=height;
5504 nexus_info->region.x=x;
5505 nexus_info->region.y=y;
5506 nexus_info->authentic_pixel_cache=MagickTrue;
5507 PrefetchPixelCacheNexusPixels(nexus_info,mode);
5508 return(nexus_info->pixels);
5514 if (CacheOverflowSanityCheckGetSize(width,height,&number_pixels) != MagickFalse)
5516 (void) ThrowMagickException(exception,GetMagickModule(),
5517 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
5518 cache_info->filename);
5519 return((Quantum *) NULL);
5526 packets=MagickMax(number_pixels,MagickMax(cache_info->columns,
5528 if ((CacheOverflowSanityCheckGetSize(packets,cache_info->number_channels,&length) != MagickFalse) ||
5529 (CacheOverflowSanityCheckGetSize(length,
sizeof(*nexus_info->pixels),&length) != MagickFalse))
5531 (void) ThrowMagickException(exception,GetMagickModule(),
5532 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
5533 cache_info->filename);
5534 return((Quantum *) NULL);
5536 if (cache_info->metacontent_extent != 0)
5538 if ((CacheOverflowSanityCheckGetSize(number_pixels,cache_info->metacontent_extent,&extent) != MagickFalse) ||
5539 (extent > (MagickSizeType) (~((MagickSizeType) 0))-length))
5541 (void) ThrowMagickException(exception,GetMagickModule(),
5542 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
5543 cache_info->filename);
5544 return((Quantum *) NULL);
5550 if (nexus_info->cache == (Quantum *) NULL)
5551 status=AcquireCacheNexusPixels(cache_info,length,nexus_info,exception);
5553 if (nexus_info->length < length)
5555 RelinquishCacheNexusPixels(nexus_info);
5556 status=AcquireCacheNexusPixels(cache_info,length,nexus_info,exception);
5558 if (status == MagickFalse)
5559 return((Quantum *) NULL);
5560 nexus_info->pixels=nexus_info->cache;
5561 nexus_info->metacontent=(
void *) NULL;
5562 if (cache_info->metacontent_extent != 0)
5563 nexus_info->metacontent=(
void *) (nexus_info->pixels+
5564 cache_info->number_channels*number_pixels);
5565 nexus_info->region.width=width;
5566 nexus_info->region.height=height;
5567 nexus_info->region.x=x;
5568 nexus_info->region.y=y;
5569 nexus_info->authentic_pixel_cache=cache_info->type == PingCache ?
5570 MagickTrue : MagickFalse;
5571 PrefetchPixelCacheNexusPixels(nexus_info,mode);
5572 return(nexus_info->pixels);
5605static MagickBooleanType SetCacheAlphaChannel(Image *image,
const Quantum alpha,
5606 ExceptionInfo *exception)
5609 *magick_restrict image_view;
5617 assert(image != (Image *) NULL);
5618 assert(image->signature == MagickCoreSignature);
5619 if (IsEventLogging() != MagickFalse)
5620 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
5621 assert(image->cache != (Cache) NULL);
5622 image->alpha_trait=BlendPixelTrait;
5624 image_view=AcquireVirtualCacheView(image,exception);
5625#if defined(MAGICKCORE_OPENMP_SUPPORT)
5626 #pragma omp parallel for schedule(static) shared(status) \
5627 magick_number_threads(image,image,image->rows,2)
5629 for (y=0; y < (ssize_t) image->rows; y++)
5637 if (status == MagickFalse)
5639 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
5640 if (q == (Quantum *) NULL)
5645 for (x=0; x < (ssize_t) image->columns; x++)
5647 SetPixelAlpha(image,alpha,q);
5648 q+=(ptrdiff_t) GetPixelChannels(image);
5650 status=SyncCacheViewAuthenticPixels(image_view,exception);
5652 image_view=DestroyCacheView(image_view);
5656MagickPrivate VirtualPixelMethod SetPixelCacheVirtualMethod(Image *image,
5657 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
5660 *magick_restrict cache_info;
5665 assert(image != (Image *) NULL);
5666 assert(image->signature == MagickCoreSignature);
5667 if (IsEventLogging() != MagickFalse)
5668 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
5669 assert(image->cache != (Cache) NULL);
5670 cache_info=(CacheInfo *) image->cache;
5671 assert(cache_info->signature == MagickCoreSignature);
5672 method=cache_info->virtual_pixel_method;
5673 cache_info->virtual_pixel_method=virtual_pixel_method;
5674 if ((image->columns != 0) && (image->rows != 0))
5675 switch (virtual_pixel_method)
5677 case BackgroundVirtualPixelMethod:
5679 if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
5680 ((image->alpha_trait & BlendPixelTrait) == 0))
5681 (void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
5682 if ((IsPixelInfoGray(&image->background_color) == MagickFalse) &&
5683 (IsGrayColorspace(image->colorspace) != MagickFalse))
5684 (void) SetImageColorspace(image,sRGBColorspace,exception);
5687 case TransparentVirtualPixelMethod:
5689 if ((image->alpha_trait & BlendPixelTrait) == 0)
5690 (void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
5699#if defined(MAGICKCORE_OPENCL_SUPPORT)
5724static void CopyOpenCLBuffer(CacheInfo *magick_restrict cache_info)
5726 assert(cache_info != (CacheInfo *) NULL);
5727 assert(cache_info->signature == MagickCoreSignature);
5728 if ((cache_info->type != MemoryCache) ||
5729 (cache_info->opencl == (MagickCLCacheInfo) NULL))
5734 LockSemaphoreInfo(cache_info->semaphore);
5735 cache_info->opencl=CopyMagickCLCacheInfo(cache_info->opencl);
5736 UnlockSemaphoreInfo(cache_info->semaphore);
5739MagickPrivate
void SyncAuthenticOpenCLBuffer(
const Image *image)
5742 *magick_restrict cache_info;
5744 assert(image != (
const Image *) NULL);
5745 cache_info=(CacheInfo *) image->cache;
5746 CopyOpenCLBuffer(cache_info);
5779MagickPrivate MagickBooleanType SyncAuthenticPixelCacheNexus(Image *image,
5780 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
5783 *magick_restrict cache_info;
5791 assert(image != (Image *) NULL);
5792 assert(image->signature == MagickCoreSignature);
5793 if (image->cache == (Cache) NULL)
5794 ThrowBinaryException(CacheError,
"PixelCacheIsNotOpen",image->filename);
5795 cache_info=(CacheInfo *) image->cache;
5796 assert(cache_info->signature == MagickCoreSignature);
5797 if (cache_info->type == UndefinedCache)
5798 return(MagickFalse);
5799 if ((image->mask_trait & UpdatePixelTrait) != 0)
5801 if (((image->channels & WriteMaskChannel) != 0) &&
5802 (ClipPixelCacheNexus(image,nexus_info,exception) == MagickFalse))
5803 return(MagickFalse);
5804 if (((image->channels & CompositeMaskChannel) != 0) &&
5805 (MaskPixelCacheNexus(image,nexus_info,exception) == MagickFalse))
5806 return(MagickFalse);
5808 if (nexus_info->authentic_pixel_cache != MagickFalse)
5810 if (image->taint == MagickFalse)
5811 image->taint=MagickTrue;
5814 assert(cache_info->signature == MagickCoreSignature);
5815 status=WritePixelCachePixels(cache_info,nexus_info,exception);
5816 if ((cache_info->metacontent_extent != 0) &&
5817 (WritePixelCacheMetacontent(cache_info,nexus_info,exception) == MagickFalse))
5818 return(MagickFalse);
5819 if ((status != MagickFalse) && (image->taint == MagickFalse))
5820 image->taint=MagickTrue;
5851static MagickBooleanType SyncAuthenticPixelsCache(Image *image,
5852 ExceptionInfo *exception)
5855 *magick_restrict cache_info;
5858 id = GetOpenMPThreadId();
5863 assert(image != (Image *) NULL);
5864 assert(image->signature == MagickCoreSignature);
5865 assert(image->cache != (Cache) NULL);
5866 cache_info=(CacheInfo *) image->cache;
5867 assert(cache_info->signature == MagickCoreSignature);
5868 assert(
id < (
int) cache_info->number_threads);
5869 status=SyncAuthenticPixelCacheNexus(image,cache_info->nexus_info[
id],
5901MagickExport MagickBooleanType SyncAuthenticPixels(Image *image,
5902 ExceptionInfo *exception)
5905 *magick_restrict cache_info;
5908 id = GetOpenMPThreadId();
5913 assert(image != (Image *) NULL);
5914 assert(image->signature == MagickCoreSignature);
5915 assert(image->cache != (Cache) NULL);
5916 cache_info=(CacheInfo *) image->cache;
5917 assert(cache_info->signature == MagickCoreSignature);
5918 if (cache_info->methods.sync_authentic_pixels_handler != (SyncAuthenticPixelsHandler) NULL)
5920 status=cache_info->methods.sync_authentic_pixels_handler(image,
5924 assert(
id < (
int) cache_info->number_threads);
5925 status=SyncAuthenticPixelCacheNexus(image,cache_info->nexus_info[
id],
5957MagickPrivate MagickBooleanType SyncImagePixelCache(Image *image,
5958 ExceptionInfo *exception)
5961 *magick_restrict cache_info;
5963 assert(image != (Image *) NULL);
5964 assert(exception != (ExceptionInfo *) NULL);
5965 cache_info=(CacheInfo *) GetImagePixelCache(image,MagickTrue,exception);
5966 return(cache_info == (CacheInfo *) NULL ? MagickFalse : MagickTrue);
5997static MagickBooleanType WritePixelCacheMetacontent(CacheInfo *cache_info,
5998 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
6017 if (cache_info->metacontent_extent == 0)
6018 return(MagickFalse);
6019 if (nexus_info->authentic_pixel_cache != MagickFalse)
6021 if (nexus_info->metacontent == (
unsigned char *) NULL)
6022 return(MagickFalse);
6023 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
6024 return(MagickFalse);
6025 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
6026 nexus_info->region.x;
6027 length=(MagickSizeType) nexus_info->region.width*
6028 cache_info->metacontent_extent;
6029 extent=(MagickSizeType) length*nexus_info->region.height;
6030 rows=nexus_info->region.height;
6032 p=(
unsigned char *) nexus_info->metacontent;
6033 switch (cache_info->type)
6044 if ((cache_info->columns == nexus_info->region.width) &&
6045 (extent == (MagickSizeType) ((
size_t) extent)))
6050 q=(
unsigned char *) cache_info->metacontent+offset*
6051 (MagickOffsetType) cache_info->metacontent_extent;
6052 for (y=0; y < (ssize_t) rows; y++)
6054 (void) memcpy(q,p,(
size_t) length);
6055 p+=(ptrdiff_t) (nexus_info->region.width*
6056 cache_info->metacontent_extent);
6057 q+=(ptrdiff_t) (cache_info->columns*cache_info->metacontent_extent);
6066 LockSemaphoreInfo(cache_info->file_semaphore);
6067 if (OpenPixelCacheOnDisk(cache_info,IOMode,exception) == MagickFalse)
6069 ThrowFileException(exception,FileOpenError,
"UnableToOpenFile",
6070 cache_info->cache_filename);
6071 UnlockSemaphoreInfo(cache_info->file_semaphore);
6072 return(MagickFalse);
6074 if ((cache_info->columns == nexus_info->region.width) &&
6075 (extent <= MagickMaxBufferExtent))
6080 extent=(MagickSizeType) cache_info->columns*cache_info->rows;
6081 for (y=0; y < (ssize_t) rows; y++)
6083 count=WritePixelCacheRegion(cache_info,cache_info->offset+
6084 (MagickOffsetType) extent*(MagickOffsetType)
6085 cache_info->number_channels*(MagickOffsetType)
sizeof(Quantum)+offset*
6086 (MagickOffsetType) cache_info->metacontent_extent,length,
6087 (
const unsigned char *) p);
6088 if (count != (MagickOffsetType) length)
6090 p+=(ptrdiff_t) (cache_info->metacontent_extent*
6091 nexus_info->region.width);
6092 offset+=(MagickOffsetType) cache_info->columns;
6094 if (IsFileDescriptorLimitExceeded() != MagickFalse)
6095 (void) ClosePixelCacheOnDisk(cache_info);
6096 UnlockSemaphoreInfo(cache_info->file_semaphore);
6099 case DistributedCache:
6107 LockSemaphoreInfo(cache_info->file_semaphore);
6108 region=nexus_info->region;
6109 if ((cache_info->columns != nexus_info->region.width) ||
6110 (extent > MagickMaxBufferExtent))
6117 for (y=0; y < (ssize_t) rows; y++)
6119 count=WriteDistributePixelCacheMetacontent((DistributeCacheInfo *)
6120 cache_info->server_info,®ion,length,(
const unsigned char *) p);
6121 if (count != (MagickOffsetType) length)
6123 p+=(ptrdiff_t) (cache_info->metacontent_extent*
6124 nexus_info->region.width);
6127 UnlockSemaphoreInfo(cache_info->file_semaphore);
6133 if (y < (ssize_t) rows)
6135 ThrowFileException(exception,CacheError,
"UnableToWritePixelCache",
6136 cache_info->cache_filename);
6137 return(MagickFalse);
6139 if ((cache_info->debug != MagickFalse) &&
6140 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
6141 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
6142 "%s[%.17gx%.17g%+.20g%+.20g]",cache_info->filename,(
double)
6143 nexus_info->region.width,(
double) nexus_info->region.height,(
double)
6144 nexus_info->region.x,(
double) nexus_info->region.y);
6176static MagickBooleanType WritePixelCachePixels(
6177 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
6178 ExceptionInfo *exception)
6197 if (nexus_info->authentic_pixel_cache != MagickFalse)
6199 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
6200 return(MagickFalse);
6201 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
6202 nexus_info->region.x;
6203 length=(MagickSizeType) cache_info->number_channels*nexus_info->region.width*
6205 extent=length*nexus_info->region.height;
6206 rows=nexus_info->region.height;
6208 p=nexus_info->pixels;
6209 switch (cache_info->type)
6220 if ((cache_info->columns == nexus_info->region.width) &&
6221 (extent == (MagickSizeType) ((
size_t) extent)))
6226 q=cache_info->pixels+(MagickOffsetType) cache_info->number_channels*
6228 for (y=0; y < (ssize_t) rows; y++)
6230 (void) memcpy(q,p,(
size_t) length);
6231 p+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
6232 q+=(ptrdiff_t) (cache_info->number_channels*cache_info->columns);
6241 LockSemaphoreInfo(cache_info->file_semaphore);
6242 if (OpenPixelCacheOnDisk(cache_info,IOMode,exception) == MagickFalse)
6244 ThrowFileException(exception,FileOpenError,
"UnableToOpenFile",
6245 cache_info->cache_filename);
6246 UnlockSemaphoreInfo(cache_info->file_semaphore);
6247 return(MagickFalse);
6249 if ((cache_info->columns == nexus_info->region.width) &&
6250 (extent <= MagickMaxBufferExtent))
6255 for (y=0; y < (ssize_t) rows; y++)
6257 count=WritePixelCacheRegion(cache_info,cache_info->offset+offset*
6258 (MagickOffsetType) cache_info->number_channels*(MagickOffsetType)
6259 sizeof(*p),length,(
const unsigned char *) p);
6260 if (count != (MagickOffsetType) length)
6262 p+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
6263 offset+=(MagickOffsetType) cache_info->columns;
6265 if (IsFileDescriptorLimitExceeded() != MagickFalse)
6266 (void) ClosePixelCacheOnDisk(cache_info);
6267 UnlockSemaphoreInfo(cache_info->file_semaphore);
6270 case DistributedCache:
6278 LockSemaphoreInfo(cache_info->file_semaphore);
6279 region=nexus_info->region;
6280 if ((cache_info->columns != nexus_info->region.width) ||
6281 (extent > MagickMaxBufferExtent))
6288 for (y=0; y < (ssize_t) rows; y++)
6290 count=WriteDistributePixelCachePixels((DistributeCacheInfo *)
6291 cache_info->server_info,®ion,length,(
const unsigned char *) p);
6292 if (count != (MagickOffsetType) length)
6294 p+=(ptrdiff_t) (cache_info->number_channels*nexus_info->region.width);
6297 UnlockSemaphoreInfo(cache_info->file_semaphore);
6303 if (y < (ssize_t) rows)
6305 ThrowFileException(exception,CacheError,
"UnableToWritePixelCache",
6306 cache_info->cache_filename);
6307 return(MagickFalse);
6309 if ((cache_info->debug != MagickFalse) &&
6310 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
6311 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
6312 "%s[%.17gx%.17g%+.20g%+.20g]",cache_info->filename,(
double)
6313 nexus_info->region.width,(
double) nexus_info->region.height,(
double)
6314 nexus_info->region.x,(
double) nexus_info->region.y);