MagickCore 7.1.2-27
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
cache.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% CCCC AAA CCCC H H EEEEE %
7% C A A C H H E %
8% C AAAAA C HHHHH EEE %
9% C A A C H H E %
10% CCCC A A CCCC H H EEEEE %
11% %
12% %
13% MagickCore Pixel Cache Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1999 %
18% %
19% %
20% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
21% dedicated to making software imaging solutions freely available. %
22% %
23% You may not use this file except in compliance with the License. You may %
24% obtain a copy of the License at %
25% %
26% https://imagemagick.org/license/ %
27% %
28% Unless required by applicable law or agreed to in writing, software %
29% distributed under the License is distributed on an "AS IS" BASIS, %
30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31% See the License for the specific language governing permissions and %
32% limitations under the License. %
33% %
34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35%
36%
37%
38*/
39␌
40/*
41 Include declarations.
42*/
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/quantum.h"
67#include "MagickCore/random_.h"
68#include "MagickCore/registry.h"
69#include "MagickCore/resource_.h"
70#include "MagickCore/semaphore.h"
71#include "MagickCore/splay-tree.h"
72#include "MagickCore/string_.h"
73#include "MagickCore/string-private.h"
74#include "MagickCore/timer-private.h"
75#include "MagickCore/thread-private.h"
76#include "MagickCore/utility.h"
77#include "MagickCore/utility-private.h"
78#if defined(MAGICKCORE_HAVE_ERRNO_H)
79# include <errno.h>
80#endif
81#if defined(MAGICKCORE_HAVE_SYS_LOADAVG_H)
82# include <sys/loadavg.h>
83#endif
84#if defined(MAGICKCORE_ZLIB_DELEGATE)
85# include "zlib.h"
86#endif
87␌
88/*
89 Define declarations.
90*/
91#define CacheTick(offset,extent) QuantumTick((MagickOffsetType) offset,extent)
92#define IsFileDescriptorLimitExceeded() (GetMagickResource(FileResource) > \
93 GetMagickResourceLimit(FileResource) ? MagickTrue : MagickFalse)
94␌
95/*
96 Typedef declarations.
97*/
98typedef struct _MagickModulo
99{
100 ssize_t
101 quotient,
102 remainder;
103} MagickModulo;
104␌
105/*
106 Forward declarations.
107*/
108#if defined(__cplusplus) || defined(c_plusplus)
109extern "C" {
110#endif
111
112static Cache
113 GetImagePixelCache(Image *,const MagickBooleanType,ExceptionInfo *)
114 magick_hot_spot;
115
116static const Quantum
117 *GetVirtualPixelCache(const Image *,const VirtualPixelMethod,const ssize_t,
118 const ssize_t,const size_t,const size_t,ExceptionInfo *),
119 *GetVirtualPixelsCache(const Image *);
120
121static const void
122 *GetVirtualMetacontentFromCache(const Image *);
123
124static MagickBooleanType
125 GetOneAuthenticPixelFromCache(Image *,const ssize_t,const ssize_t,Quantum *,
126 ExceptionInfo *),
127 GetOneVirtualPixelFromCache(const Image *,const VirtualPixelMethod,
128 const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
129 OpenPixelCache(Image *,const MapMode,ExceptionInfo *),
130 OpenPixelCacheOnDisk(CacheInfo *,const MapMode),
131 ReadPixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
132 ExceptionInfo *),
133 ReadPixelCacheMetacontent(CacheInfo *magick_restrict,
134 NexusInfo *magick_restrict,ExceptionInfo *),
135 SyncAuthenticPixelsCache(Image *,ExceptionInfo *),
136 WritePixelCachePixels(CacheInfo *magick_restrict,NexusInfo *magick_restrict,
137 ExceptionInfo *),
138 WritePixelCacheMetacontent(CacheInfo *,NexusInfo *magick_restrict,
139 ExceptionInfo *);
140
141static Quantum
142 *GetAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,
143 const size_t,ExceptionInfo *),
144 *QueueAuthenticPixelsCache(Image *,const ssize_t,const ssize_t,const size_t,
145 const size_t,ExceptionInfo *),
146 *SetPixelCacheNexusPixels(const CacheInfo *magick_restrict,const MapMode,
147 const ssize_t,const ssize_t,const size_t,const size_t,
148 const MagickBooleanType,NexusInfo *magick_restrict,ExceptionInfo *)
149 magick_hot_spot;
150
151#if defined(MAGICKCORE_OPENCL_SUPPORT)
152static void
153 CopyOpenCLBuffer(CacheInfo *magick_restrict);
154#endif
155
156#if defined(__cplusplus) || defined(c_plusplus)
157}
158#endif
159␌
160/*
161 Global declarations.
162*/
163static SemaphoreInfo
164 *cache_semaphore = (SemaphoreInfo *) NULL;
165
166static ssize_t
167 cache_anonymous_memory = (-1);
168␌
169/*
170%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
171% %
172% %
173% %
174+ A c q u i r e P i x e l C a c h e %
175% %
176% %
177% %
178%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
179%
180% AcquirePixelCache() acquires a pixel cache.
181%
182% The format of the AcquirePixelCache() method is:
183%
184% Cache AcquirePixelCache(const size_t number_threads)
185%
186% A description of each parameter follows:
187%
188% o number_threads: the number of nexus threads.
189%
190*/
191MagickPrivate Cache AcquirePixelCache(const size_t number_threads)
192{
193 CacheInfo
194 *magick_restrict cache_info;
195
196 char
197 *value;
198
199 cache_info=(CacheInfo *) AcquireAlignedMemory(1,sizeof(*cache_info));
200 if (cache_info == (CacheInfo *) NULL)
201 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
202 (void) memset(cache_info,0,sizeof(*cache_info));
203 cache_info->type=UndefinedCache;
204 cache_info->mode=IOMode;
205 cache_info->disk_mode=IOMode;
206 cache_info->colorspace=sRGBColorspace;
207 cache_info->file=(-1);
208 cache_info->id=GetMagickThreadId();
209 cache_info->number_threads=number_threads;
210 if (GetOpenMPMaximumThreads() > cache_info->number_threads)
211 cache_info->number_threads=GetOpenMPMaximumThreads();
212 if (cache_info->number_threads == 0)
213 cache_info->number_threads=1;
214 cache_info->nexus_info=AcquirePixelCacheNexus(cache_info->number_threads);
215 value=GetEnvironmentValue("MAGICK_SYNCHRONIZE");
216 if (value != (const char *) NULL)
217 {
218 cache_info->synchronize=IsStringTrue(value);
219 value=DestroyString(value);
220 }
221 value=GetPolicyValue("cache:synchronize");
222 if (value != (const char *) NULL)
223 {
224 cache_info->synchronize=IsStringTrue(value);
225 value=DestroyString(value);
226 }
227 cache_info->width_limit=MagickMin(GetMagickResourceLimit(WidthResource),
228 (MagickSizeType) MAGICK_SSIZE_MAX);
229 cache_info->height_limit=MagickMin(GetMagickResourceLimit(HeightResource),
230 (MagickSizeType) MAGICK_SSIZE_MAX);
231 cache_info->semaphore=AcquireSemaphoreInfo();
232 cache_info->reference_count=1;
233 cache_info->file_semaphore=AcquireSemaphoreInfo();
234 cache_info->debug=(GetLogEventMask() & CacheEvent) != 0 ? MagickTrue :
235 MagickFalse;
236 cache_info->signature=MagickCoreSignature;
237 return((Cache ) cache_info);
238}
239␌
240/*
241%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
242% %
243% %
244% %
245% A c q u i r e P i x e l C a c h e N e x u s %
246% %
247% %
248% %
249%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
250%
251% AcquirePixelCacheNexus() allocates the NexusInfo structure.
252%
253% The format of the AcquirePixelCacheNexus method is:
254%
255% NexusInfo **AcquirePixelCacheNexus(const size_t number_threads)
256%
257% A description of each parameter follows:
258%
259% o number_threads: the number of nexus threads.
260%
261*/
262MagickPrivate NexusInfo **AcquirePixelCacheNexus(const size_t number_threads)
263{
264 NexusInfo
265 **magick_restrict nexus_info;
266
267 ssize_t
268 i;
269
270 nexus_info=(NexusInfo **) MagickAssumeAligned(AcquireAlignedMemory(2*
271 number_threads,sizeof(*nexus_info)));
272 if (nexus_info == (NexusInfo **) NULL)
273 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
274 *nexus_info=(NexusInfo *) AcquireQuantumMemory(number_threads,
275 2*sizeof(**nexus_info));
276 if (*nexus_info == (NexusInfo *) NULL)
277 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
278 (void) memset(*nexus_info,0,2*number_threads*sizeof(**nexus_info));
279 for (i=0; i < (ssize_t) (2*number_threads); i++)
280 {
281 nexus_info[i]=(*nexus_info+i);
282 if (i < (ssize_t) number_threads)
283 nexus_info[i]->virtual_nexus=(*nexus_info+number_threads+i);
284 nexus_info[i]->signature=MagickCoreSignature;
285 }
286 return(nexus_info);
287}
288␌
289/*
290%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
291% %
292% %
293% %
294% A c q u i r e P i x e l C a c h e P i x e l s %
295% %
296% %
297% %
298%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
299%
300% AcquirePixelCachePixels() returns the pixels associated with the specified
301% image.
302%
303% The format of the AcquirePixelCachePixels() method is:
304%
305% void *AcquirePixelCachePixels(const Image *image,size_t *length,
306% ExceptionInfo *exception)
307%
308% A description of each parameter follows:
309%
310% o image: the image.
311%
312% o length: the pixel cache length.
313%
314% o exception: return any errors or warnings in this structure.
315%
316*/
317MagickExport void *AcquirePixelCachePixels(const Image *image,size_t *length,
318 ExceptionInfo *exception)
319{
320 CacheInfo
321 *magick_restrict cache_info;
322
323 assert(image != (const Image *) NULL);
324 assert(image->signature == MagickCoreSignature);
325 assert(exception != (ExceptionInfo *) NULL);
326 assert(exception->signature == MagickCoreSignature);
327 assert(image->cache != (Cache) NULL);
328 (void) exception;
329 cache_info=(CacheInfo *) image->cache;
330 assert(cache_info->signature == MagickCoreSignature);
331 *length=0;
332 if ((cache_info->type != MemoryCache) && (cache_info->type != MapCache))
333 return((void *) NULL);
334 *length=(size_t) cache_info->length;
335 return(cache_info->pixels);
336}
337␌
338/*
339%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
340% %
341% %
342% %
343+ C a c h e C o m p o n e n t G e n e s i s %
344% %
345% %
346% %
347%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
348%
349% CacheComponentGenesis() instantiates the cache component.
350%
351% The format of the CacheComponentGenesis method is:
352%
353% MagickBooleanType CacheComponentGenesis(void)
354%
355*/
356MagickPrivate MagickBooleanType CacheComponentGenesis(void)
357{
358 if (cache_semaphore == (SemaphoreInfo *) NULL)
359 cache_semaphore=AcquireSemaphoreInfo();
360 return(MagickTrue);
361}
362␌
363/*
364%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
365% %
366% %
367% %
368+ C a c h e C o m p o n e n t T e r m i n u s %
369% %
370% %
371% %
372%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
373%
374% CacheComponentTerminus() destroys the cache component.
375%
376% The format of the CacheComponentTerminus() method is:
377%
378% CacheComponentTerminus(void)
379%
380*/
381MagickPrivate void CacheComponentTerminus(void)
382{
383 if (cache_semaphore == (SemaphoreInfo *) NULL)
384 ActivateSemaphoreInfo(&cache_semaphore);
385 /* no op-- nothing to destroy */
386 RelinquishSemaphoreInfo(&cache_semaphore);
387}
388␌
389/*
390%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
391% %
392% %
393% %
394+ C l i p P i x e l C a c h e N e x u s %
395% %
396% %
397% %
398%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
399%
400% ClipPixelCacheNexus() clips the cache nexus as defined by the image clip
401% mask. The method returns MagickTrue if the pixel region is clipped,
402% otherwise MagickFalse.
403%
404% The format of the ClipPixelCacheNexus() method is:
405%
406% MagickBooleanType ClipPixelCacheNexus(Image *image,NexusInfo *nexus_info,
407% ExceptionInfo *exception)
408%
409% A description of each parameter follows:
410%
411% o image: the image.
412%
413% o nexus_info: the cache nexus to clip.
414%
415% o exception: return any errors or warnings in this structure.
416%
417*/
418static MagickBooleanType ClipPixelCacheNexus(Image *image,
419 NexusInfo *nexus_info,ExceptionInfo *exception)
420{
421 CacheInfo
422 *magick_restrict cache_info;
423
424 Quantum
425 *magick_restrict p,
426 *magick_restrict q;
427
428 ssize_t
429 y;
430
431 /*
432 Apply clip mask.
433 */
434 if (IsEventLogging() != MagickFalse)
435 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
436 if ((image->channels & WriteMaskChannel) == 0)
437 return(MagickTrue);
438 if ((nexus_info->region.width == 0) || (nexus_info->region.height == 0))
439 return(MagickTrue);
440 cache_info=(CacheInfo *) image->cache;
441 if (cache_info == (CacheInfo *) NULL)
442 return(MagickFalse);
443 p=GetAuthenticPixelCacheNexus(image,nexus_info->region.x,nexus_info->region.y,
444 nexus_info->region.width,nexus_info->region.height,
445 nexus_info->virtual_nexus,exception);
446 q=nexus_info->pixels;
447 if ((p == (Quantum *) NULL) || (q == (Quantum *) NULL))
448 return(MagickFalse);
449 for (y=0; y < (ssize_t) nexus_info->region.height; y++)
450 {
451 ssize_t
452 x;
453
454 for (x=0; x < (ssize_t) nexus_info->region.width; x++)
455 {
456 double
457 mask;
458
459 ssize_t
460 i;
461
462 mask=(double) GetPixelWriteMask(image,p);
463 if (fabs(mask) >= MagickEpsilon)
464 {
465 double
466 mask_alpha,
467 dst_alpha;
468
469 Quantum
470 src_alpha;
471
472 src_alpha=GetPixelAlpha(image,p);
473 mask_alpha=QuantumScale*mask*(double) src_alpha;
474 dst_alpha=(double) GetPixelAlpha(image,q);
475 for (i=0; i < (ssize_t) image->number_channels; i++)
476 {
477 PixelTrait
478 traits;
479
480 PixelChannel channel = GetPixelChannelChannel(image,i);
481 if (channel == AlphaPixelChannel)
482 continue;
483 traits=GetPixelChannelTraits(image,channel);
484 if ((traits & UpdatePixelTrait) == 0)
485 continue;
486 q[i]=ClampToQuantum(MagickOver_((double) p[i],mask_alpha,
487 (double) q[i],dst_alpha));
488 }
489 SetPixelAlpha(image,src_alpha,q);
490 }
491 p+=(ptrdiff_t) GetPixelChannels(image);
492 q+=(ptrdiff_t) GetPixelChannels(image);
493 }
494 }
495 return(MagickTrue);
496}
497␌
498/*
499%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
500% %
501% %
502% %
503+ C l o n e P i x e l C a c h e %
504% %
505% %
506% %
507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
508%
509% ClonePixelCache() clones a pixel cache.
510%
511% The format of the ClonePixelCache() method is:
512%
513% Cache ClonePixelCache(const Cache cache)
514%
515% A description of each parameter follows:
516%
517% o cache: the pixel cache.
518%
519*/
520MagickPrivate Cache ClonePixelCache(const Cache cache)
521{
522 CacheInfo
523 *magick_restrict clone_info;
524
525 const CacheInfo
526 *magick_restrict cache_info;
527
528 assert(cache != NULL);
529 cache_info=(const CacheInfo *) cache;
530 assert(cache_info->signature == MagickCoreSignature);
531 if (IsEventLogging() != MagickFalse)
532 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
533 cache_info->filename);
534 clone_info=(CacheInfo *) AcquirePixelCache(cache_info->number_threads);
535 clone_info->virtual_pixel_method=cache_info->virtual_pixel_method;
536 return((Cache ) clone_info);
537}
538␌
539/*
540%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
541% %
542% %
543% %
544+ C l o n e P i x e l C a c h e M e t h o d s %
545% %
546% %
547% %
548%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
549%
550% ClonePixelCacheMethods() clones the pixel cache methods from one cache to
551% another.
552%
553% The format of the ClonePixelCacheMethods() method is:
554%
555% void ClonePixelCacheMethods(Cache clone,const Cache cache)
556%
557% A description of each parameter follows:
558%
559% o clone: Specifies a pointer to a Cache structure.
560%
561% o cache: the pixel cache.
562%
563*/
564MagickPrivate void ClonePixelCacheMethods(Cache clone,const Cache cache)
565{
566 CacheInfo
567 *magick_restrict cache_info,
568 *magick_restrict source_info;
569
570 assert(clone != (Cache) NULL);
571 source_info=(CacheInfo *) clone;
572 assert(source_info->signature == MagickCoreSignature);
573 if (IsEventLogging() != MagickFalse)
574 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
575 source_info->filename);
576 assert(cache != (Cache) NULL);
577 cache_info=(CacheInfo *) cache;
578 assert(cache_info->signature == MagickCoreSignature);
579 source_info->methods=cache_info->methods;
580}
581␌
582/*
583%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
584% %
585% %
586% %
587+ C l o n e P i x e l C a c h e R e p o s i t o r y %
588% %
589% %
590% %
591%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
592%
593% ClonePixelCacheRepository() clones the source pixel cache to the destination
594% cache.
595%
596% The format of the ClonePixelCacheRepository() method is:
597%
598% MagickBooleanType ClonePixelCacheRepository(CacheInfo *clone_info,
599% CacheInfo *cache_info,ExceptionInfo *exception)
600%
601% A description of each parameter follows:
602%
603% o clone_info: the pixel cache.
604%
605% o cache_info: the source pixel cache.
606%
607% o exception: return any errors or warnings in this structure.
608%
609*/
610
611static MagickBooleanType ClonePixelCacheOnDisk(
612 CacheInfo *magick_restrict cache_info,CacheInfo *magick_restrict clone_info)
613{
614 MagickSizeType
615 extent;
616
617 size_t
618 quantum;
619
620 ssize_t
621 count;
622
623 struct stat
624 file_stats;
625
626 unsigned char
627 *buffer;
628
629 /*
630 Clone pixel cache on disk with identical morphology.
631 */
632 if ((OpenPixelCacheOnDisk(cache_info,ReadMode) == MagickFalse) ||
633 (OpenPixelCacheOnDisk(clone_info,IOMode) == MagickFalse))
634 return(MagickFalse);
635 if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||
636 (lseek(clone_info->file,0,SEEK_SET) < 0))
637 return(MagickFalse);
638 quantum=(size_t) MagickMaxBufferExtent;
639 if ((fstat(cache_info->file,&file_stats) == 0) && (file_stats.st_size > 0))
640 {
641#if defined(MAGICKCORE_HAVE_LINUX_SENDFILE)
642 if (cache_info->length < 0x7ffff000)
643 {
644 do
645 {
646 count=sendfile(clone_info->file,cache_info->file,(off_t *) NULL,
647 (size_t) cache_info->length);
648 } while ((count < 0) && (errno == EINTR));
649 if (count == (ssize_t) cache_info->length)
650 return(MagickTrue);
651 if (count < 0)
652 return(MagickFalse);
653 if ((lseek(cache_info->file,0,SEEK_SET) < 0) ||
654 (lseek(clone_info->file,0,SEEK_SET) < 0))
655 return(MagickFalse);
656 }
657#endif
658 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
659 }
660 buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer));
661 if (buffer == (unsigned char *) NULL)
662 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
663 extent=0;
664 while (extent < cache_info->length)
665 {
666 size_t
667 length;
668
669 length=(size_t) MagickMin((MagickSizeType) quantum,cache_info->length-
670 extent);
671 do
672 {
673 count=read(cache_info->file,buffer,length);
674 } while ((count < 0) && (errno == EINTR));
675 if (count <= 0)
676 {
677 buffer=(unsigned char *) RelinquishMagickMemory(buffer);
678 return(MagickFalse);
679 }
680 {
681 ssize_t
682 number_bytes,
683 offset = 0;
684
685 while (offset < count)
686 {
687 do
688 {
689 number_bytes=write(clone_info->file,buffer+offset,(size_t) (count-
690 offset));
691 } while ((number_bytes < 0) && (errno == EINTR));
692 if (number_bytes <= 0)
693 {
694 buffer=(unsigned char *) RelinquishMagickMemory(buffer);
695 return(MagickFalse);
696 }
697 offset+=number_bytes;
698 }
699 extent+=(MagickSizeType) offset;
700 }
701 }
702 buffer=(unsigned char *) RelinquishMagickMemory(buffer);
703 return(extent == cache_info->length ? MagickTrue : MagickFalse);
704}
705
706#if defined(MAGICKCORE_OPENMP_SUPPORT)
707static inline int GetCacheNumberThreads(const CacheInfo *source,
708 const CacheInfo *destination,const size_t chunk,const int factor)
709{
710 size_t
711 max_threads = (size_t) GetMagickResourceLimit(ThreadResource),
712 number_threads = 1UL,
713 workload_factor = 64UL << factor;
714
715 /*
716 Determine number of threads based on workload.
717 */
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);
721 /*
722 Limit threads for non-memory or non-map cache sources/destinations.
723 */
724 if (((source->type != MemoryCache) && (source->type != MapCache)) ||
725 ((destination->type != MemoryCache) && (destination->type != MapCache)))
726 number_threads=MagickMin(number_threads,4);
727 return((int) number_threads);
728}
729#endif
730
731static MagickBooleanType ClonePixelCacheRepository(
732 CacheInfo *magick_restrict clone_info,CacheInfo *magick_restrict cache_info,
733 ExceptionInfo *exception)
734{
735#define cache_number_threads(source,destination,chunk,factor) \
736 num_threads(GetCacheNumberThreads((source),(destination),(chunk),(factor)))
737
738 MagickBooleanType
739 optimize,
740 status;
741
742 NexusInfo
743 **magick_restrict cache_nexus,
744 **magick_restrict clone_nexus;
745
746 size_t
747 length;
748
749 ssize_t
750 y;
751
752 assert(cache_info != (CacheInfo *) NULL);
753 assert(clone_info != (CacheInfo *) NULL);
754 assert(exception != (ExceptionInfo *) NULL);
755 if (cache_info->type == PingCache)
756 return(MagickTrue);
757 length=cache_info->number_channels*sizeof(*cache_info->channel_map);
758 if ((cache_info->storage_class == clone_info->storage_class) &&
759 (cache_info->colorspace == clone_info->colorspace) &&
760 (cache_info->alpha_trait == clone_info->alpha_trait) &&
761 (cache_info->channels == clone_info->channels) &&
762 (cache_info->columns == clone_info->columns) &&
763 (cache_info->rows == clone_info->rows) &&
764 (cache_info->number_channels == clone_info->number_channels) &&
765 (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) &&
766 (cache_info->metacontent_extent == clone_info->metacontent_extent))
767 {
768 /*
769 Identical pixel cache morphology.
770 */
771 if (((cache_info->type == MemoryCache) ||
772 (cache_info->type == MapCache)) &&
773 ((clone_info->type == MemoryCache) || (clone_info->type == MapCache)))
774 {
775 (void) memcpy(clone_info->pixels,cache_info->pixels,
776 cache_info->number_channels*cache_info->columns*cache_info->rows*
777 sizeof(*cache_info->pixels));
778 if ((cache_info->metacontent_extent != 0) &&
779 (clone_info->metacontent_extent != 0))
780 (void) memcpy(clone_info->metacontent,cache_info->metacontent,
781 cache_info->columns*cache_info->rows*
782 clone_info->metacontent_extent*sizeof(unsigned char));
783 return(MagickTrue);
784 }
785 if ((cache_info->type == DiskCache) && (clone_info->type == DiskCache))
786 return(ClonePixelCacheOnDisk(cache_info,clone_info));
787 }
788 /*
789 Mismatched pixel cache morphology.
790 */
791 cache_nexus=AcquirePixelCacheNexus(cache_info->number_threads);
792 clone_nexus=AcquirePixelCacheNexus(clone_info->number_threads);
793 length=cache_info->number_channels*sizeof(*cache_info->channel_map);
794 optimize=(cache_info->number_channels == clone_info->number_channels) &&
795 (memcmp(cache_info->channel_map,clone_info->channel_map,length) == 0) ?
796 MagickTrue : MagickFalse;
797 length=(size_t) MagickMin(cache_info->number_channels*cache_info->columns,
798 clone_info->number_channels*clone_info->columns);
799 status=MagickTrue;
800#if defined(MAGICKCORE_OPENMP_SUPPORT)
801 #pragma omp parallel for schedule(static) shared(status) \
802 cache_number_threads(cache_info,clone_info,cache_info->rows,3)
803#endif
804 for (y=0; y < (ssize_t) cache_info->rows; y++)
805 {
806 const int
807 id = GetOpenMPThreadId();
808
809 Quantum
810 *pixels;
811
812 ssize_t
813 x;
814
815 if (status == MagickFalse)
816 continue;
817 if (y >= (ssize_t) clone_info->rows)
818 continue;
819 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,
820 cache_info->columns,1,MagickFalse,cache_nexus[id],exception);
821 if (pixels == (Quantum *) NULL)
822 continue;
823 status=ReadPixelCachePixels(cache_info,cache_nexus[id],exception);
824 if (status == MagickFalse)
825 continue;
826 pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,
827 clone_info->columns,1,MagickFalse,clone_nexus[id],exception);
828 if (pixels == (Quantum *) NULL)
829 continue;
830 (void) memset(clone_nexus[id]->pixels,0,(size_t) clone_nexus[id]->length);
831 if (optimize != MagickFalse)
832 (void) memcpy(clone_nexus[id]->pixels,cache_nexus[id]->pixels,length*
833 sizeof(Quantum));
834 else
835 {
836 const Quantum
837 *magick_restrict p;
838
839 Quantum
840 *magick_restrict q;
841
842 /*
843 Mismatched pixel channel map.
844 */
845 p=cache_nexus[id]->pixels;
846 q=clone_nexus[id]->pixels;
847 for (x=0; x < (ssize_t) cache_info->columns; x++)
848 {
849 ssize_t
850 i;
851
852 if (x == (ssize_t) clone_info->columns)
853 break;
854 for (i=0; i < (ssize_t) clone_info->number_channels; i++)
855 {
856 PixelChannel
857 channel;
858
859 PixelTrait
860 traits;
861
862 channel=clone_info->channel_map[i].channel;
863 traits=cache_info->channel_map[channel].traits;
864 if (traits != UndefinedPixelTrait)
865 *q=*(p+cache_info->channel_map[channel].offset);
866 q++;
867 }
868 p+=(ptrdiff_t) cache_info->number_channels;
869 }
870 }
871 status=WritePixelCachePixels(clone_info,clone_nexus[id],exception);
872 }
873 if ((cache_info->metacontent_extent != 0) &&
874 (clone_info->metacontent_extent != 0))
875 {
876 /*
877 Clone metacontent.
878 */
879 length=(size_t) MagickMin(cache_info->metacontent_extent,
880 clone_info->metacontent_extent);
881#if defined(MAGICKCORE_OPENMP_SUPPORT)
882 #pragma omp parallel for schedule(static) shared(status) \
883 cache_number_threads(cache_info,clone_info,cache_info->rows,3)
884#endif
885 for (y=0; y < (ssize_t) cache_info->rows; y++)
886 {
887 const int
888 id = GetOpenMPThreadId();
889
890 Quantum
891 *pixels;
892
893 if (status == MagickFalse)
894 continue;
895 if (y >= (ssize_t) clone_info->rows)
896 continue;
897 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,0,y,
898 cache_info->columns,1,MagickFalse,cache_nexus[id],exception);
899 if (pixels == (Quantum *) NULL)
900 continue;
901 status=ReadPixelCacheMetacontent(cache_info,cache_nexus[id],exception);
902 if (status == MagickFalse)
903 continue;
904 pixels=SetPixelCacheNexusPixels(clone_info,WriteMode,0,y,
905 clone_info->columns,1,MagickFalse,clone_nexus[id],exception);
906 if (pixels == (Quantum *) NULL)
907 continue;
908 if ((clone_nexus[id]->metacontent != (void *) NULL) &&
909 (cache_nexus[id]->metacontent != (void *) NULL))
910 (void) memcpy(clone_nexus[id]->metacontent,
911 cache_nexus[id]->metacontent,length*sizeof(unsigned char));
912 status=WritePixelCacheMetacontent(clone_info,clone_nexus[id],exception);
913 }
914 }
915 clone_nexus=DestroyPixelCacheNexus(clone_nexus,clone_info->number_threads);
916 cache_nexus=DestroyPixelCacheNexus(cache_nexus,cache_info->number_threads);
917 if (cache_info->debug != MagickFalse)
918 {
919 char
920 message[MagickPathExtent];
921
922 (void) FormatLocaleString(message,MagickPathExtent,"%s => %s",
923 CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) cache_info->type),
924 CommandOptionToMnemonic(MagickCacheOptions,(ssize_t) clone_info->type));
925 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);
926 }
927 return(status);
928}
929␌
930/*
931%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
932% %
933% %
934% %
935+ D e s t r o y I m a g e P i x e l C a c h e %
936% %
937% %
938% %
939%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
940%
941% DestroyImagePixelCache() deallocates memory associated with the pixel cache.
942%
943% The format of the DestroyImagePixelCache() method is:
944%
945% void DestroyImagePixelCache(Image *image)
946%
947% A description of each parameter follows:
948%
949% o image: the image.
950%
951*/
952static void DestroyImagePixelCache(Image *image)
953{
954 assert(image != (Image *) NULL);
955 assert(image->signature == MagickCoreSignature);
956 if (IsEventLogging() != MagickFalse)
957 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
958 if (image->cache != (void *) NULL)
959 image->cache=DestroyPixelCache(image->cache);
960}
961␌
962/*
963%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
964% %
965% %
966% %
967+ D e s t r o y I m a g e P i x e l s %
968% %
969% %
970% %
971%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
972%
973% DestroyImagePixels() deallocates memory associated with the pixel cache.
974%
975% The format of the DestroyImagePixels() method is:
976%
977% void DestroyImagePixels(Image *image)
978%
979% A description of each parameter follows:
980%
981% o image: the image.
982%
983*/
984MagickExport void DestroyImagePixels(Image *image)
985{
986 CacheInfo
987 *magick_restrict cache_info;
988
989 assert(image != (const Image *) NULL);
990 assert(image->signature == MagickCoreSignature);
991 if (IsEventLogging() != MagickFalse)
992 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
993 assert(image->cache != (Cache) NULL);
994 cache_info=(CacheInfo *) image->cache;
995 assert(cache_info->signature == MagickCoreSignature);
996 if (cache_info->methods.destroy_pixel_handler != (DestroyPixelHandler) NULL)
997 {
998 cache_info->methods.destroy_pixel_handler(image);
999 return;
1000 }
1001 image->cache=DestroyPixelCache(image->cache);
1002}
1003␌
1004/*
1005%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1006% %
1007% %
1008% %
1009+ D e s t r o y P i x e l C a c h e %
1010% %
1011% %
1012% %
1013%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1014%
1015% DestroyPixelCache() deallocates memory associated with the pixel cache.
1016%
1017% The format of the DestroyPixelCache() method is:
1018%
1019% Cache DestroyPixelCache(Cache cache)
1020%
1021% A description of each parameter follows:
1022%
1023% o cache: the pixel cache.
1024%
1025*/
1026
1027static MagickBooleanType ClosePixelCacheOnDisk(CacheInfo *cache_info)
1028{
1029 int
1030 status;
1031
1032 status=(-1);
1033 if (cache_info->file != -1)
1034 {
1035 status=close_utf8(cache_info->file);
1036 cache_info->file=(-1);
1037 RelinquishMagickResource(FileResource,1);
1038 }
1039 return(status == -1 ? MagickFalse : MagickTrue);
1040}
1041
1042static inline void RelinquishPixelCachePixels(CacheInfo *cache_info)
1043{
1044 switch (cache_info->type)
1045 {
1046 case MemoryCache:
1047 {
1048 (void) ShredMagickMemory(cache_info->pixels,(size_t) cache_info->length);
1049#if defined(MAGICKCORE_OPENCL_SUPPORT)
1050 if (cache_info->opencl != (MagickCLCacheInfo) NULL)
1051 {
1052 cache_info->opencl=RelinquishMagickCLCacheInfo(cache_info->opencl,
1053 MagickTrue);
1054 cache_info->pixels=(Quantum *) NULL;
1055 break;
1056 }
1057#endif
1058 if (cache_info->mapped == MagickFalse)
1059 cache_info->pixels=(Quantum *) RelinquishAlignedMemory(
1060 cache_info->pixels);
1061 else
1062 {
1063 (void) UnmapBlob(cache_info->pixels,(size_t) cache_info->length);
1064 cache_info->pixels=(Quantum *) NULL;
1065 }
1066 RelinquishMagickResource(MemoryResource,cache_info->length);
1067 break;
1068 }
1069 case MapCache:
1070 {
1071 (void) UnmapBlob(cache_info->pixels,(size_t) cache_info->length);
1072 cache_info->pixels=(Quantum *) NULL;
1073 if ((cache_info->mode != ReadMode) && (cache_info->mode != PersistMode))
1074 (void) RelinquishUniqueFileResource(cache_info->cache_filename);
1075 *cache_info->cache_filename='\0';
1076 RelinquishMagickResource(MapResource,cache_info->length);
1077 magick_fallthrough;
1078 }
1079 case DiskCache:
1080 {
1081 if (cache_info->file != -1)
1082 (void) ClosePixelCacheOnDisk(cache_info);
1083 if ((cache_info->mode != ReadMode) && (cache_info->mode != PersistMode))
1084 (void) RelinquishUniqueFileResource(cache_info->cache_filename);
1085 *cache_info->cache_filename='\0';
1086 RelinquishMagickResource(DiskResource,cache_info->length);
1087 break;
1088 }
1089 case DistributedCache:
1090 {
1091 *cache_info->cache_filename='\0';
1092 (void) RelinquishDistributePixelCache((DistributeCacheInfo *)
1093 cache_info->server_info);
1094 break;
1095 }
1096 default:
1097 break;
1098 }
1099 cache_info->type=UndefinedCache;
1100 cache_info->mapped=MagickFalse;
1101 cache_info->metacontent=(void *) NULL;
1102}
1103
1104MagickPrivate Cache DestroyPixelCache(Cache cache)
1105{
1106 CacheInfo
1107 *magick_restrict cache_info;
1108
1109 assert(cache != (Cache) NULL);
1110 cache_info=(CacheInfo *) cache;
1111 assert(cache_info->signature == MagickCoreSignature);
1112 if (IsEventLogging() != MagickFalse)
1113 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1114 cache_info->filename);
1115 LockSemaphoreInfo(cache_info->semaphore);
1116 cache_info->reference_count--;
1117 if (cache_info->reference_count != 0)
1118 {
1119 UnlockSemaphoreInfo(cache_info->semaphore);
1120 return((Cache) NULL);
1121 }
1122 UnlockSemaphoreInfo(cache_info->semaphore);
1123 if (cache_info->debug != MagickFalse)
1124 {
1125 char
1126 message[MagickPathExtent];
1127
1128 (void) FormatLocaleString(message,MagickPathExtent,"destroy %s",
1129 cache_info->filename);
1130 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);
1131 }
1132 RelinquishPixelCachePixels(cache_info);
1133 if (cache_info->server_info != (DistributeCacheInfo *) NULL)
1134 cache_info->server_info=DestroyDistributeCacheInfo((DistributeCacheInfo *)
1135 cache_info->server_info);
1136 if (cache_info->nexus_info != (NexusInfo **) NULL)
1137 cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
1138 cache_info->number_threads);
1139 if (cache_info->random_info != (RandomInfo *) NULL)
1140 cache_info->random_info=DestroyRandomInfo(cache_info->random_info);
1141 if (cache_info->file_semaphore != (SemaphoreInfo *) NULL)
1142 RelinquishSemaphoreInfo(&cache_info->file_semaphore);
1143 if (cache_info->semaphore != (SemaphoreInfo *) NULL)
1144 RelinquishSemaphoreInfo(&cache_info->semaphore);
1145 cache_info->signature=(~MagickCoreSignature);
1146 cache_info=(CacheInfo *) RelinquishAlignedMemory(cache_info);
1147 cache=(Cache) NULL;
1148 return(cache);
1149}
1150␌
1151/*
1152%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1153% %
1154% %
1155% %
1156+ D e s t r o y P i x e l C a c h e N e x u s %
1157% %
1158% %
1159% %
1160%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1161%
1162% DestroyPixelCacheNexus() destroys a pixel cache nexus.
1163%
1164% The format of the DestroyPixelCacheNexus() method is:
1165%
1166% NexusInfo **DestroyPixelCacheNexus(NexusInfo *nexus_info,
1167% const size_t number_threads)
1168%
1169% A description of each parameter follows:
1170%
1171% o nexus_info: the nexus to destroy.
1172%
1173% o number_threads: the number of nexus threads.
1174%
1175*/
1176
1177static inline void RelinquishCacheNexusPixels(NexusInfo *nexus_info)
1178{
1179 if (nexus_info->mapped == MagickFalse)
1180 (void) RelinquishAlignedMemory(nexus_info->cache);
1181 else
1182 (void) UnmapBlob(nexus_info->cache,(size_t) nexus_info->length);
1183 nexus_info->cache=(Quantum *) NULL;
1184 nexus_info->pixels=(Quantum *) NULL;
1185 nexus_info->metacontent=(void *) NULL;
1186 nexus_info->length=0;
1187 nexus_info->mapped=MagickFalse;
1188}
1189
1190MagickPrivate NexusInfo **DestroyPixelCacheNexus(NexusInfo **nexus_info,
1191 const size_t number_threads)
1192{
1193 ssize_t
1194 i;
1195
1196 assert(nexus_info != (NexusInfo **) NULL);
1197 for (i=0; i < (ssize_t) (2*number_threads); i++)
1198 {
1199 if (nexus_info[i]->cache != (Quantum *) NULL)
1200 RelinquishCacheNexusPixels(nexus_info[i]);
1201 nexus_info[i]->signature=(~MagickCoreSignature);
1202 }
1203 *nexus_info=(NexusInfo *) RelinquishMagickMemory(*nexus_info);
1204 nexus_info=(NexusInfo **) RelinquishAlignedMemory(nexus_info);
1205 return(nexus_info);
1206}
1207
1208
1209/*
1210%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1211% %
1212% %
1213% %
1214% G e t A u t h e n t i c M e t a c o n t e n t %
1215% %
1216% %
1217% %
1218%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1219%
1220% GetAuthenticMetacontent() returns the authentic metacontent corresponding
1221% with the last call to QueueAuthenticPixels() or GetVirtualPixels(). NULL is
1222% returned if the associated pixels are not available.
1223%
1224% The format of the GetAuthenticMetacontent() method is:
1225%
1226% void *GetAuthenticMetacontent(const Image *image)
1227%
1228% A description of each parameter follows:
1229%
1230% o image: the image.
1231%
1232*/
1233MagickExport void *GetAuthenticMetacontent(const Image *image)
1234{
1235 CacheInfo
1236 *magick_restrict cache_info;
1237
1238 const int
1239 id = GetOpenMPThreadId();
1240
1241 assert(image != (const Image *) NULL);
1242 assert(image->signature == MagickCoreSignature);
1243 assert(image->cache != (Cache) NULL);
1244 cache_info=(CacheInfo *) image->cache;
1245 assert(cache_info->signature == MagickCoreSignature);
1246 if (cache_info->methods.get_authentic_metacontent_from_handler !=
1247 (GetAuthenticMetacontentFromHandler) NULL)
1248 {
1249 void
1250 *metacontent;
1251
1252 metacontent=cache_info->methods.
1253 get_authentic_metacontent_from_handler(image);
1254 return(metacontent);
1255 }
1256 assert(id < (int) cache_info->number_threads);
1257 return(cache_info->nexus_info[id]->metacontent);
1258}
1259␌
1260/*
1261%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1262% %
1263% %
1264% %
1265+ G e t A u t h e n t i c M e t a c o n t e n t F r o m C a c h e %
1266% %
1267% %
1268% %
1269%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1270%
1271% GetAuthenticMetacontentFromCache() returns the meta-content corresponding
1272% with the last call to QueueAuthenticPixelsCache() or
1273% GetAuthenticPixelsCache().
1274%
1275% The format of the GetAuthenticMetacontentFromCache() method is:
1276%
1277% void *GetAuthenticMetacontentFromCache(const Image *image)
1278%
1279% A description of each parameter follows:
1280%
1281% o image: the image.
1282%
1283*/
1284static void *GetAuthenticMetacontentFromCache(const Image *image)
1285{
1286 CacheInfo
1287 *magick_restrict cache_info;
1288
1289 const int
1290 id = GetOpenMPThreadId();
1291
1292 assert(image != (const Image *) NULL);
1293 assert(image->signature == MagickCoreSignature);
1294 assert(image->cache != (Cache) NULL);
1295 cache_info=(CacheInfo *) image->cache;
1296 assert(cache_info->signature == MagickCoreSignature);
1297 assert(id < (int) cache_info->number_threads);
1298 return(cache_info->nexus_info[id]->metacontent);
1299}
1300
1301#if defined(MAGICKCORE_OPENCL_SUPPORT)
1302/*
1303%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1304% %
1305% %
1306% %
1307+ G e t A u t h e n t i c O p e n C L B u f f e r %
1308% %
1309% %
1310% %
1311%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1312%
1313% GetAuthenticOpenCLBuffer() returns an OpenCL buffer used to execute OpenCL
1314% operations.
1315%
1316% The format of the GetAuthenticOpenCLBuffer() method is:
1317%
1318% cl_mem GetAuthenticOpenCLBuffer(const Image *image,
1319% MagickCLDevice device,ExceptionInfo *exception)
1320%
1321% A description of each parameter follows:
1322%
1323% o image: the image.
1324%
1325% o device: the device to use.
1326%
1327% o exception: return any errors or warnings in this structure.
1328%
1329*/
1330MagickPrivate cl_mem GetAuthenticOpenCLBuffer(const Image *image,
1331 MagickCLDevice device,ExceptionInfo *exception)
1332{
1333 CacheInfo
1334 *magick_restrict cache_info;
1335
1336 assert(image != (const Image *) NULL);
1337 assert(device != (const MagickCLDevice) NULL);
1338 cache_info=(CacheInfo *) image->cache;
1339 if ((cache_info->type == UndefinedCache) || (cache_info->reference_count > 1))
1340 {
1341 (void) SyncImagePixelCache((Image *) image,exception);
1342 cache_info=(CacheInfo *) image->cache;
1343 }
1344 if ((cache_info->type != MemoryCache) || (cache_info->mapped != MagickFalse))
1345 return((cl_mem) NULL);
1346 LockSemaphoreInfo(cache_info->semaphore);
1347 if ((cache_info->opencl != (MagickCLCacheInfo) NULL) &&
1348 (cache_info->opencl->device->context != device->context))
1349 cache_info->opencl=CopyMagickCLCacheInfo(cache_info->opencl);
1350 if (cache_info->opencl == (MagickCLCacheInfo) NULL)
1351 {
1352 assert(cache_info->pixels != (Quantum *) NULL);
1353 cache_info->opencl=AcquireMagickCLCacheInfo(device,cache_info->pixels,
1354 cache_info->length);
1355 }
1356 if (cache_info->opencl != (MagickCLCacheInfo) NULL)
1357 RetainOpenCLMemObject(cache_info->opencl->buffer);
1358 UnlockSemaphoreInfo(cache_info->semaphore);
1359 if (cache_info->opencl == (MagickCLCacheInfo) NULL)
1360 return((cl_mem) NULL);
1361 assert(cache_info->opencl->pixels == cache_info->pixels);
1362 return(cache_info->opencl->buffer);
1363}
1364#endif
1365␌
1366/*
1367%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1368% %
1369% %
1370% %
1371+ G e t A u t h e n t i c P i x e l C a c h e N e x u s %
1372% %
1373% %
1374% %
1375%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1376%
1377% GetAuthenticPixelCacheNexus() gets authentic pixels from the in-memory or
1378% disk pixel cache as defined by the geometry parameters. A pointer to the
1379% pixels is returned if the pixels are transferred, otherwise a NULL is
1380% returned.
1381%
1382% The format of the GetAuthenticPixelCacheNexus() method is:
1383%
1384% Quantum *GetAuthenticPixelCacheNexus(Image *image,const ssize_t x,
1385% const ssize_t y,const size_t columns,const size_t rows,
1386% NexusInfo *nexus_info,ExceptionInfo *exception)
1387%
1388% A description of each parameter follows:
1389%
1390% o image: the image.
1391%
1392% o x,y,columns,rows: These values define the perimeter of a region of
1393% pixels.
1394%
1395% o nexus_info: the cache nexus to return.
1396%
1397% o exception: return any errors or warnings in this structure.
1398%
1399*/
1400
1401MagickPrivate Quantum *GetAuthenticPixelCacheNexus(Image *image,const ssize_t x,
1402 const ssize_t y,const size_t columns,const size_t rows,NexusInfo *nexus_info,
1403 ExceptionInfo *exception)
1404{
1405 CacheInfo
1406 *magick_restrict cache_info;
1407
1408 Quantum
1409 *magick_restrict pixels;
1410
1411 /*
1412 Transfer pixels from the cache.
1413 */
1414 assert(image != (Image *) NULL);
1415 assert(image->signature == MagickCoreSignature);
1416 pixels=QueueAuthenticPixelCacheNexus(image,x,y,columns,rows,MagickTrue,
1417 nexus_info,exception);
1418 if (pixels == (Quantum *) NULL)
1419 return((Quantum *) NULL);
1420 cache_info=(CacheInfo *) image->cache;
1421 assert(cache_info->signature == MagickCoreSignature);
1422 if (nexus_info->authentic_pixel_cache != MagickFalse)
1423 return(pixels);
1424 if (ReadPixelCachePixels(cache_info,nexus_info,exception) == MagickFalse)
1425 return((Quantum *) NULL);
1426 if (cache_info->metacontent_extent != 0)
1427 if (ReadPixelCacheMetacontent(cache_info,nexus_info,exception) == MagickFalse)
1428 return((Quantum *) NULL);
1429 return(pixels);
1430}
1431␌
1432/*
1433%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1434% %
1435% %
1436% %
1437+ G e t A u t h e n t i c P i x e l s F r o m C a c h e %
1438% %
1439% %
1440% %
1441%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1442%
1443% GetAuthenticPixelsFromCache() returns the pixels associated with the last
1444% call to the QueueAuthenticPixelsCache() or GetAuthenticPixelsCache() methods.
1445%
1446% The format of the GetAuthenticPixelsFromCache() method is:
1447%
1448% Quantum *GetAuthenticPixelsFromCache(const Image image)
1449%
1450% A description of each parameter follows:
1451%
1452% o image: the image.
1453%
1454*/
1455static Quantum *GetAuthenticPixelsFromCache(const Image *image)
1456{
1457 CacheInfo
1458 *magick_restrict cache_info;
1459
1460 const int
1461 id = GetOpenMPThreadId();
1462
1463 assert(image != (const Image *) NULL);
1464 assert(image->signature == MagickCoreSignature);
1465 assert(image->cache != (Cache) NULL);
1466 cache_info=(CacheInfo *) image->cache;
1467 assert(cache_info->signature == MagickCoreSignature);
1468 assert(id < (int) cache_info->number_threads);
1469 return(cache_info->nexus_info[id]->pixels);
1470}
1471␌
1472/*
1473%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1474% %
1475% %
1476% %
1477% G e t A u t h e n t i c P i x e l Q u e u e %
1478% %
1479% %
1480% %
1481%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1482%
1483% GetAuthenticPixelQueue() returns the authentic pixels associated
1484% corresponding with the last call to QueueAuthenticPixels() or
1485% GetAuthenticPixels().
1486%
1487% The format of the GetAuthenticPixelQueue() method is:
1488%
1489% Quantum *GetAuthenticPixelQueue(const Image image)
1490%
1491% A description of each parameter follows:
1492%
1493% o image: the image.
1494%
1495*/
1496MagickExport Quantum *GetAuthenticPixelQueue(const Image *image)
1497{
1498 CacheInfo
1499 *magick_restrict cache_info;
1500
1501 const int
1502 id = GetOpenMPThreadId();
1503
1504 assert(image != (const Image *) NULL);
1505 assert(image->signature == MagickCoreSignature);
1506 assert(image->cache != (Cache) NULL);
1507 cache_info=(CacheInfo *) image->cache;
1508 assert(cache_info->signature == MagickCoreSignature);
1509 if (cache_info->methods.get_authentic_pixels_from_handler !=
1510 (GetAuthenticPixelsFromHandler) NULL)
1511 return(cache_info->methods.get_authentic_pixels_from_handler(image));
1512 assert(id < (int) cache_info->number_threads);
1513 return(cache_info->nexus_info[id]->pixels);
1514}
1515␌
1516/*
1517%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1518% %
1519% %
1520% %
1521% G e t A u t h e n t i c P i x e l s %
1522% %
1523% %
1524% %
1525%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1526%
1527% GetAuthenticPixels() obtains a pixel region for read/write access. If the
1528% region is successfully accessed, a pointer to a Quantum array
1529% representing the region is returned, otherwise NULL is returned.
1530%
1531% The returned pointer may point to a temporary working copy of the pixels
1532% or it may point to the original pixels in memory. Performance is maximized
1533% if the selected region is part of one row, or one or more full rows, since
1534% then there is opportunity to access the pixels in-place (without a copy)
1535% if the image is in memory, or in a memory-mapped file. The returned pointer
1536% must *never* be deallocated by the user.
1537%
1538% Pixels accessed via the returned pointer represent a simple array of type
1539% Quantum. If the image has corresponding metacontent,call
1540% GetAuthenticMetacontent() after invoking GetAuthenticPixels() to obtain the
1541% meta-content corresponding to the region. Once the Quantum array has
1542% been updated, the changes must be saved back to the underlying image using
1543% SyncAuthenticPixels() or they may be lost.
1544%
1545% The format of the GetAuthenticPixels() method is:
1546%
1547% Quantum *GetAuthenticPixels(Image *image,const ssize_t x,
1548% const ssize_t y,const size_t columns,const size_t rows,
1549% ExceptionInfo *exception)
1550%
1551% A description of each parameter follows:
1552%
1553% o image: the image.
1554%
1555% o x,y,columns,rows: These values define the perimeter of a region of
1556% pixels.
1557%
1558% o exception: return any errors or warnings in this structure.
1559%
1560*/
1561MagickExport Quantum *GetAuthenticPixels(Image *image,const ssize_t x,
1562 const ssize_t y,const size_t columns,const size_t rows,
1563 ExceptionInfo *exception)
1564{
1565 CacheInfo
1566 *magick_restrict cache_info;
1567
1568 const int
1569 id = GetOpenMPThreadId();
1570
1571 Quantum
1572 *pixels;
1573
1574 assert(image != (Image *) NULL);
1575 assert(image->signature == MagickCoreSignature);
1576 assert(image->cache != (Cache) NULL);
1577 cache_info=(CacheInfo *) image->cache;
1578 assert(cache_info->signature == MagickCoreSignature);
1579 if (cache_info->methods.get_authentic_pixels_handler !=
1580 (GetAuthenticPixelsHandler) NULL)
1581 {
1582 pixels=cache_info->methods.get_authentic_pixels_handler(image,x,y,columns,
1583 rows,exception);
1584 return(pixels);
1585 }
1586 assert(id < (int) cache_info->number_threads);
1587 pixels=GetAuthenticPixelCacheNexus(image,x,y,columns,rows,
1588 cache_info->nexus_info[id],exception);
1589 return(pixels);
1590}
1591␌
1592/*
1593%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1594% %
1595% %
1596% %
1597+ G e t A u t h e n t i c P i x e l s C a c h e %
1598% %
1599% %
1600% %
1601%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1602%
1603% GetAuthenticPixelsCache() gets pixels from the in-memory or disk pixel cache
1604% as defined by the geometry parameters. A pointer to the pixels is returned
1605% if the pixels are transferred, otherwise a NULL is returned.
1606%
1607% The format of the GetAuthenticPixelsCache() method is:
1608%
1609% Quantum *GetAuthenticPixelsCache(Image *image,const ssize_t x,
1610% const ssize_t y,const size_t columns,const size_t rows,
1611% ExceptionInfo *exception)
1612%
1613% A description of each parameter follows:
1614%
1615% o image: the image.
1616%
1617% o x,y,columns,rows: These values define the perimeter of a region of
1618% pixels.
1619%
1620% o exception: return any errors or warnings in this structure.
1621%
1622*/
1623static Quantum *GetAuthenticPixelsCache(Image *image,const ssize_t x,
1624 const ssize_t y,const size_t columns,const size_t rows,
1625 ExceptionInfo *exception)
1626{
1627 CacheInfo
1628 *magick_restrict cache_info;
1629
1630 const int
1631 id = GetOpenMPThreadId();
1632
1633 Quantum
1634 *magick_restrict pixels;
1635
1636 assert(image != (const Image *) NULL);
1637 assert(image->signature == MagickCoreSignature);
1638 assert(image->cache != (Cache) NULL);
1639 cache_info=(CacheInfo *) image->cache;
1640 if (cache_info == (Cache) NULL)
1641 return((Quantum *) NULL);
1642 assert(cache_info->signature == MagickCoreSignature);
1643 assert(id < (int) cache_info->number_threads);
1644 pixels=GetAuthenticPixelCacheNexus(image,x,y,columns,rows,
1645 cache_info->nexus_info[id],exception);
1646 return(pixels);
1647}
1648␌
1649/*
1650%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1651% %
1652% %
1653% %
1654+ G e t I m a g e E x t e n t %
1655% %
1656% %
1657% %
1658%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1659%
1660% GetImageExtent() returns the extent of the pixels associated corresponding
1661% with the last call to QueueAuthenticPixels() or GetAuthenticPixels().
1662%
1663% The format of the GetImageExtent() method is:
1664%
1665% MagickSizeType GetImageExtent(const Image *image)
1666%
1667% A description of each parameter follows:
1668%
1669% o image: the image.
1670%
1671*/
1672MagickExport MagickSizeType GetImageExtent(const Image *image)
1673{
1674 CacheInfo
1675 *magick_restrict cache_info;
1676
1677 const int
1678 id = GetOpenMPThreadId();
1679
1680 assert(image != (Image *) NULL);
1681 assert(image->signature == MagickCoreSignature);
1682 if (IsEventLogging() != MagickFalse)
1683 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1684 assert(image->cache != (Cache) NULL);
1685 cache_info=(CacheInfo *) image->cache;
1686 assert(cache_info->signature == MagickCoreSignature);
1687 assert(id < (int) cache_info->number_threads);
1688 return(GetPixelCacheNexusExtent(cache_info,cache_info->nexus_info[id]));
1689}
1690␌
1691/*
1692%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1693% %
1694% %
1695% %
1696+ G e t I m a g e P i x e l C a c h e %
1697% %
1698% %
1699% %
1700%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1701%
1702% GetImagePixelCache() ensures that there is only a single reference to the
1703% pixel cache to be modified, updating the provided cache pointer to point to
1704% a clone of the original pixel cache if necessary.
1705%
1706% The format of the GetImagePixelCache method is:
1707%
1708% Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
1709% ExceptionInfo *exception)
1710%
1711% A description of each parameter follows:
1712%
1713% o image: the image.
1714%
1715% o clone: any value other than MagickFalse clones the cache pixels.
1716%
1717% o exception: return any errors or warnings in this structure.
1718%
1719*/
1720
1721static MagickBooleanType GetDynamicThrottlePolicy(void)
1722{
1723 static MagickBooleanType
1724 check_policy = MagickTrue;
1725
1726 static MagickBooleanType
1727 dynamic_throttle = MagickFalse;
1728
1729 if (check_policy != MagickFalse)
1730 {
1731 char *value = GetPolicyValue("resource:dynamic-throttle");
1732 if (value != (char *) NULL)
1733 {
1734 dynamic_throttle=IsStringTrue(value);
1735 value=DestroyString(value);
1736 }
1737 check_policy=MagickFalse;
1738 }
1739 return(dynamic_throttle);
1740}
1741
1742static inline MagickBooleanType ValidatePixelCacheMorphology(
1743 const Image *magick_restrict image)
1744{
1745 const CacheInfo
1746 *magick_restrict cache_info;
1747
1748 const PixelChannelMap
1749 *magick_restrict p,
1750 *magick_restrict q;
1751
1752 /*
1753 Does the image match the pixel cache morphology?
1754 */
1755 cache_info=(CacheInfo *) image->cache;
1756 p=image->channel_map;
1757 q=cache_info->channel_map;
1758 if ((image->storage_class != cache_info->storage_class) ||
1759 (image->colorspace != cache_info->colorspace) ||
1760 (image->alpha_trait != cache_info->alpha_trait) ||
1761 (image->channels != cache_info->channels) ||
1762 (image->columns != cache_info->columns) ||
1763 (image->rows != cache_info->rows) ||
1764 (image->number_channels != cache_info->number_channels) ||
1765 (memcmp(p,q,image->number_channels*sizeof(*p)) != 0) ||
1766 (image->metacontent_extent != cache_info->metacontent_extent) ||
1767 (cache_info->nexus_info == (NexusInfo **) NULL))
1768 return(MagickFalse);
1769 return(MagickTrue);
1770}
1771
1772static Cache GetImagePixelCache(Image *image,const MagickBooleanType clone,
1773 ExceptionInfo *exception)
1774{
1775 CacheInfo
1776 *magick_restrict cache_info;
1777
1778 MagickBooleanType
1779 destroy,
1780 status = MagickTrue;
1781
1782 static MagickSizeType
1783 cpu_throttle = MagickResourceInfinity,
1784 cycles = 0;
1785
1786 if (IsImageTTLExpired(image) != MagickFalse)
1787 {
1788#if defined(ESTALE)
1789 errno=ESTALE;
1790#endif
1791 (void) ThrowMagickException(exception,GetMagickModule(),
1792 ResourceLimitError,"TimeLimitExceeded","`%s'",image->filename);
1793 return((Cache) NULL);
1794 }
1795 if (cpu_throttle == MagickResourceInfinity)
1796 cpu_throttle=GetMagickResourceLimit(ThrottleResource);
1797 if ((GetDynamicThrottlePolicy() != MagickFalse) && ((cycles % 65536) == 0))
1798 {
1799 const double
1800 max_delay = 50.0,
1801 sensitivity = 0.3;
1802
1803 double
1804 load,
1805 load_average = 0.0;
1806
1807 /*
1808 Dynamically throttle the CPU relative to the load average.
1809 */
1810#if defined(MAGICKCORE_HAVE_GETLOADAVG)
1811 if (getloadavg(&load_average,1) != 1)
1812 load_average=0.0;
1813#endif
1814 load=MagickMax(load_average-GetOpenMPMaximumThreads(),0.0);
1815 cpu_throttle=(MagickSizeType) (max_delay*(1.0-exp(-sensitivity*load)));
1816 }
1817 if ((cpu_throttle != 0) && ((cycles % 4096) == 0))
1818 MagickDelay(cpu_throttle);
1819 cycles++;
1820 LockSemaphoreInfo(image->semaphore);
1821 assert(image->cache != (Cache) NULL);
1822 cache_info=(CacheInfo *) image->cache;
1823#if defined(MAGICKCORE_OPENCL_SUPPORT)
1824 CopyOpenCLBuffer(cache_info);
1825#endif
1826 destroy=MagickFalse;
1827 if ((cache_info->reference_count > 1) || (cache_info->mode == ReadMode))
1828 {
1829 LockSemaphoreInfo(cache_info->semaphore);
1830 if ((cache_info->reference_count > 1) || (cache_info->mode == ReadMode))
1831 {
1832 CacheInfo
1833 *clone_info;
1834
1835 Image
1836 clone_image;
1837
1838 /*
1839 Clone pixel cache.
1840 */
1841 clone_image=(*image);
1842 clone_image.semaphore=AcquireSemaphoreInfo();
1843 clone_image.reference_count=1;
1844 clone_image.cache=ClonePixelCache(cache_info);
1845 clone_info=(CacheInfo *) clone_image.cache;
1846 status=OpenPixelCache(&clone_image,IOMode,exception);
1847 if (status == MagickFalse)
1848 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
1849 else
1850 {
1851 if (clone != MagickFalse)
1852 status=ClonePixelCacheRepository(clone_info,cache_info,
1853 exception);
1854 if (status == MagickFalse)
1855 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
1856 else
1857 {
1858 destroy=MagickTrue;
1859 image->cache=clone_info;
1860 }
1861 }
1862 RelinquishSemaphoreInfo(&clone_image.semaphore);
1863 }
1864 UnlockSemaphoreInfo(cache_info->semaphore);
1865 }
1866 if (destroy != MagickFalse)
1867 cache_info=(CacheInfo *) DestroyPixelCache(cache_info);
1868 if (status != MagickFalse)
1869 {
1870 /*
1871 Ensure the image matches the pixel cache morphology.
1872 */
1873 if (ValidatePixelCacheMorphology(image) == MagickFalse)
1874 {
1875 image->type=UndefinedType;
1876 status=OpenPixelCache(image,IOMode,exception);
1877 cache_info=(CacheInfo *) image->cache;
1878 if (cache_info->file != -1)
1879 (void) ClosePixelCacheOnDisk(cache_info);
1880 }
1881 }
1882 UnlockSemaphoreInfo(image->semaphore);
1883 if (status == MagickFalse)
1884 return((Cache) NULL);
1885 return(image->cache);
1886}
1887␌
1888/*
1889%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1890% %
1891% %
1892% %
1893+ G e t I m a g e P i x e l C a c h e T y p e %
1894% %
1895% %
1896% %
1897%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1898%
1899% GetImagePixelCacheType() returns the pixel cache type: UndefinedCache,
1900% DiskCache, MemoryCache, MapCache, or PingCache.
1901%
1902% The format of the GetImagePixelCacheType() method is:
1903%
1904% CacheType GetImagePixelCacheType(const Image *image)
1905%
1906% A description of each parameter follows:
1907%
1908% o image: the image.
1909%
1910*/
1911MagickExport CacheType GetImagePixelCacheType(const Image *image)
1912{
1913 CacheInfo
1914 *magick_restrict cache_info;
1915
1916 assert(image != (Image *) NULL);
1917 assert(image->signature == MagickCoreSignature);
1918 assert(image->cache != (Cache) NULL);
1919 cache_info=(CacheInfo *) image->cache;
1920 assert(cache_info->signature == MagickCoreSignature);
1921 return(cache_info->type);
1922}
1923␌
1924/*
1925%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1926% %
1927% %
1928% %
1929% G e t O n e A u t h e n t i c P i x e l %
1930% %
1931% %
1932% %
1933%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1934%
1935% GetOneAuthenticPixel() returns a single pixel at the specified (x,y)
1936% location. The image background color is returned if an error occurs.
1937%
1938% The format of the GetOneAuthenticPixel() method is:
1939%
1940% MagickBooleanType GetOneAuthenticPixel(const Image image,const ssize_t x,
1941% const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
1942%
1943% A description of each parameter follows:
1944%
1945% o image: the image.
1946%
1947% o x,y: These values define the location of the pixel to return.
1948%
1949% o pixel: return a pixel at the specified (x,y) location.
1950%
1951% o exception: return any errors or warnings in this structure.
1952%
1953*/
1954
1955static inline MagickBooleanType CopyPixel(const Image *image,
1956 const Quantum *source,Quantum *destination)
1957{
1958 ssize_t
1959 i;
1960
1961 if (source == (const Quantum *) NULL)
1962 {
1963 destination[RedPixelChannel]=ClampToQuantum(image->background_color.red);
1964 destination[GreenPixelChannel]=ClampToQuantum(
1965 image->background_color.green);
1966 destination[BluePixelChannel]=ClampToQuantum(
1967 image->background_color.blue);
1968 destination[BlackPixelChannel]=ClampToQuantum(
1969 image->background_color.black);
1970 destination[AlphaPixelChannel]=ClampToQuantum(
1971 image->background_color.alpha);
1972 return(MagickFalse);
1973 }
1974 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1975 {
1976 PixelChannel channel = GetPixelChannelChannel(image,i);
1977 destination[channel]=source[i];
1978 }
1979 return(MagickTrue);
1980}
1981
1982MagickExport MagickBooleanType GetOneAuthenticPixel(Image *image,
1983 const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
1984{
1985 CacheInfo
1986 *magick_restrict cache_info;
1987
1988 Quantum
1989 *magick_restrict q;
1990
1991 assert(image != (Image *) NULL);
1992 assert(image->signature == MagickCoreSignature);
1993 assert(image->cache != (Cache) NULL);
1994 cache_info=(CacheInfo *) image->cache;
1995 assert(cache_info->signature == MagickCoreSignature);
1996 (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
1997 if (cache_info->methods.get_one_authentic_pixel_from_handler != (GetOneAuthenticPixelFromHandler) NULL)
1998 return(cache_info->methods.get_one_authentic_pixel_from_handler(image,x,y,pixel,exception));
1999 q=GetAuthenticPixelsCache(image,x,y,1UL,1UL,exception);
2000 return(CopyPixel(image,q,pixel));
2001}
2002␌
2003/*
2004%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2005% %
2006% %
2007% %
2008+ G e t O n e A u t h e n t i c P i x e l F r o m C a c h e %
2009% %
2010% %
2011% %
2012%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2013%
2014% GetOneAuthenticPixelFromCache() returns a single pixel at the specified (x,y)
2015% location. The image background color is returned if an error occurs.
2016%
2017% The format of the GetOneAuthenticPixelFromCache() method is:
2018%
2019% MagickBooleanType GetOneAuthenticPixelFromCache(const Image image,
2020% const ssize_t x,const ssize_t y,Quantum *pixel,
2021% ExceptionInfo *exception)
2022%
2023% A description of each parameter follows:
2024%
2025% o image: the image.
2026%
2027% o x,y: These values define the location of the pixel to return.
2028%
2029% o pixel: return a pixel at the specified (x,y) location.
2030%
2031% o exception: return any errors or warnings in this structure.
2032%
2033*/
2034static MagickBooleanType GetOneAuthenticPixelFromCache(Image *image,
2035 const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
2036{
2037 CacheInfo
2038 *magick_restrict cache_info;
2039
2040 const int
2041 id = GetOpenMPThreadId();
2042
2043 Quantum
2044 *magick_restrict q;
2045
2046 assert(image != (const Image *) NULL);
2047 assert(image->signature == MagickCoreSignature);
2048 assert(image->cache != (Cache) NULL);
2049 cache_info=(CacheInfo *) image->cache;
2050 assert(cache_info->signature == MagickCoreSignature);
2051 assert(id < (int) cache_info->number_threads);
2052 (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
2053 q=GetAuthenticPixelCacheNexus(image,x,y,1UL,1UL,cache_info->nexus_info[id],
2054 exception);
2055 return(CopyPixel(image,q,pixel));
2056}
2057␌
2058/*
2059%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2060% %
2061% %
2062% %
2063% G e t O n e V i r t u a l P i x e l %
2064% %
2065% %
2066% %
2067%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2068%
2069% GetOneVirtualPixel() returns a single virtual pixel at the specified
2070% (x,y) location. The image background color is returned if an error occurs.
2071% If you plan to modify the pixel, use GetOneAuthenticPixel() instead.
2072%
2073% The format of the GetOneVirtualPixel() method is:
2074%
2075% MagickBooleanType GetOneVirtualPixel(const Image image,const ssize_t x,
2076% const ssize_t y,Quantum *pixel,ExceptionInfo exception)
2077%
2078% A description of each parameter follows:
2079%
2080% o image: the image.
2081%
2082% o x,y: These values define the location of the pixel to return.
2083%
2084% o pixel: return a pixel at the specified (x,y) location.
2085%
2086% o exception: return any errors or warnings in this structure.
2087%
2088*/
2089MagickExport MagickBooleanType GetOneVirtualPixel(const Image *image,
2090 const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
2091{
2092 CacheInfo
2093 *magick_restrict cache_info;
2094
2095 const int
2096 id = GetOpenMPThreadId();
2097
2098 const Quantum
2099 *p;
2100
2101 assert(image != (const Image *) NULL);
2102 assert(image->signature == MagickCoreSignature);
2103 assert(image->cache != (Cache) NULL);
2104 cache_info=(CacheInfo *) image->cache;
2105 assert(cache_info->signature == MagickCoreSignature);
2106 (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
2107 if (cache_info->methods.get_one_virtual_pixel_from_handler !=
2108 (GetOneVirtualPixelFromHandler) NULL)
2109 return(cache_info->methods.get_one_virtual_pixel_from_handler(image,
2110 GetPixelCacheVirtualMethod(image),x,y,pixel,exception));
2111 assert(id < (int) cache_info->number_threads);
2112 p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
2113 1UL,1UL,cache_info->nexus_info[id],exception);
2114 return(CopyPixel(image,p,pixel));
2115}
2116␌
2117/*
2118%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2119% %
2120% %
2121% %
2122+ G e t O n e V i r t u a l P i x e l F r o m C a c h e %
2123% %
2124% %
2125% %
2126%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2127%
2128% GetOneVirtualPixelFromCache() returns a single virtual pixel at the
2129% specified (x,y) location. The image background color is returned if an
2130% error occurs.
2131%
2132% The format of the GetOneVirtualPixelFromCache() method is:
2133%
2134% MagickBooleanType GetOneVirtualPixelFromCache(const Image image,
2135% const VirtualPixelMethod method,const ssize_t x,const ssize_t y,
2136% Quantum *pixel,ExceptionInfo *exception)
2137%
2138% A description of each parameter follows:
2139%
2140% o image: the image.
2141%
2142% o virtual_pixel_method: the virtual pixel method.
2143%
2144% o x,y: These values define the location of the pixel to return.
2145%
2146% o pixel: return a pixel at the specified (x,y) location.
2147%
2148% o exception: return any errors or warnings in this structure.
2149%
2150*/
2151static MagickBooleanType GetOneVirtualPixelFromCache(const Image *image,
2152 const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
2153 Quantum *pixel,ExceptionInfo *exception)
2154{
2155 CacheInfo
2156 *magick_restrict cache_info;
2157
2158 const int
2159 id = GetOpenMPThreadId();
2160
2161 const Quantum
2162 *p;
2163
2164 assert(image != (const Image *) NULL);
2165 assert(image->signature == MagickCoreSignature);
2166 assert(image->cache != (Cache) NULL);
2167 cache_info=(CacheInfo *) image->cache;
2168 assert(cache_info->signature == MagickCoreSignature);
2169 assert(id < (int) cache_info->number_threads);
2170 (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
2171 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
2172 cache_info->nexus_info[id],exception);
2173 return(CopyPixel(image,p,pixel));
2174}
2175␌
2176/*
2177%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2178% %
2179% %
2180% %
2181% G e t O n e V i r t u a l P i x e l I n f o %
2182% %
2183% %
2184% %
2185%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2186%
2187% GetOneVirtualPixelInfo() returns a single pixel at the specified (x,y)
2188% location. The image background color is returned if an error occurs. If
2189% you plan to modify the pixel, use GetOneAuthenticPixel() instead.
2190%
2191% The format of the GetOneVirtualPixelInfo() method is:
2192%
2193% MagickBooleanType GetOneVirtualPixelInfo(const Image image,
2194% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
2195% const ssize_t y,PixelInfo *pixel,ExceptionInfo exception)
2196%
2197% A description of each parameter follows:
2198%
2199% o image: the image.
2200%
2201% o virtual_pixel_method: the virtual pixel method.
2202%
2203% o x,y: these values define the location of the pixel to return.
2204%
2205% o pixel: return a pixel at the specified (x,y) location.
2206%
2207% o exception: return any errors or warnings in this structure.
2208%
2209*/
2210MagickExport MagickBooleanType GetOneVirtualPixelInfo(const Image *image,
2211 const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
2212 PixelInfo *pixel,ExceptionInfo *exception)
2213{
2214 CacheInfo
2215 *magick_restrict cache_info;
2216
2217 const int
2218 id = GetOpenMPThreadId();
2219
2220 const Quantum
2221 *magick_restrict p;
2222
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 GetPixelInfo(image,pixel);
2230 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,1UL,1UL,
2231 cache_info->nexus_info[id],exception);
2232 if (p == (const Quantum *) NULL)
2233 return(MagickFalse);
2234 GetPixelInfoPixel(image,p,pixel);
2235 return(MagickTrue);
2236}
2237␌
2238/*
2239%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2240% %
2241% %
2242% %
2243+ G e t P i x e l C a c h e C o l o r s p a c e %
2244% %
2245% %
2246% %
2247%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2248%
2249% GetPixelCacheColorspace() returns the colorspace of the pixel cache.
2250%
2251% The format of the GetPixelCacheColorspace() method is:
2252%
2253% Colorspace GetPixelCacheColorspace(const Cache cache)
2254%
2255% A description of each parameter follows:
2256%
2257% o cache: the pixel cache.
2258%
2259*/
2260MagickPrivate ColorspaceType GetPixelCacheColorspace(const Cache cache)
2261{
2262 CacheInfo
2263 *magick_restrict cache_info;
2264
2265 assert(cache != (Cache) NULL);
2266 cache_info=(CacheInfo *) cache;
2267 assert(cache_info->signature == MagickCoreSignature);
2268 if (IsEventLogging() != MagickFalse)
2269 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2270 cache_info->filename);
2271 return(cache_info->colorspace);
2272}
2273␌
2274/*
2275%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2276% %
2277% %
2278% %
2279+ G e t P i x e l C a c h e F i l e n a m e %
2280% %
2281% %
2282% %
2283%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2284%
2285% GetPixelCacheFilename() returns the filename associated with the pixel
2286% cache.
2287%
2288% The format of the GetPixelCacheFilename() method is:
2289%
2290% const char *GetPixelCacheFilename(const Image *image)
2291%
2292% A description of each parameter follows:
2293%
2294% o image: the image.
2295%
2296*/
2297MagickExport const char *GetPixelCacheFilename(const Image *image)
2298{
2299 CacheInfo
2300 *magick_restrict cache_info;
2301
2302 assert(image != (const Image *) NULL);
2303 assert(image->signature == MagickCoreSignature);
2304 assert(image->cache != (Cache) NULL);
2305 cache_info=(CacheInfo *) image->cache;
2306 assert(cache_info->signature == MagickCoreSignature);
2307 return(cache_info->cache_filename);
2308}
2309␌
2310/*
2311%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2312% %
2313% %
2314% %
2315+ G e t P i x e l C a c h e M e t h o d s %
2316% %
2317% %
2318% %
2319%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2320%
2321% GetPixelCacheMethods() initializes the CacheMethods structure.
2322%
2323% The format of the GetPixelCacheMethods() method is:
2324%
2325% void GetPixelCacheMethods(CacheMethods *cache_methods)
2326%
2327% A description of each parameter follows:
2328%
2329% o cache_methods: Specifies a pointer to a CacheMethods structure.
2330%
2331*/
2332MagickPrivate void GetPixelCacheMethods(CacheMethods *cache_methods)
2333{
2334 assert(cache_methods != (CacheMethods *) NULL);
2335 (void) memset(cache_methods,0,sizeof(*cache_methods));
2336 cache_methods->get_virtual_pixel_handler=GetVirtualPixelCache;
2337 cache_methods->get_virtual_pixels_handler=GetVirtualPixelsCache;
2338 cache_methods->get_virtual_metacontent_from_handler=
2339 GetVirtualMetacontentFromCache;
2340 cache_methods->get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromCache;
2341 cache_methods->get_authentic_pixels_handler=GetAuthenticPixelsCache;
2342 cache_methods->get_authentic_metacontent_from_handler=
2343 GetAuthenticMetacontentFromCache;
2344 cache_methods->get_authentic_pixels_from_handler=GetAuthenticPixelsFromCache;
2345 cache_methods->get_one_authentic_pixel_from_handler=
2346 GetOneAuthenticPixelFromCache;
2347 cache_methods->queue_authentic_pixels_handler=QueueAuthenticPixelsCache;
2348 cache_methods->sync_authentic_pixels_handler=SyncAuthenticPixelsCache;
2349 cache_methods->destroy_pixel_handler=DestroyImagePixelCache;
2350}
2351␌
2352/*
2353%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2354% %
2355% %
2356% %
2357+ G e t P i x e l C a c h e N e x u s E x t e n t %
2358% %
2359% %
2360% %
2361%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2362%
2363% GetPixelCacheNexusExtent() returns the extent of the pixels associated
2364% corresponding with the last call to SetPixelCacheNexusPixels() or
2365% GetPixelCacheNexusPixels().
2366%
2367% The format of the GetPixelCacheNexusExtent() method is:
2368%
2369% MagickSizeType GetPixelCacheNexusExtent(const Cache cache,
2370% NexusInfo *nexus_info)
2371%
2372% A description of each parameter follows:
2373%
2374% o nexus_info: the nexus info.
2375%
2376*/
2377MagickPrivate MagickSizeType GetPixelCacheNexusExtent(const Cache cache,
2378 NexusInfo *magick_restrict nexus_info)
2379{
2380 CacheInfo
2381 *magick_restrict cache_info;
2382
2383 MagickSizeType
2384 extent;
2385
2386 assert(cache != NULL);
2387 cache_info=(CacheInfo *) cache;
2388 assert(cache_info->signature == MagickCoreSignature);
2389 extent=(MagickSizeType) nexus_info->region.width*nexus_info->region.height;
2390 if (extent == 0)
2391 return((MagickSizeType) cache_info->columns*cache_info->rows);
2392 return(extent);
2393}
2394␌
2395/*
2396%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2397% %
2398% %
2399% %
2400+ G e t P i x e l C a c h e P i x e l s %
2401% %
2402% %
2403% %
2404%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2405%
2406% GetPixelCachePixels() returns the pixels associated with the specified image.
2407%
2408% The format of the GetPixelCachePixels() method is:
2409%
2410% void *GetPixelCachePixels(Image *image,MagickSizeType *length,
2411% ExceptionInfo *exception)
2412%
2413% A description of each parameter follows:
2414%
2415% o image: the image.
2416%
2417% o length: the pixel cache length.
2418%
2419% o exception: return any errors or warnings in this structure.
2420%
2421*/
2422MagickExport void *GetPixelCachePixels(Image *image,MagickSizeType *length,
2423 ExceptionInfo *magick_unused(exception))
2424{
2425 CacheInfo
2426 *magick_restrict cache_info;
2427
2428 assert(image != (const Image *) NULL);
2429 assert(image->signature == MagickCoreSignature);
2430 assert(image->cache != (Cache) NULL);
2431 assert(length != (MagickSizeType *) NULL);
2432 magick_unreferenced(exception);
2433 cache_info=(CacheInfo *) image->cache;
2434 assert(cache_info->signature == MagickCoreSignature);
2435 *length=cache_info->length;
2436 if ((cache_info->type != MemoryCache) && (cache_info->type != MapCache))
2437 return((void *) NULL);
2438 return((void *) cache_info->pixels);
2439}
2440␌
2441/*
2442%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2443% %
2444% %
2445% %
2446+ G e t P i x e l C a c h e S t o r a g e C l a s s %
2447% %
2448% %
2449% %
2450%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2451%
2452% GetPixelCacheStorageClass() returns the class type of the pixel cache.
2453%
2454% The format of the GetPixelCacheStorageClass() method is:
2455%
2456% ClassType GetPixelCacheStorageClass(Cache cache)
2457%
2458% A description of each parameter follows:
2459%
2460% o type: GetPixelCacheStorageClass returns DirectClass or PseudoClass.
2461%
2462% o cache: the pixel cache.
2463%
2464*/
2465MagickPrivate ClassType GetPixelCacheStorageClass(const Cache cache)
2466{
2467 CacheInfo
2468 *magick_restrict cache_info;
2469
2470 assert(cache != (Cache) NULL);
2471 cache_info=(CacheInfo *) cache;
2472 assert(cache_info->signature == MagickCoreSignature);
2473 if (IsEventLogging() != MagickFalse)
2474 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2475 cache_info->filename);
2476 return(cache_info->storage_class);
2477}
2478␌
2479/*
2480%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2481% %
2482% %
2483% %
2484+ G e t P i x e l C a c h e T i l e S i z e %
2485% %
2486% %
2487% %
2488%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2489%
2490% GetPixelCacheTileSize() returns the pixel cache tile size.
2491%
2492% The format of the GetPixelCacheTileSize() method is:
2493%
2494% void GetPixelCacheTileSize(const Image *image,size_t *width,
2495% size_t *height)
2496%
2497% A description of each parameter follows:
2498%
2499% o image: the image.
2500%
2501% o width: the optimized cache tile width in pixels.
2502%
2503% o height: the optimized cache tile height in pixels.
2504%
2505*/
2506MagickPrivate void GetPixelCacheTileSize(const Image *image,size_t *width,
2507 size_t *height)
2508{
2509 CacheInfo
2510 *magick_restrict cache_info;
2511
2512 assert(image != (Image *) NULL);
2513 assert(image->signature == MagickCoreSignature);
2514 if (IsEventLogging() != MagickFalse)
2515 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2516 cache_info=(CacheInfo *) image->cache;
2517 assert(cache_info->signature == MagickCoreSignature);
2518 *width=2048UL/(MagickMax(cache_info->number_channels,1)*sizeof(Quantum));
2519 if (GetImagePixelCacheType(image) == DiskCache)
2520 *width=8192UL/(MagickMax(cache_info->number_channels,1)*sizeof(Quantum));
2521 *height=(*width);
2522}
2523␌
2524/*
2525%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2526% %
2527% %
2528% %
2529+ G e t P i x e l C a c h e V i r t u a l M e t h o d %
2530% %
2531% %
2532% %
2533%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2534%
2535% GetPixelCacheVirtualMethod() gets the "virtual pixels" method for the
2536% pixel cache. A virtual pixel is any pixel access that is outside the
2537% boundaries of the image cache.
2538%
2539% The format of the GetPixelCacheVirtualMethod() method is:
2540%
2541% VirtualPixelMethod GetPixelCacheVirtualMethod(const Image *image)
2542%
2543% A description of each parameter follows:
2544%
2545% o image: the image.
2546%
2547*/
2548MagickPrivate VirtualPixelMethod GetPixelCacheVirtualMethod(const Image *image)
2549{
2550 CacheInfo
2551 *magick_restrict cache_info;
2552
2553 assert(image != (Image *) NULL);
2554 assert(image->signature == MagickCoreSignature);
2555 assert(image->cache != (Cache) NULL);
2556 cache_info=(CacheInfo *) image->cache;
2557 assert(cache_info->signature == MagickCoreSignature);
2558 return(cache_info->virtual_pixel_method);
2559}
2560␌
2561/*
2562%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2563% %
2564% %
2565% %
2566+ G e t V i r t u a l M e t a c o n t e n t F r o m C a c h e %
2567% %
2568% %
2569% %
2570%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2571%
2572% GetVirtualMetacontentFromCache() returns the meta-content corresponding with
2573% the last call to QueueAuthenticPixelsCache() or GetVirtualPixelCache().
2574%
2575% The format of the GetVirtualMetacontentFromCache() method is:
2576%
2577% void *GetVirtualMetacontentFromCache(const Image *image)
2578%
2579% A description of each parameter follows:
2580%
2581% o image: the image.
2582%
2583*/
2584static const void *GetVirtualMetacontentFromCache(const Image *image)
2585{
2586 CacheInfo
2587 *magick_restrict cache_info;
2588
2589 const int
2590 id = GetOpenMPThreadId();
2591
2592 const void
2593 *magick_restrict metacontent;
2594
2595 assert(image != (const Image *) NULL);
2596 assert(image->signature == MagickCoreSignature);
2597 assert(image->cache != (Cache) NULL);
2598 cache_info=(CacheInfo *) image->cache;
2599 assert(cache_info->signature == MagickCoreSignature);
2600 assert(id < (int) cache_info->number_threads);
2601 metacontent=GetVirtualMetacontentFromNexus(cache_info,
2602 cache_info->nexus_info[id]);
2603 return(metacontent);
2604}
2605␌
2606/*
2607%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2608% %
2609% %
2610% %
2611+ G e t V i r t u a l M e t a c o n t e n t F r o m N e x u s %
2612% %
2613% %
2614% %
2615%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2616%
2617% GetVirtualMetacontentFromNexus() returns the meta-content for the specified
2618% cache nexus.
2619%
2620% The format of the GetVirtualMetacontentFromNexus() method is:
2621%
2622% const void *GetVirtualMetacontentFromNexus(const Cache cache,
2623% NexusInfo *nexus_info)
2624%
2625% A description of each parameter follows:
2626%
2627% o cache: the pixel cache.
2628%
2629% o nexus_info: the cache nexus to return the meta-content.
2630%
2631*/
2632MagickPrivate const void *GetVirtualMetacontentFromNexus(const Cache cache,
2633 NexusInfo *magick_restrict nexus_info)
2634{
2635 CacheInfo
2636 *magick_restrict cache_info;
2637
2638 assert(cache != (Cache) NULL);
2639 cache_info=(CacheInfo *) cache;
2640 assert(cache_info->signature == MagickCoreSignature);
2641 if (cache_info->storage_class == UndefinedClass)
2642 return((void *) NULL);
2643 return(nexus_info->metacontent);
2644}
2645␌
2646/*
2647%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2648% %
2649% %
2650% %
2651% G e t V i r t u a l M e t a c o n t e n t %
2652% %
2653% %
2654% %
2655%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2656%
2657% GetVirtualMetacontent() returns the virtual metacontent corresponding with
2658% the last call to QueueAuthenticPixels() or GetVirtualPixels(). NULL is
2659% returned if the meta-content are not available.
2660%
2661% The format of the GetVirtualMetacontent() method is:
2662%
2663% const void *GetVirtualMetacontent(const Image *image)
2664%
2665% A description of each parameter follows:
2666%
2667% o image: the image.
2668%
2669*/
2670MagickExport const void *GetVirtualMetacontent(const Image *image)
2671{
2672 CacheInfo
2673 *magick_restrict cache_info;
2674
2675 const int
2676 id = GetOpenMPThreadId();
2677
2678 const void
2679 *magick_restrict metacontent;
2680
2681 assert(image != (const Image *) NULL);
2682 assert(image->signature == MagickCoreSignature);
2683 assert(image->cache != (Cache) NULL);
2684 cache_info=(CacheInfo *) image->cache;
2685 assert(cache_info->signature == MagickCoreSignature);
2686 if (cache_info->methods.get_virtual_metacontent_from_handler != (GetVirtualMetacontentFromHandler) NULL)
2687 {
2688 metacontent=cache_info->methods.get_virtual_metacontent_from_handler(
2689 image);
2690 if (metacontent != (const void *) NULL)
2691 return(metacontent);
2692 }
2693 assert(id < (int) cache_info->number_threads);
2694 metacontent=GetVirtualMetacontentFromNexus(cache_info,
2695 cache_info->nexus_info[id]);
2696 return(metacontent);
2697}
2698␌
2699/*
2700%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2701% %
2702% %
2703% %
2704+ G e t V i r t u a l P i x e l C a c h e N e x u s %
2705% %
2706% %
2707% %
2708%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2709%
2710% GetVirtualPixelCacheNexus() gets virtual pixels from the in-memory or disk
2711% pixel cache as defined by the geometry parameters. A pointer to the pixels
2712% is returned if the pixels are transferred, otherwise a NULL is returned.
2713%
2714% The format of the GetVirtualPixelCacheNexus() method is:
2715%
2716% Quantum *GetVirtualPixelCacheNexus(const Image *image,
2717% const VirtualPixelMethod method,const ssize_t x,const ssize_t y,
2718% const size_t columns,const size_t rows,NexusInfo *nexus_info,
2719% ExceptionInfo *exception)
2720%
2721% A description of each parameter follows:
2722%
2723% o image: the image.
2724%
2725% o virtual_pixel_method: the virtual pixel method.
2726%
2727% o x,y,columns,rows: These values define the perimeter of a region of
2728% pixels.
2729%
2730% o nexus_info: the cache nexus to acquire.
2731%
2732% o exception: return any errors or warnings in this structure.
2733%
2734*/
2735
2736static ssize_t
2737 DitherMatrix[64] =
2738 {
2739 0, 48, 12, 60, 3, 51, 15, 63,
2740 32, 16, 44, 28, 35, 19, 47, 31,
2741 8, 56, 4, 52, 11, 59, 7, 55,
2742 40, 24, 36, 20, 43, 27, 39, 23,
2743 2, 50, 14, 62, 1, 49, 13, 61,
2744 34, 18, 46, 30, 33, 17, 45, 29,
2745 10, 58, 6, 54, 9, 57, 5, 53,
2746 42, 26, 38, 22, 41, 25, 37, 21
2747 };
2748
2749static inline ssize_t DitherX(const ssize_t x,const size_t columns)
2750{
2751 ssize_t
2752 index;
2753
2754 index=x+DitherMatrix[x & 0x07]-32L;
2755 if (index < 0L)
2756 return(0L);
2757 if (index >= (ssize_t) columns)
2758 return((ssize_t) columns-1L);
2759 return(index);
2760}
2761
2762static inline ssize_t DitherY(const ssize_t y,const size_t rows)
2763{
2764 ssize_t
2765 index;
2766
2767 index=y+DitherMatrix[y & 0x07]-32L;
2768 if (index < 0L)
2769 return(0L);
2770 if (index >= (ssize_t) rows)
2771 return((ssize_t) rows-1L);
2772 return(index);
2773}
2774
2775static inline ssize_t EdgeX(const ssize_t x,const size_t columns)
2776{
2777 if (x < 0L)
2778 return(0L);
2779 if (x >= (ssize_t) columns)
2780 return((ssize_t) (columns-1));
2781 return(x);
2782}
2783
2784static inline ssize_t EdgeY(const ssize_t y,const size_t rows)
2785{
2786 if (y < 0L)
2787 return(0L);
2788 if (y >= (ssize_t) rows)
2789 return((ssize_t) (rows-1));
2790 return(y);
2791}
2792
2793static inline MagickBooleanType IsOffsetOverflow(const MagickOffsetType x,
2794 const MagickOffsetType y)
2795{
2796 if (((y > 0) && (x > ((MagickOffsetType) MAGICK_SSIZE_MAX-y))) ||
2797 ((y < 0) && (x < ((MagickOffsetType) MAGICK_SSIZE_MIN-y))))
2798 return(MagickFalse);
2799 return(MagickTrue);
2800}
2801
2802static inline ssize_t RandomX(RandomInfo *random_info,const size_t columns)
2803{
2804 return((ssize_t) (columns*GetPseudoRandomValue(random_info)));
2805}
2806
2807static inline ssize_t RandomY(RandomInfo *random_info,const size_t rows)
2808{
2809 return((ssize_t) (rows*GetPseudoRandomValue(random_info)));
2810}
2811
2812static inline MagickModulo VirtualPixelModulo(const ssize_t offset,
2813 const size_t extent)
2814{
2815 MagickModulo
2816 modulo;
2817
2818 modulo.quotient=offset;
2819 modulo.remainder=0;
2820 if (extent != 0)
2821 {
2822 modulo.quotient=offset/((ssize_t) extent);
2823 modulo.remainder=offset % ((ssize_t) extent);
2824 }
2825 if ((modulo.remainder != 0) && ((offset ^ ((ssize_t) extent)) < 0))
2826 {
2827 modulo.quotient-=1;
2828 modulo.remainder+=((ssize_t) extent);
2829 }
2830 return(modulo);
2831}
2832
2833MagickPrivate const Quantum *GetVirtualPixelCacheNexus(const Image *image,
2834 const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
2835 const size_t columns,const size_t rows,NexusInfo *nexus_info,
2836 ExceptionInfo *exception)
2837{
2838 CacheInfo
2839 *magick_restrict cache_info;
2840
2841 const Quantum
2842 *magick_restrict p;
2843
2844 const void
2845 *magick_restrict r;
2846
2847 MagickOffsetType
2848 offset;
2849
2850 MagickSizeType
2851 length,
2852 number_pixels;
2853
2854 NexusInfo
2855 *magick_restrict virtual_nexus;
2856
2857 Quantum
2858 *magick_restrict pixels,
2859 *magick_restrict q,
2860 virtual_pixel[MaxPixelChannels];
2861
2862 ssize_t
2863 i,
2864 u,
2865 v;
2866
2867 unsigned char
2868 *magick_restrict s;
2869
2870 void
2871 *magick_restrict virtual_metacontent;
2872
2873 /*
2874 Acquire pixels.
2875 */
2876 assert(image != (const Image *) NULL);
2877 assert(image->signature == MagickCoreSignature);
2878 assert(image->cache != (Cache) NULL);
2879 cache_info=(CacheInfo *) image->cache;
2880 assert(cache_info->signature == MagickCoreSignature);
2881 if (cache_info->type == UndefinedCache)
2882 return((const Quantum *) NULL);
2883#if defined(MAGICKCORE_OPENCL_SUPPORT)
2884 CopyOpenCLBuffer(cache_info);
2885#endif
2886 pixels=SetPixelCacheNexusPixels(cache_info,ReadMode,x,y,columns,rows,
2887 ((image->channels & WriteMaskChannel) != 0) ||
2888 ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
2889 nexus_info,exception);
2890 if (pixels == (Quantum *) NULL)
2891 return((const Quantum *) NULL);
2892 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
2893 return((const Quantum *) NULL);
2894 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns;
2895 if (IsOffsetOverflow(offset,(MagickOffsetType) nexus_info->region.x) == MagickFalse)
2896 return((const Quantum *) NULL);
2897 offset+=nexus_info->region.x;
2898 length=(MagickSizeType) (nexus_info->region.height-1L)*cache_info->columns+
2899 nexus_info->region.width-1L;
2900 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
2901 if ((offset >= 0) && (((MagickSizeType) offset+length) < number_pixels))
2902 if ((x >= 0) && ((x+(ssize_t) columns-1) < (ssize_t) cache_info->columns) &&
2903 (y >= 0) && ((y+(ssize_t) rows-1) < (ssize_t) cache_info->rows))
2904 {
2905 MagickBooleanType
2906 status;
2907
2908 /*
2909 Pixel request is inside cache extents.
2910 */
2911 if (nexus_info->authentic_pixel_cache != MagickFalse)
2912 return(pixels);
2913 status=ReadPixelCachePixels(cache_info,nexus_info,exception);
2914 if (status == MagickFalse)
2915 return((const Quantum *) NULL);
2916 if (cache_info->metacontent_extent != 0)
2917 {
2918 status=ReadPixelCacheMetacontent(cache_info,nexus_info,exception);
2919 if (status == MagickFalse)
2920 return((const Quantum *) NULL);
2921 }
2922 return(pixels);
2923 }
2924 /*
2925 Pixel request is outside cache extents.
2926 */
2927 virtual_nexus=nexus_info->virtual_nexus;
2928 q=pixels;
2929 s=(unsigned char *) nexus_info->metacontent;
2930 (void) memset(virtual_pixel,0,cache_info->number_channels*
2931 sizeof(*virtual_pixel));
2932 virtual_metacontent=(void *) NULL;
2933 switch (virtual_pixel_method)
2934 {
2935 case BackgroundVirtualPixelMethod:
2936 case BlackVirtualPixelMethod:
2937 case GrayVirtualPixelMethod:
2938 case TransparentVirtualPixelMethod:
2939 case MaskVirtualPixelMethod:
2940 case WhiteVirtualPixelMethod:
2941 case EdgeVirtualPixelMethod:
2942 case CheckerTileVirtualPixelMethod:
2943 case HorizontalTileVirtualPixelMethod:
2944 case VerticalTileVirtualPixelMethod:
2945 {
2946 if (cache_info->metacontent_extent != 0)
2947 {
2948 /*
2949 Acquire a metacontent buffer.
2950 */
2951 virtual_metacontent=(void *) AcquireQuantumMemory(1,
2952 cache_info->metacontent_extent);
2953 if (virtual_metacontent == (void *) NULL)
2954 {
2955 (void) ThrowMagickException(exception,GetMagickModule(),
2956 CacheError,"UnableToGetCacheNexus","`%s'",image->filename);
2957 return((const Quantum *) NULL);
2958 }
2959 (void) memset(virtual_metacontent,0,cache_info->metacontent_extent);
2960 }
2961 switch (virtual_pixel_method)
2962 {
2963 case BlackVirtualPixelMethod:
2964 {
2965 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
2966 SetPixelChannel(image,(PixelChannel) i,(Quantum) 0,virtual_pixel);
2967 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
2968 break;
2969 }
2970 case GrayVirtualPixelMethod:
2971 {
2972 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
2973 SetPixelChannel(image,(PixelChannel) i,QuantumRange/2,
2974 virtual_pixel);
2975 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
2976 break;
2977 }
2978 case TransparentVirtualPixelMethod:
2979 {
2980 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
2981 SetPixelChannel(image,(PixelChannel) i,(Quantum) 0,virtual_pixel);
2982 SetPixelAlpha(image,TransparentAlpha,virtual_pixel);
2983 break;
2984 }
2985 case MaskVirtualPixelMethod:
2986 case WhiteVirtualPixelMethod:
2987 {
2988 for (i=0; i < (ssize_t) cache_info->number_channels; i++)
2989 SetPixelChannel(image,(PixelChannel) i,QuantumRange,virtual_pixel);
2990 SetPixelAlpha(image,OpaqueAlpha,virtual_pixel);
2991 break;
2992 }
2993 default:
2994 {
2995 SetPixelRed(image,ClampToQuantum(image->background_color.red),
2996 virtual_pixel);
2997 SetPixelGreen(image,ClampToQuantum(image->background_color.green),
2998 virtual_pixel);
2999 SetPixelBlue(image,ClampToQuantum(image->background_color.blue),
3000 virtual_pixel);
3001 SetPixelBlack(image,ClampToQuantum(image->background_color.black),
3002 virtual_pixel);
3003 SetPixelAlpha(image,ClampToQuantum(image->background_color.alpha),
3004 virtual_pixel);
3005 break;
3006 }
3007 }
3008 break;
3009 }
3010 default:
3011 break;
3012 }
3013 for (v=0; v < (ssize_t) rows; v++)
3014 {
3015 ssize_t
3016 y_offset;
3017
3018 y_offset=y+v;
3019 if ((virtual_pixel_method == EdgeVirtualPixelMethod) ||
3020 (virtual_pixel_method == UndefinedVirtualPixelMethod))
3021 y_offset=EdgeY(y_offset,cache_info->rows);
3022 for (u=0; u < (ssize_t) columns; u+=(ssize_t) length)
3023 {
3024 ssize_t
3025 x_offset;
3026
3027 x_offset=x+u;
3028 length=(MagickSizeType) MagickMin((ssize_t) cache_info->columns-
3029 x_offset,(ssize_t) columns-u);
3030 if (((x_offset < 0) || (x_offset >= (ssize_t) cache_info->columns)) ||
3031 ((y_offset < 0) || (y_offset >= (ssize_t) cache_info->rows)) ||
3032 (length == 0))
3033 {
3034 MagickModulo
3035 x_modulo,
3036 y_modulo;
3037
3038 /*
3039 Transfer a single pixel.
3040 */
3041 length=(MagickSizeType) 1;
3042 switch (virtual_pixel_method)
3043 {
3044 case EdgeVirtualPixelMethod:
3045 default:
3046 {
3047 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3048 EdgeX(x_offset,cache_info->columns),
3049 EdgeY(y_offset,cache_info->rows),1UL,1UL,virtual_nexus,
3050 exception);
3051 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3052 break;
3053 }
3054 case RandomVirtualPixelMethod:
3055 {
3056 if (cache_info->random_info == (RandomInfo *) NULL)
3057 cache_info->random_info=AcquireRandomInfo();
3058 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3059 RandomX(cache_info->random_info,cache_info->columns),
3060 RandomY(cache_info->random_info,cache_info->rows),1UL,1UL,
3061 virtual_nexus,exception);
3062 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3063 break;
3064 }
3065 case DitherVirtualPixelMethod:
3066 {
3067 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3068 DitherX(x_offset,cache_info->columns),
3069 DitherY(y_offset,cache_info->rows),1UL,1UL,virtual_nexus,
3070 exception);
3071 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3072 break;
3073 }
3074 case TileVirtualPixelMethod:
3075 {
3076 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3077 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3078 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3079 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3080 exception);
3081 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3082 break;
3083 }
3084 case MirrorVirtualPixelMethod:
3085 {
3086 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3087 if ((x_modulo.quotient & 0x01) == 1L)
3088 x_modulo.remainder=(ssize_t) cache_info->columns-
3089 x_modulo.remainder-1L;
3090 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3091 if ((y_modulo.quotient & 0x01) == 1L)
3092 y_modulo.remainder=(ssize_t) cache_info->rows-
3093 y_modulo.remainder-1L;
3094 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3095 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3096 exception);
3097 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3098 break;
3099 }
3100 case HorizontalTileEdgeVirtualPixelMethod:
3101 {
3102 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3103 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3104 x_modulo.remainder,EdgeY(y_offset,cache_info->rows),1UL,1UL,
3105 virtual_nexus,exception);
3106 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3107 break;
3108 }
3109 case VerticalTileEdgeVirtualPixelMethod:
3110 {
3111 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3112 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3113 EdgeX(x_offset,cache_info->columns),y_modulo.remainder,1UL,1UL,
3114 virtual_nexus,exception);
3115 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3116 break;
3117 }
3118 case BackgroundVirtualPixelMethod:
3119 case BlackVirtualPixelMethod:
3120 case GrayVirtualPixelMethod:
3121 case TransparentVirtualPixelMethod:
3122 case MaskVirtualPixelMethod:
3123 case WhiteVirtualPixelMethod:
3124 {
3125 p=virtual_pixel;
3126 r=virtual_metacontent;
3127 break;
3128 }
3129 case CheckerTileVirtualPixelMethod:
3130 {
3131 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3132 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3133 if (((x_modulo.quotient ^ y_modulo.quotient) & 0x01) != 0L)
3134 {
3135 p=virtual_pixel;
3136 r=virtual_metacontent;
3137 break;
3138 }
3139 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3140 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3141 exception);
3142 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3143 break;
3144 }
3145 case HorizontalTileVirtualPixelMethod:
3146 {
3147 if ((y_offset < 0) || (y_offset >= (ssize_t) cache_info->rows))
3148 {
3149 p=virtual_pixel;
3150 r=virtual_metacontent;
3151 break;
3152 }
3153 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3154 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3155 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3156 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3157 exception);
3158 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3159 break;
3160 }
3161 case VerticalTileVirtualPixelMethod:
3162 {
3163 if ((x_offset < 0) || (x_offset >= (ssize_t) cache_info->columns))
3164 {
3165 p=virtual_pixel;
3166 r=virtual_metacontent;
3167 break;
3168 }
3169 x_modulo=VirtualPixelModulo(x_offset,cache_info->columns);
3170 y_modulo=VirtualPixelModulo(y_offset,cache_info->rows);
3171 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,
3172 x_modulo.remainder,y_modulo.remainder,1UL,1UL,virtual_nexus,
3173 exception);
3174 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3175 break;
3176 }
3177 }
3178 if (p == (const Quantum *) NULL)
3179 break;
3180 (void) memcpy(q,p,(size_t) (cache_info->number_channels*length*
3181 sizeof(*p)));
3182 q+=(ptrdiff_t) cache_info->number_channels;
3183 if ((s != (void *) NULL) && (r != (const void *) NULL))
3184 {
3185 (void) memcpy(s,r,(size_t) cache_info->metacontent_extent);
3186 s+=(ptrdiff_t) cache_info->metacontent_extent;
3187 }
3188 continue;
3189 }
3190 /*
3191 Transfer a run of pixels.
3192 */
3193 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x_offset,y_offset,
3194 (size_t) length,1UL,virtual_nexus,exception);
3195 if (p == (const Quantum *) NULL)
3196 break;
3197 r=GetVirtualMetacontentFromNexus(cache_info,virtual_nexus);
3198 (void) memcpy(q,p,(size_t) (cache_info->number_channels*length*
3199 sizeof(*p)));
3200 q+=(ptrdiff_t) cache_info->number_channels*length;
3201 if ((r != (void *) NULL) && (s != (const void *) NULL))
3202 {
3203 (void) memcpy(s,r,(size_t) length);
3204 s+=(ptrdiff_t) length*cache_info->metacontent_extent;
3205 }
3206 }
3207 if (u < (ssize_t) columns)
3208 break;
3209 }
3210 /*
3211 Free resources.
3212 */
3213 if (virtual_metacontent != (void *) NULL)
3214 virtual_metacontent=(void *) RelinquishMagickMemory(virtual_metacontent);
3215 if (v < (ssize_t) rows)
3216 return((const Quantum *) NULL);
3217 return(pixels);
3218}
3219␌
3220/*
3221%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3222% %
3223% %
3224% %
3225+ G e t V i r t u a l P i x e l C a c h e %
3226% %
3227% %
3228% %
3229%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3230%
3231% GetVirtualPixelCache() get virtual pixels from the in-memory or disk pixel
3232% cache as defined by the geometry parameters. A pointer to the pixels
3233% is returned if the pixels are transferred, otherwise a NULL is returned.
3234%
3235% The format of the GetVirtualPixelCache() method is:
3236%
3237% const Quantum *GetVirtualPixelCache(const Image *image,
3238% const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
3239% const ssize_t y,const size_t columns,const size_t rows,
3240% ExceptionInfo *exception)
3241%
3242% A description of each parameter follows:
3243%
3244% o image: the image.
3245%
3246% o virtual_pixel_method: the virtual pixel method.
3247%
3248% o x,y,columns,rows: These values define the perimeter of a region of
3249% pixels.
3250%
3251% o exception: return any errors or warnings in this structure.
3252%
3253*/
3254static const Quantum *GetVirtualPixelCache(const Image *image,
3255 const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
3256 const size_t columns,const size_t rows,ExceptionInfo *exception)
3257{
3258 CacheInfo
3259 *magick_restrict cache_info;
3260
3261 const int
3262 id = GetOpenMPThreadId();
3263
3264 const Quantum
3265 *magick_restrict p;
3266
3267 assert(image != (const Image *) NULL);
3268 assert(image->signature == MagickCoreSignature);
3269 assert(image->cache != (Cache) NULL);
3270 cache_info=(CacheInfo *) image->cache;
3271 assert(cache_info->signature == MagickCoreSignature);
3272 assert(id < (int) cache_info->number_threads);
3273 p=GetVirtualPixelCacheNexus(image,virtual_pixel_method,x,y,columns,rows,
3274 cache_info->nexus_info[id],exception);
3275 return(p);
3276}
3277␌
3278/*
3279%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3280% %
3281% %
3282% %
3283% G e t V i r t u a l P i x e l Q u e u e %
3284% %
3285% %
3286% %
3287%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3288%
3289% GetVirtualPixelQueue() returns the virtual pixels associated corresponding
3290% with the last call to QueueAuthenticPixels() or GetVirtualPixels().
3291%
3292% The format of the GetVirtualPixelQueue() method is:
3293%
3294% const Quantum *GetVirtualPixelQueue(const Image image)
3295%
3296% A description of each parameter follows:
3297%
3298% o image: the image.
3299%
3300*/
3301MagickExport const Quantum *GetVirtualPixelQueue(const Image *image)
3302{
3303 CacheInfo
3304 *magick_restrict cache_info;
3305
3306 const int
3307 id = GetOpenMPThreadId();
3308
3309 assert(image != (const Image *) NULL);
3310 assert(image->signature == MagickCoreSignature);
3311 assert(image->cache != (Cache) NULL);
3312 cache_info=(CacheInfo *) image->cache;
3313 assert(cache_info->signature == MagickCoreSignature);
3314 if (cache_info->methods.get_virtual_pixels_handler != (GetVirtualPixelsHandler) NULL)
3315 return(cache_info->methods.get_virtual_pixels_handler(image));
3316 assert(id < (int) cache_info->number_threads);
3317 return(GetVirtualPixelsNexus(cache_info,cache_info->nexus_info[id]));
3318}
3319␌
3320/*
3321%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3322% %
3323% %
3324% %
3325% G e t V i r t u a l P i x e l s %
3326% %
3327% %
3328% %
3329%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3330%
3331% GetVirtualPixels() returns an immutable pixel region. If the
3332% region is successfully accessed, a pointer to it is returned, otherwise
3333% NULL is returned. The returned pointer may point to a temporary working
3334% copy of the pixels or it may point to the original pixels in memory.
3335% Performance is maximized if the selected region is part of one row, or one
3336% or more full rows, since there is opportunity to access the pixels in-place
3337% (without a copy) if the image is in memory, or in a memory-mapped file. The
3338% returned pointer must *never* be deallocated by the user.
3339%
3340% Pixels accessed via the returned pointer represent a simple array of type
3341% Quantum. If the image type is CMYK or the storage class is PseudoClass,
3342% call GetAuthenticMetacontent() after invoking GetAuthenticPixels() to
3343% access the meta-content (of type void) corresponding to the
3344% region.
3345%
3346% If you plan to modify the pixels, use GetAuthenticPixels() instead.
3347%
3348% Note, the GetVirtualPixels() and GetAuthenticPixels() methods are not thread-
3349% safe. In a threaded environment, use GetCacheViewVirtualPixels() or
3350% GetCacheViewAuthenticPixels() instead.
3351%
3352% The format of the GetVirtualPixels() method is:
3353%
3354% const Quantum *GetVirtualPixels(const Image *image,const ssize_t x,
3355% const ssize_t y,const size_t columns,const size_t rows,
3356% ExceptionInfo *exception)
3357%
3358% A description of each parameter follows:
3359%
3360% o image: the image.
3361%
3362% o x,y,columns,rows: These values define the perimeter of a region of
3363% pixels.
3364%
3365% o exception: return any errors or warnings in this structure.
3366%
3367*/
3368MagickExport const Quantum *GetVirtualPixels(const Image *image,
3369 const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,
3370 ExceptionInfo *exception)
3371{
3372 CacheInfo
3373 *magick_restrict cache_info;
3374
3375 const int
3376 id = GetOpenMPThreadId();
3377
3378 const Quantum
3379 *magick_restrict p;
3380
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_pixel_handler !=
3387 (GetVirtualPixelHandler) NULL)
3388 return(cache_info->methods.get_virtual_pixel_handler(image,
3389 GetPixelCacheVirtualMethod(image),x,y,columns,rows,exception));
3390 assert(id < (int) cache_info->number_threads);
3391 p=GetVirtualPixelCacheNexus(image,GetPixelCacheVirtualMethod(image),x,y,
3392 columns,rows,cache_info->nexus_info[id],exception);
3393 return(p);
3394}
3395␌
3396/*
3397%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3398% %
3399% %
3400% %
3401+ G e t V i r t u a l P i x e l s F r o m C a c h e %
3402% %
3403% %
3404% %
3405%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3406%
3407% GetVirtualPixelsCache() returns the pixels associated corresponding with the
3408% last call to QueueAuthenticPixelsCache() or GetVirtualPixelCache().
3409%
3410% The format of the GetVirtualPixelsCache() method is:
3411%
3412% Quantum *GetVirtualPixelsCache(const Image *image)
3413%
3414% A description of each parameter follows:
3415%
3416% o image: the image.
3417%
3418*/
3419static const Quantum *GetVirtualPixelsCache(const Image *image)
3420{
3421 CacheInfo
3422 *magick_restrict cache_info;
3423
3424 const int
3425 id = GetOpenMPThreadId();
3426
3427 assert(image != (const Image *) NULL);
3428 assert(image->signature == MagickCoreSignature);
3429 assert(image->cache != (Cache) NULL);
3430 cache_info=(CacheInfo *) image->cache;
3431 assert(cache_info->signature == MagickCoreSignature);
3432 assert(id < (int) cache_info->number_threads);
3433 return(GetVirtualPixelsNexus(image->cache,cache_info->nexus_info[id]));
3434}
3435␌
3436/*
3437%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3438% %
3439% %
3440% %
3441+ G e t V i r t u a l P i x e l s N e x u s %
3442% %
3443% %
3444% %
3445%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3446%
3447% GetVirtualPixelsNexus() returns the pixels associated with the specified
3448% cache nexus.
3449%
3450% The format of the GetVirtualPixelsNexus() method is:
3451%
3452% const Quantum *GetVirtualPixelsNexus(const Cache cache,
3453% NexusInfo *nexus_info)
3454%
3455% A description of each parameter follows:
3456%
3457% o cache: the pixel cache.
3458%
3459% o nexus_info: the cache nexus to return the colormap pixels.
3460%
3461*/
3462MagickPrivate const Quantum *GetVirtualPixelsNexus(const Cache cache,
3463 NexusInfo *magick_restrict nexus_info)
3464{
3465 CacheInfo
3466 *magick_restrict cache_info;
3467
3468 assert(cache != (Cache) NULL);
3469 cache_info=(CacheInfo *) cache;
3470 assert(cache_info->signature == MagickCoreSignature);
3471 if (cache_info->storage_class == UndefinedClass)
3472 return((Quantum *) NULL);
3473 return((const Quantum *) nexus_info->pixels);
3474}
3475␌
3476/*
3477%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3478% %
3479% %
3480% %
3481+ M a s k P i x e l C a c h e N e x u s %
3482% %
3483% %
3484% %
3485%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3486%
3487% MaskPixelCacheNexus() masks the cache nexus as defined by the composite mask.
3488% The method returns MagickTrue if the pixel region is masked, otherwise
3489% MagickFalse.
3490%
3491% The format of the MaskPixelCacheNexus() method is:
3492%
3493% MagickBooleanType MaskPixelCacheNexus(Image *image,
3494% NexusInfo *nexus_info,ExceptionInfo *exception)
3495%
3496% A description of each parameter follows:
3497%
3498% o image: the image.
3499%
3500% o nexus_info: the cache nexus to clip.
3501%
3502% o exception: return any errors or warnings in this structure.
3503%
3504*/
3505
3506static inline Quantum ApplyPixelCompositeMask(const Quantum p,
3507 const MagickRealType alpha,const Quantum q,const MagickRealType beta)
3508{
3509 double
3510 gamma;
3511
3512 if (fabs((double) (alpha-(double) TransparentAlpha)) < MagickEpsilon)
3513 return(q);
3514 gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
3515 gamma=MagickSafeReciprocal(gamma);
3516 return(ClampToQuantum(gamma*MagickOver_((double) p,alpha,(double) q,beta)));
3517}
3518
3519static MagickBooleanType MaskPixelCacheNexus(Image *image,NexusInfo *nexus_info,
3520 ExceptionInfo *exception)
3521{
3522 CacheInfo
3523 *magick_restrict cache_info;
3524
3525 Quantum
3526 *magick_restrict p,
3527 *magick_restrict q;
3528
3529 ssize_t
3530 y;
3531
3532 /*
3533 Apply composite mask.
3534 */
3535 if (IsEventLogging() != MagickFalse)
3536 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3537 if ((image->channels & CompositeMaskChannel) == 0)
3538 return(MagickTrue);
3539 if ((nexus_info->region.width == 0) || (nexus_info->region.height == 0))
3540 return(MagickTrue);
3541 cache_info=(CacheInfo *) image->cache;
3542 if (cache_info == (Cache) NULL)
3543 return(MagickFalse);
3544 p=GetAuthenticPixelCacheNexus(image,nexus_info->region.x,nexus_info->region.y,
3545 nexus_info->region.width,nexus_info->region.height,
3546 nexus_info->virtual_nexus,exception);
3547 q=nexus_info->pixels;
3548 if ((p == (Quantum *) NULL) || (q == (Quantum *) NULL))
3549 return(MagickFalse);
3550 for (y=0; y < (ssize_t) nexus_info->region.height; y++)
3551 {
3552 ssize_t
3553 x;
3554
3555 for (x=0; x < (ssize_t) nexus_info->region.width; x++)
3556 {
3557 double
3558 alpha;
3559
3560 ssize_t
3561 i;
3562
3563 alpha=(double) GetPixelCompositeMask(image,p);
3564 for (i=0; i < (ssize_t) image->number_channels; i++)
3565 {
3566 PixelChannel channel = GetPixelChannelChannel(image,i);
3567 PixelTrait traits = GetPixelChannelTraits(image,channel);
3568 if ((traits & UpdatePixelTrait) == 0)
3569 continue;
3570 q[i]=ApplyPixelCompositeMask(q[i],alpha,p[i],GetPixelAlpha(image,p));
3571 }
3572 p+=(ptrdiff_t) GetPixelChannels(image);
3573 q+=(ptrdiff_t) GetPixelChannels(image);
3574 }
3575 }
3576 return(MagickTrue);
3577}
3578␌
3579/*
3580%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3581% %
3582% %
3583% %
3584+ O p e n P i x e l C a c h e %
3585% %
3586% %
3587% %
3588%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3589%
3590% OpenPixelCache() allocates the pixel cache. This includes defining the cache
3591% dimensions, allocating space for the image pixels and optionally the
3592% metacontent, and memory mapping the cache if it is disk based. The cache
3593% nexus array is initialized as well.
3594%
3595% The format of the OpenPixelCache() method is:
3596%
3597% MagickBooleanType OpenPixelCache(Image *image,const MapMode mode,
3598% ExceptionInfo *exception)
3599%
3600% A description of each parameter follows:
3601%
3602% o image: the image.
3603%
3604% o mode: ReadMode, WriteMode, or IOMode.
3605%
3606% o exception: return any errors or warnings in this structure.
3607%
3608*/
3609
3610static inline MagickBooleanType CacheOverflowSanityCheckGetSize(
3611 const MagickSizeType count,const size_t quantum,MagickSizeType *const extent)
3612{
3613 MagickSizeType
3614 length;
3615
3616 if ((count == 0) || (quantum == 0))
3617 return(MagickTrue);
3618 length=count*quantum;
3619 if (quantum != (length/count))
3620 {
3621 errno=ENOMEM;
3622 return(MagickTrue);
3623 }
3624 if (extent != NULL)
3625 *extent=length;
3626 return(MagickFalse);
3627}
3628
3629static MagickBooleanType OpenPixelCacheOnDisk(CacheInfo *cache_info,
3630 const MapMode mode)
3631{
3632 int
3633 file;
3634
3635 /*
3636 Open pixel cache on disk.
3637 */
3638 if ((cache_info->file != -1) && (cache_info->disk_mode == mode))
3639 return(MagickTrue); /* cache already open and in the proper mode */
3640 if (*cache_info->cache_filename == '\0')
3641 file=AcquireUniqueFileResource(cache_info->cache_filename);
3642 else
3643 switch (mode)
3644 {
3645 case ReadMode:
3646 {
3647 file=open_utf8(cache_info->cache_filename,O_RDONLY | O_BINARY,0);
3648 break;
3649 }
3650 case WriteMode:
3651 {
3652 file=open_utf8(cache_info->cache_filename,O_WRONLY | O_CREAT |
3653 O_BINARY | O_EXCL,S_MODE);
3654 if (file == -1)
3655 file=open_utf8(cache_info->cache_filename,O_WRONLY | O_BINARY,S_MODE);
3656 break;
3657 }
3658 case IOMode:
3659 default:
3660 {
3661 file=open_utf8(cache_info->cache_filename,O_RDWR | O_CREAT | O_BINARY |
3662 O_EXCL,S_MODE);
3663 if (file == -1)
3664 file=open_utf8(cache_info->cache_filename,O_RDWR | O_BINARY,S_MODE);
3665 break;
3666 }
3667 }
3668 if (file == -1)
3669 return(MagickFalse);
3670 (void) AcquireMagickResource(FileResource,1);
3671 if (cache_info->file != -1)
3672 (void) ClosePixelCacheOnDisk(cache_info);
3673 cache_info->file=file;
3674 cache_info->disk_mode=mode;
3675 return(MagickTrue);
3676}
3677
3678static inline MagickOffsetType WritePixelCacheRegion(
3679 const CacheInfo *magick_restrict cache_info,const MagickOffsetType offset,
3680 const MagickSizeType length,const unsigned char *magick_restrict buffer)
3681{
3682 MagickOffsetType
3683 i;
3684
3685 ssize_t
3686 count = 0;
3687
3688#if !defined(MAGICKCORE_HAVE_PWRITE)
3689 if (lseek(cache_info->file,offset,SEEK_SET) < 0)
3690 return((MagickOffsetType) -1);
3691#endif
3692 for (i=0; i < (MagickOffsetType) length; i+=count)
3693 {
3694#if !defined(MAGICKCORE_HAVE_PWRITE)
3695 count=write(cache_info->file,buffer+i,(size_t) MagickMin(length-
3696 (MagickSizeType) i,MagickMaxBufferExtent));
3697#else
3698 count=pwrite(cache_info->file,buffer+i,(size_t) MagickMin(length-
3699 (MagickSizeType) i,MagickMaxBufferExtent),offset+i);
3700#endif
3701 if (count <= 0)
3702 {
3703 count=0;
3704 if (errno != EINTR)
3705 break;
3706 }
3707 }
3708 return(i);
3709}
3710
3711static MagickBooleanType SetPixelCacheExtent(Image *image,MagickSizeType length)
3712{
3713 CacheInfo
3714 *magick_restrict cache_info;
3715
3716 MagickOffsetType
3717 offset;
3718
3719 cache_info=(CacheInfo *) image->cache;
3720 if (cache_info->debug != MagickFalse)
3721 {
3722 char
3723 format[MagickPathExtent],
3724 message[MagickPathExtent];
3725
3726 (void) FormatMagickSize(length,MagickFalse,"B",MagickPathExtent,format);
3727 (void) FormatLocaleString(message,MagickPathExtent,
3728 "extend %s (%s[%d], disk, %s)",cache_info->filename,
3729 cache_info->cache_filename,cache_info->file,format);
3730 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);
3731 }
3732 if (length != (MagickSizeType) ((MagickOffsetType) length))
3733 return(MagickFalse);
3734 offset=(MagickOffsetType) lseek(cache_info->file,0,SEEK_END);
3735 if (offset < 0)
3736 return(MagickFalse);
3737 if ((MagickSizeType) offset < length)
3738 {
3739 MagickOffsetType
3740 count,
3741 extent;
3742
3743 extent=(MagickOffsetType) length-1;
3744 count=WritePixelCacheRegion(cache_info,extent,1,(const unsigned char *)
3745 "");
3746 if (count != 1)
3747 return(MagickFalse);
3748#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
3749 if (cache_info->synchronize != MagickFalse)
3750 if (posix_fallocate(cache_info->file,offset+1,extent-offset) != 0)
3751 return(MagickFalse);
3752#endif
3753 }
3754 offset=(MagickOffsetType) lseek(cache_info->file,0,SEEK_SET);
3755 if (offset < 0)
3756 return(MagickFalse);
3757 return(MagickTrue);
3758}
3759
3760static MagickBooleanType OpenPixelCache(Image *image,const MapMode mode,
3761 ExceptionInfo *exception)
3762{
3763 CacheInfo
3764 *magick_restrict cache_info,
3765 source_info;
3766
3767 char
3768 format[MagickPathExtent],
3769 message[MagickPathExtent];
3770
3771 const char
3772 *hosts,
3773 *type;
3774
3775 MagickBooleanType
3776 status;
3777
3778 MagickSizeType
3779 length = 0,
3780 number_pixels;
3781
3782 size_t
3783 columns,
3784 packet_size;
3785
3786 assert(image != (const Image *) NULL);
3787 assert(image->signature == MagickCoreSignature);
3788 assert(image->cache != (Cache) NULL);
3789 if (IsEventLogging() != MagickFalse)
3790 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3791 if (cache_anonymous_memory < 0)
3792 {
3793 char
3794 *value;
3795
3796 /*
3797 Does the security policy require anonymous mapping for pixel cache?
3798 */
3799 cache_anonymous_memory=0;
3800 value=GetPolicyValue("pixel-cache-memory");
3801 if (value == (char *) NULL)
3802 value=GetPolicyValue("cache:memory-map");
3803 if (LocaleCompare(value,"anonymous") == 0)
3804 {
3805#if defined(MAGICKCORE_HAVE_MMAP) && defined(MAP_ANONYMOUS)
3806 cache_anonymous_memory=1;
3807#else
3808 (void) ThrowMagickException(exception,GetMagickModule(),
3809 MissingDelegateError,"DelegateLibrarySupportNotBuiltIn",
3810 "`%s' (policy requires anonymous memory mapping)",image->filename);
3811#endif
3812 }
3813 value=DestroyString(value);
3814 }
3815 if ((image->columns == 0) || (image->rows == 0))
3816 ThrowBinaryException(CacheError,"NoPixelsDefinedInCache",image->filename);
3817 cache_info=(CacheInfo *) image->cache;
3818 assert(cache_info->signature == MagickCoreSignature);
3819 if (((MagickSizeType) image->columns > cache_info->width_limit) ||
3820 ((MagickSizeType) image->rows > cache_info->height_limit))
3821 {
3822 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
3823 "WidthOrHeightExceedsLimit","`%s' (%.20gx%.20g) > (%.20gx%.20g)",
3824 image->filename, (double) image->columns, (double) image->rows,
3825 (double) cache_info->width_limit,(double) cache_info->height_limit);
3826 return(MagickFalse);
3827 }
3828 if (GetMagickResourceLimit(ListLengthResource) != MagickResourceInfinity)
3829 {
3830 length=GetImageListLength(image);
3831 if (AcquireMagickResource(ListLengthResource,length) == MagickFalse)
3832 ThrowBinaryException(ResourceLimitError,"ListLengthExceedsLimit",
3833 image->filename);
3834 }
3835 source_info=(*cache_info);
3836 source_info.file=(-1);
3837 (void) FormatLocaleString(cache_info->filename,MagickPathExtent,"%s[%.20g]",
3838 image->filename,(double) image->scene);
3839 cache_info->storage_class=image->storage_class;
3840 cache_info->colorspace=image->colorspace;
3841 cache_info->alpha_trait=image->alpha_trait;
3842 cache_info->channels=image->channels;
3843 cache_info->rows=image->rows;
3844 cache_info->columns=image->columns;
3845 status=ResetPixelChannelMap(image,exception);
3846 if (status == MagickFalse)
3847 return(MagickFalse);
3848 cache_info->number_channels=GetPixelChannels(image);
3849 (void) memcpy(cache_info->channel_map,image->channel_map,MaxPixelChannels*
3850 sizeof(*image->channel_map));
3851 cache_info->metacontent_extent=image->metacontent_extent;
3852 cache_info->mode=mode;
3853 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
3854 packet_size=MagickMax(cache_info->number_channels,1)*sizeof(Quantum);
3855 if (image->metacontent_extent != 0)
3856 packet_size+=cache_info->metacontent_extent;
3857 if (CacheOverflowSanityCheckGetSize(number_pixels,packet_size,&length) != MagickFalse)
3858 {
3859 cache_info->storage_class=UndefinedClass;
3860 cache_info->length=0;
3861 ThrowBinaryException(ResourceLimitError,"PixelCacheAllocationFailed",
3862 image->filename);
3863 }
3864 columns=(size_t) (length/cache_info->rows/packet_size);
3865 if ((cache_info->columns != columns) || ((ssize_t) cache_info->columns < 0) ||
3866 ((ssize_t) cache_info->rows < 0))
3867 {
3868 cache_info->storage_class=UndefinedClass;
3869 cache_info->length=0;
3870 ThrowBinaryException(ResourceLimitError,"PixelCacheAllocationFailed",
3871 image->filename);
3872 }
3873 cache_info->length=length;
3874 if (image->ping != MagickFalse)
3875 {
3876 cache_info->type=PingCache;
3877 return(MagickTrue);
3878 }
3879 status=AcquireMagickResource(AreaResource,(MagickSizeType)
3880 cache_info->columns*cache_info->rows);
3881 if (cache_info->mode == PersistMode)
3882 status=MagickFalse;
3883 length=number_pixels*(cache_info->number_channels*sizeof(Quantum)+
3884 cache_info->metacontent_extent);
3885 if ((status != MagickFalse) &&
3886 (length == (MagickSizeType) ((size_t) length)) &&
3887 ((cache_info->type == UndefinedCache) ||
3888 (cache_info->type == MemoryCache)))
3889 {
3890 status=AcquireMagickResource(MemoryResource,cache_info->length);
3891 if (status != MagickFalse)
3892 {
3893 status=MagickTrue;
3894 if (cache_anonymous_memory <= 0)
3895 {
3896 cache_info->mapped=MagickFalse;
3897 cache_info->pixels=(Quantum *) MagickAssumeAligned(
3898 AcquireAlignedMemory(1,(size_t) cache_info->length));
3899 }
3900 else
3901 {
3902 cache_info->mapped=MagickTrue;
3903 cache_info->pixels=(Quantum *) MapBlob(-1,IOMode,0,(size_t)
3904 cache_info->length);
3905 }
3906 if (cache_info->pixels == (Quantum *) NULL)
3907 {
3908 cache_info->mapped=source_info.mapped;
3909 cache_info->pixels=source_info.pixels;
3910 }
3911 else
3912 {
3913 /*
3914 Create memory pixel cache.
3915 */
3916 cache_info->type=MemoryCache;
3917 cache_info->metacontent=(void *) NULL;
3918 if (cache_info->metacontent_extent != 0)
3919 cache_info->metacontent=(void *) (cache_info->pixels+
3920 cache_info->number_channels*number_pixels);
3921 if ((source_info.storage_class != UndefinedClass) &&
3922 (mode != ReadMode))
3923 {
3924 status=ClonePixelCacheRepository(cache_info,&source_info,
3925 exception);
3926 RelinquishPixelCachePixels(&source_info);
3927 }
3928 if (cache_info->debug != MagickFalse)
3929 {
3930 (void) FormatMagickSize(cache_info->length,MagickTrue,"B",
3931 MagickPathExtent,format);
3932 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
3933 cache_info->type);
3934 (void) FormatLocaleString(message,MagickPathExtent,
3935 "open %s (%s %s, %.20gx%.20gx%.20g %s)",
3936 cache_info->filename,cache_info->mapped != MagickFalse ?
3937 "Anonymous" : "Heap",type,(double) cache_info->columns,
3938 (double) cache_info->rows,(double)
3939 cache_info->number_channels,format);
3940 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
3941 message);
3942 }
3943 cache_info->storage_class=image->storage_class;
3944 if (status == 0)
3945 {
3946 if ((source_info.storage_class != UndefinedClass) &&
3947 (mode != ReadMode))
3948 RelinquishPixelCachePixels(&source_info);
3949 cache_info->type=UndefinedCache;
3950 return(MagickFalse);
3951 }
3952 return(MagickTrue);
3953 }
3954 }
3955 }
3956 status=AcquireMagickResource(DiskResource,cache_info->length);
3957 hosts=(const char *) GetImageRegistry(StringRegistryType,"cache:hosts",
3958 exception);
3959 if ((status == MagickFalse) && (hosts != (const char *) NULL))
3960 {
3961 DistributeCacheInfo
3962 *server_info;
3963
3964 /*
3965 Distribute the pixel cache to a remote server.
3966 */
3967 server_info=AcquireDistributeCacheInfo(exception);
3968 if (server_info != (DistributeCacheInfo *) NULL)
3969 {
3970 status=OpenDistributePixelCache(server_info,image);
3971 if (status == MagickFalse)
3972 {
3973 ThrowFileException(exception,CacheError,"UnableToOpenPixelCache",
3974 GetDistributeCacheHostname(server_info));
3975 server_info=DestroyDistributeCacheInfo(server_info);
3976 }
3977 else
3978 {
3979 /*
3980 Create a distributed pixel cache.
3981 */
3982 status=MagickTrue;
3983 cache_info->type=DistributedCache;
3984 cache_info->server_info=server_info;
3985 (void) FormatLocaleString(cache_info->cache_filename,
3986 MagickPathExtent,"%s:%d",GetDistributeCacheHostname(
3987 (DistributeCacheInfo *) cache_info->server_info),
3988 GetDistributeCachePort((DistributeCacheInfo *)
3989 cache_info->server_info));
3990 if ((source_info.storage_class != UndefinedClass) &&
3991 (mode != ReadMode))
3992 {
3993 status=ClonePixelCacheRepository(cache_info,&source_info,
3994 exception);
3995 RelinquishPixelCachePixels(&source_info);
3996 }
3997 if (cache_info->debug != MagickFalse)
3998 {
3999 (void) FormatMagickSize(cache_info->length,MagickFalse,"B",
4000 MagickPathExtent,format);
4001 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4002 cache_info->type);
4003 (void) FormatLocaleString(message,MagickPathExtent,
4004 "open %s (%s[%d], %s, %.20gx%.20gx%.20g %s)",
4005 cache_info->filename,cache_info->cache_filename,
4006 GetDistributeCacheFile((DistributeCacheInfo *)
4007 cache_info->server_info),type,(double) cache_info->columns,
4008 (double) cache_info->rows,(double)
4009 cache_info->number_channels,format);
4010 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
4011 message);
4012 }
4013 if (status == 0)
4014 {
4015 if ((source_info.storage_class != UndefinedClass) &&
4016 (mode != ReadMode))
4017 RelinquishPixelCachePixels(&source_info);
4018 cache_info->type=UndefinedCache;
4019 return(MagickFalse);
4020 }
4021 return(MagickTrue);
4022 }
4023 }
4024 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4025 RelinquishPixelCachePixels(&source_info);
4026 cache_info->type=UndefinedCache;
4027 (void) memset(image->channel_map,0,MaxPixelChannels*
4028 sizeof(*image->channel_map));
4029 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4030 "CacheResourcesExhausted","`%s'",image->filename);
4031 return(MagickFalse);
4032 }
4033 /*
4034 Create pixel cache on disk.
4035 */
4036 if (status == MagickFalse)
4037 {
4038 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4039 RelinquishPixelCachePixels(&source_info);
4040 cache_info->type=UndefinedCache;
4041 (void) memset(image->channel_map,0,MaxPixelChannels*
4042 sizeof(*image->channel_map));
4043 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4044 "CacheResourcesExhausted","`%s'",image->filename);
4045 return(MagickFalse);
4046 }
4047 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode) &&
4048 (cache_info->mode != PersistMode))
4049 {
4050 (void) ClosePixelCacheOnDisk(cache_info);
4051 *cache_info->cache_filename='\0';
4052 }
4053 if (OpenPixelCacheOnDisk(cache_info,mode) == MagickFalse)
4054 {
4055 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4056 RelinquishPixelCachePixels(&source_info);
4057 cache_info->type=UndefinedCache;
4058 ThrowFileException(exception,CacheError,"UnableToOpenPixelCache",
4059 image->filename);
4060 return(MagickFalse);
4061 }
4062 status=SetPixelCacheExtent(image,(MagickSizeType) cache_info->offset+
4063 cache_info->length);
4064 if (status == MagickFalse)
4065 {
4066 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4067 RelinquishPixelCachePixels(&source_info);
4068 cache_info->type=UndefinedCache;
4069 ThrowFileException(exception,CacheError,"UnableToExtendCache",
4070 image->filename);
4071 return(MagickFalse);
4072 }
4073 cache_info->type=DiskCache;
4074 length=number_pixels*(cache_info->number_channels*sizeof(Quantum)+
4075 cache_info->metacontent_extent);
4076 if (length == (MagickSizeType) ((size_t) length))
4077 {
4078 status=AcquireMagickResource(MapResource,cache_info->length);
4079 if (status != MagickFalse)
4080 {
4081 cache_info->pixels=(Quantum *) MapBlob(cache_info->file,mode,
4082 cache_info->offset,(size_t) cache_info->length);
4083 if (cache_info->pixels == (Quantum *) NULL)
4084 {
4085 cache_info->mapped=source_info.mapped;
4086 cache_info->pixels=source_info.pixels;
4087 RelinquishMagickResource(MapResource,cache_info->length);
4088 }
4089 else
4090 {
4091 /*
4092 Create file-backed memory-mapped pixel cache.
4093 */
4094 (void) ClosePixelCacheOnDisk(cache_info);
4095 cache_info->type=MapCache;
4096 cache_info->mapped=MagickTrue;
4097 cache_info->metacontent=(void *) NULL;
4098 if (cache_info->metacontent_extent != 0)
4099 cache_info->metacontent=(void *) (cache_info->pixels+
4100 cache_info->number_channels*number_pixels);
4101 if ((source_info.storage_class != UndefinedClass) &&
4102 (mode != ReadMode))
4103 {
4104 status=ClonePixelCacheRepository(cache_info,&source_info,
4105 exception);
4106 RelinquishPixelCachePixels(&source_info);
4107 }
4108 if (cache_info->debug != MagickFalse)
4109 {
4110 (void) FormatMagickSize(cache_info->length,MagickTrue,"B",
4111 MagickPathExtent,format);
4112 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4113 cache_info->type);
4114 (void) FormatLocaleString(message,MagickPathExtent,
4115 "open %s (%s[%d], %s, %.20gx%.20gx%.20g %s)",
4116 cache_info->filename,cache_info->cache_filename,
4117 cache_info->file,type,(double) cache_info->columns,
4118 (double) cache_info->rows,(double)
4119 cache_info->number_channels,format);
4120 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",
4121 message);
4122 }
4123 if (status == 0)
4124 {
4125 if ((source_info.storage_class != UndefinedClass) &&
4126 (mode != ReadMode))
4127 RelinquishPixelCachePixels(&source_info);
4128 cache_info->type=UndefinedCache;
4129 return(MagickFalse);
4130 }
4131 return(MagickTrue);
4132 }
4133 }
4134 }
4135 status=MagickTrue;
4136 if ((source_info.storage_class != UndefinedClass) && (mode != ReadMode))
4137 {
4138 status=ClonePixelCacheRepository(cache_info,&source_info,exception);
4139 RelinquishPixelCachePixels(&source_info);
4140 }
4141 if (cache_info->debug != MagickFalse)
4142 {
4143 (void) FormatMagickSize(cache_info->length,MagickFalse,"B",
4144 MagickPathExtent,format);
4145 type=CommandOptionToMnemonic(MagickCacheOptions,(ssize_t)
4146 cache_info->type);
4147 (void) FormatLocaleString(message,MagickPathExtent,
4148 "open %s (%s[%d], %s, %.20gx%.20gx%.20g %s)",cache_info->filename,
4149 cache_info->cache_filename,cache_info->file,type,(double)
4150 cache_info->columns,(double) cache_info->rows,(double)
4151 cache_info->number_channels,format);
4152 (void) LogMagickEvent(CacheEvent,GetMagickModule(),"%s",message);
4153 }
4154 if (status == 0)
4155 {
4156 cache_info->type=UndefinedCache;
4157 return(MagickFalse);
4158 }
4159 return(MagickTrue);
4160}
4161␌
4162/*
4163%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4164% %
4165% %
4166% %
4167+ P e r s i s t P i x e l C a c h e %
4168% %
4169% %
4170% %
4171%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4172%
4173% PersistPixelCache() attaches to or initializes a persistent pixel cache. A
4174% persistent pixel cache is one that resides on disk and is not destroyed
4175% when the program exits.
4176%
4177% The format of the PersistPixelCache() method is:
4178%
4179% MagickBooleanType PersistPixelCache(Image *image,const char *filename,
4180% const MagickBooleanType attach,MagickOffsetType *offset,
4181% ExceptionInfo *exception)
4182%
4183% A description of each parameter follows:
4184%
4185% o image: the image.
4186%
4187% o filename: the persistent pixel cache filename.
4188%
4189% o attach: A value other than zero initializes the persistent pixel cache.
4190%
4191% o initialize: A value other than zero initializes the persistent pixel
4192% cache.
4193%
4194% o offset: the offset in the persistent cache to store pixels.
4195%
4196% o exception: return any errors or warnings in this structure.
4197%
4198*/
4199MagickExport MagickBooleanType PersistPixelCache(Image *image,
4200 const char *filename,const MagickBooleanType attach,MagickOffsetType *offset,
4201 ExceptionInfo *exception)
4202{
4203 CacheInfo
4204 *magick_restrict cache_info,
4205 *magick_restrict clone_info;
4206
4207 MagickBooleanType
4208 status;
4209
4210 ssize_t
4211 page_size;
4212
4213 assert(image != (Image *) NULL);
4214 assert(image->signature == MagickCoreSignature);
4215 if (IsEventLogging() != MagickFalse)
4216 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4217 assert(image->cache != (void *) NULL);
4218 assert(filename != (const char *) NULL);
4219 assert(offset != (MagickOffsetType *) NULL);
4220 page_size=GetMagickPageSize();
4221 cache_info=(CacheInfo *) image->cache;
4222 assert(cache_info->signature == MagickCoreSignature);
4223#if defined(MAGICKCORE_OPENCL_SUPPORT)
4224 CopyOpenCLBuffer(cache_info);
4225#endif
4226 if (attach != MagickFalse)
4227 {
4228 /*
4229 Attach existing persistent pixel cache.
4230 */
4231 if (cache_info->debug != MagickFalse)
4232 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
4233 "attach persistent cache");
4234 (void) CopyMagickString(cache_info->cache_filename,filename,
4235 MagickPathExtent);
4236 cache_info->type=MapCache;
4237 cache_info->offset=(*offset);
4238 if (OpenPixelCache(image,ReadMode,exception) == MagickFalse)
4239 return(MagickFalse);
4240 *offset=(*offset+(MagickOffsetType) cache_info->length+page_size-
4241 ((MagickOffsetType) cache_info->length % page_size));
4242 return(MagickTrue);
4243 }
4244 /*
4245 Clone persistent pixel cache.
4246 */
4247 status=AcquireMagickResource(DiskResource,cache_info->length);
4248 if (status == MagickFalse)
4249 {
4250 cache_info->type=UndefinedCache;
4251 (void) memset(image->channel_map,0,MaxPixelChannels*
4252 sizeof(*image->channel_map));
4253 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4254 "CacheResourcesExhausted","`%s'",image->filename);
4255 return(MagickFalse);
4256 }
4257 clone_info=(CacheInfo *) ClonePixelCache(cache_info);
4258 clone_info->type=DiskCache;
4259 (void) CopyMagickString(clone_info->cache_filename,filename,MagickPathExtent);
4260 clone_info->file=(-1);
4261 clone_info->storage_class=cache_info->storage_class;
4262 clone_info->colorspace=cache_info->colorspace;
4263 clone_info->alpha_trait=cache_info->alpha_trait;
4264 clone_info->channels=cache_info->channels;
4265 clone_info->columns=cache_info->columns;
4266 clone_info->rows=cache_info->rows;
4267 clone_info->number_channels=cache_info->number_channels;
4268 clone_info->metacontent_extent=cache_info->metacontent_extent;
4269 clone_info->mode=PersistMode;
4270 clone_info->length=cache_info->length;
4271 (void) memcpy(clone_info->channel_map,cache_info->channel_map,
4272 MaxPixelChannels*sizeof(*cache_info->channel_map));
4273 clone_info->offset=(*offset);
4274 status=OpenPixelCacheOnDisk(clone_info,WriteMode);
4275 if (status != MagickFalse)
4276 status=ClonePixelCacheRepository(clone_info,cache_info,exception);
4277 *offset=(*offset+(MagickOffsetType) cache_info->length+page_size-
4278 ((MagickOffsetType) cache_info->length % page_size));
4279 clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
4280 return(status);
4281}
4282␌
4283/*
4284%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4285% %
4286% %
4287% %
4288+ Q u e u e A u t h e n t i c P i x e l C a c h e N e x u s %
4289% %
4290% %
4291% %
4292%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4293%
4294% QueueAuthenticPixelCacheNexus() allocates an region to store image pixels as
4295% defined by the region rectangle and returns a pointer to the region. This
4296% region is subsequently transferred from the pixel cache with
4297% SyncAuthenticPixelsCache(). A pointer to the pixels is returned if the
4298% pixels are transferred, otherwise a NULL is returned.
4299%
4300% The format of the QueueAuthenticPixelCacheNexus() method is:
4301%
4302% Quantum *QueueAuthenticPixelCacheNexus(Image *image,const ssize_t x,
4303% const ssize_t y,const size_t columns,const size_t rows,
4304% const MagickBooleanType clone,NexusInfo *nexus_info,
4305% ExceptionInfo *exception)
4306%
4307% A description of each parameter follows:
4308%
4309% o image: the image.
4310%
4311% o x,y,columns,rows: These values define the perimeter of a region of
4312% pixels.
4313%
4314% o nexus_info: the cache nexus to set.
4315%
4316% o clone: clone the pixel cache.
4317%
4318% o exception: return any errors or warnings in this structure.
4319%
4320*/
4321MagickPrivate Quantum *QueueAuthenticPixelCacheNexus(Image *image,
4322 const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,
4323 const MagickBooleanType clone,NexusInfo *nexus_info,ExceptionInfo *exception)
4324{
4325 CacheInfo
4326 *magick_restrict cache_info;
4327
4328 MagickOffsetType
4329 offset;
4330
4331 MagickSizeType
4332 number_pixels;
4333
4334 Quantum
4335 *magick_restrict pixels;
4336
4337 /*
4338 Validate pixel cache geometry.
4339 */
4340 assert(image != (const Image *) NULL);
4341 assert(image->signature == MagickCoreSignature);
4342 assert(image->cache != (Cache) NULL);
4343 cache_info=(CacheInfo *) GetImagePixelCache(image,clone,exception);
4344 if (cache_info == (Cache) NULL)
4345 return((Quantum *) NULL);
4346 assert(cache_info->signature == MagickCoreSignature);
4347 if ((cache_info->columns == 0) || (cache_info->rows == 0) || (x < 0) ||
4348 (y < 0) || (x >= (ssize_t) cache_info->columns) ||
4349 (y >= (ssize_t) cache_info->rows))
4350 {
4351 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
4352 "PixelsAreNotAuthentic","`%s'",image->filename);
4353 return((Quantum *) NULL);
4354 }
4355 if (IsValidPixelOffset(y,cache_info->columns) == MagickFalse)
4356 return((Quantum *) NULL);
4357 offset=y*(MagickOffsetType) cache_info->columns;
4358 if (IsOffsetOverflow(offset,(MagickOffsetType) x) == MagickFalse)
4359 return((Quantum *) NULL);
4360 offset+=x;
4361 if (offset < 0)
4362 return((Quantum *) NULL);
4363 number_pixels=(MagickSizeType) cache_info->columns*cache_info->rows;
4364 offset+=((MagickOffsetType) rows-1)*(MagickOffsetType) cache_info->columns;
4365 if (IsOffsetOverflow(offset,(MagickOffsetType) columns-1) == MagickFalse)
4366 return((Quantum *) NULL);
4367 offset+=(MagickOffsetType) columns-1;
4368 if ((MagickSizeType) offset >= number_pixels)
4369 return((Quantum *) NULL);
4370 /*
4371 Return pixel cache.
4372 */
4373 pixels=SetPixelCacheNexusPixels(cache_info,WriteMode,x,y,columns,rows,
4374 ((image->channels & WriteMaskChannel) != 0) ||
4375 ((image->channels & CompositeMaskChannel) != 0) ? MagickTrue : MagickFalse,
4376 nexus_info,exception);
4377 return(pixels);
4378}
4379␌
4380/*
4381%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4382% %
4383% %
4384% %
4385+ Q u e u e A u t h e n t i c P i x e l s C a c h e %
4386% %
4387% %
4388% %
4389%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4390%
4391% QueueAuthenticPixelsCache() allocates an region to store image pixels as
4392% defined by the region rectangle and returns a pointer to the region. This
4393% region is subsequently transferred from the pixel cache with
4394% SyncAuthenticPixelsCache(). A pointer to the pixels is returned if the
4395% pixels are transferred, otherwise a NULL is returned.
4396%
4397% The format of the QueueAuthenticPixelsCache() method is:
4398%
4399% Quantum *QueueAuthenticPixelsCache(Image *image,const ssize_t x,
4400% const ssize_t y,const size_t columns,const size_t rows,
4401% ExceptionInfo *exception)
4402%
4403% A description of each parameter follows:
4404%
4405% o image: the image.
4406%
4407% o x,y,columns,rows: These values define the perimeter of a region of
4408% pixels.
4409%
4410% o exception: return any errors or warnings in this structure.
4411%
4412*/
4413static Quantum *QueueAuthenticPixelsCache(Image *image,const ssize_t x,
4414 const ssize_t y,const size_t columns,const size_t rows,
4415 ExceptionInfo *exception)
4416{
4417 CacheInfo
4418 *magick_restrict cache_info;
4419
4420 const int
4421 id = GetOpenMPThreadId();
4422
4423 Quantum
4424 *magick_restrict pixels;
4425
4426 assert(image != (const Image *) NULL);
4427 assert(image->signature == MagickCoreSignature);
4428 assert(image->cache != (Cache) NULL);
4429 cache_info=(CacheInfo *) image->cache;
4430 assert(cache_info->signature == MagickCoreSignature);
4431 assert(id < (int) cache_info->number_threads);
4432 pixels=QueueAuthenticPixelCacheNexus(image,x,y,columns,rows,MagickFalse,
4433 cache_info->nexus_info[id],exception);
4434 return(pixels);
4435}
4436␌
4437/*
4438%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4439% %
4440% %
4441% %
4442% Q u e u e A u t h e n t i c P i x e l s %
4443% %
4444% %
4445% %
4446%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4447%
4448% QueueAuthenticPixels() queues a mutable pixel region. If the region is
4449% successfully initialized a pointer to a Quantum array representing the
4450% region is returned, otherwise NULL is returned. The returned pointer may
4451% point to a temporary working buffer for the pixels or it may point to the
4452% final location of the pixels in memory.
4453%
4454% Write-only access means that any existing pixel values corresponding to
4455% the region are ignored. This is useful if the initial image is being
4456% created from scratch, or if the existing pixel values are to be
4457% completely replaced without need to refer to their preexisting values.
4458% The application is free to read and write the pixel buffer returned by
4459% QueueAuthenticPixels() any way it pleases. QueueAuthenticPixels() does not
4460% initialize the pixel array values. Initializing pixel array values is the
4461% application's responsibility.
4462%
4463% Performance is maximized if the selected region is part of one row, or
4464% one or more full rows, since then there is opportunity to access the
4465% pixels in-place (without a copy) if the image is in memory, or in a
4466% memory-mapped file. The returned pointer must *never* be deallocated
4467% by the user.
4468%
4469% Pixels accessed via the returned pointer represent a simple array of type
4470% Quantum. If the image type is CMYK or the storage class is PseudoClass,
4471% call GetAuthenticMetacontent() after invoking GetAuthenticPixels() to
4472% obtain the meta-content (of type void) corresponding to the region.
4473% Once the Quantum (and/or Quantum) array has been updated, the
4474% changes must be saved back to the underlying image using
4475% SyncAuthenticPixels() or they may be lost.
4476%
4477% The format of the QueueAuthenticPixels() method is:
4478%
4479% Quantum *QueueAuthenticPixels(Image *image,const ssize_t x,
4480% const ssize_t y,const size_t columns,const size_t rows,
4481% ExceptionInfo *exception)
4482%
4483% A description of each parameter follows:
4484%
4485% o image: the image.
4486%
4487% o x,y,columns,rows: These values define the perimeter of a region of
4488% pixels.
4489%
4490% o exception: return any errors or warnings in this structure.
4491%
4492*/
4493MagickExport Quantum *QueueAuthenticPixels(Image *image,const ssize_t x,
4494 const ssize_t y,const size_t columns,const size_t rows,
4495 ExceptionInfo *exception)
4496{
4497 CacheInfo
4498 *magick_restrict cache_info;
4499
4500 const int
4501 id = GetOpenMPThreadId();
4502
4503 Quantum
4504 *magick_restrict pixels;
4505
4506 assert(image != (Image *) NULL);
4507 assert(image->signature == MagickCoreSignature);
4508 assert(image->cache != (Cache) NULL);
4509 cache_info=(CacheInfo *) image->cache;
4510 assert(cache_info->signature == MagickCoreSignature);
4511 if (cache_info->methods.queue_authentic_pixels_handler !=
4512 (QueueAuthenticPixelsHandler) NULL)
4513 {
4514 pixels=cache_info->methods.queue_authentic_pixels_handler(image,x,y,
4515 columns,rows,exception);
4516 return(pixels);
4517 }
4518 assert(id < (int) cache_info->number_threads);
4519 pixels=QueueAuthenticPixelCacheNexus(image,x,y,columns,rows,MagickFalse,
4520 cache_info->nexus_info[id],exception);
4521 return(pixels);
4522}
4523␌
4524/*
4525%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4526% %
4527% %
4528% %
4529+ R e a d P i x e l C a c h e M e t a c o n t e n t %
4530% %
4531% %
4532% %
4533%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4534%
4535% ReadPixelCacheMetacontent() reads metacontent from the specified region of
4536% the pixel cache.
4537%
4538% The format of the ReadPixelCacheMetacontent() method is:
4539%
4540% MagickBooleanType ReadPixelCacheMetacontent(CacheInfo *cache_info,
4541% NexusInfo *nexus_info,ExceptionInfo *exception)
4542%
4543% A description of each parameter follows:
4544%
4545% o cache_info: the pixel cache.
4546%
4547% o nexus_info: the cache nexus to read the metacontent.
4548%
4549% o exception: return any errors or warnings in this structure.
4550%
4551*/
4552
4553static inline MagickOffsetType ReadPixelCacheRegion(
4554 const CacheInfo *magick_restrict cache_info,const MagickOffsetType offset,
4555 const MagickSizeType length,unsigned char *magick_restrict buffer)
4556{
4557 MagickOffsetType
4558 i;
4559
4560 ssize_t
4561 count = 0;
4562
4563#if !defined(MAGICKCORE_HAVE_PREAD)
4564 if (lseek(cache_info->file,offset,SEEK_SET) < 0)
4565 return((MagickOffsetType) -1);
4566#endif
4567 for (i=0; i < (MagickOffsetType) length; i+=count)
4568 {
4569#if !defined(MAGICKCORE_HAVE_PREAD)
4570 count=read(cache_info->file,buffer+i,(size_t) MagickMin(length-
4571 (MagickSizeType) i,(size_t) MagickMaxBufferExtent));
4572#else
4573 count=pread(cache_info->file,buffer+i,(size_t) MagickMin(length-
4574 (MagickSizeType) i,(size_t) MagickMaxBufferExtent),offset+i);
4575#endif
4576 if (count <= 0)
4577 {
4578 count=0;
4579 if (errno != EINTR)
4580 break;
4581 }
4582 }
4583 return(i);
4584}
4585
4586static MagickBooleanType ReadPixelCacheMetacontent(
4587 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
4588 ExceptionInfo *exception)
4589{
4590 MagickOffsetType
4591 count,
4592 offset;
4593
4594 MagickSizeType
4595 extent,
4596 length;
4597
4598 ssize_t
4599 y;
4600
4601 unsigned char
4602 *magick_restrict q;
4603
4604 size_t
4605 rows;
4606
4607 if (cache_info->metacontent_extent == 0)
4608 return(MagickFalse);
4609 if (nexus_info->authentic_pixel_cache != MagickFalse)
4610 return(MagickTrue);
4611 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
4612 return(MagickFalse);
4613 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
4614 nexus_info->region.x;
4615 length=(MagickSizeType) nexus_info->region.width*
4616 cache_info->metacontent_extent;
4617 extent=length*nexus_info->region.height;
4618 rows=nexus_info->region.height;
4619 y=0;
4620 q=(unsigned char *) nexus_info->metacontent;
4621 switch (cache_info->type)
4622 {
4623 case MemoryCache:
4624 case MapCache:
4625 {
4626 unsigned char
4627 *magick_restrict p;
4628
4629 /*
4630 Read meta-content from memory.
4631 */
4632 if ((cache_info->columns == nexus_info->region.width) &&
4633 (extent == (MagickSizeType) ((size_t) extent)))
4634 {
4635 length=extent;
4636 rows=1UL;
4637 }
4638 p=(unsigned char *) cache_info->metacontent+offset*(MagickOffsetType)
4639 cache_info->metacontent_extent;
4640 for (y=0; y < (ssize_t) rows; y++)
4641 {
4642 (void) memcpy(q,p,(size_t) length);
4643 p+=(ptrdiff_t) cache_info->metacontent_extent*cache_info->columns;
4644 q+=(ptrdiff_t) cache_info->metacontent_extent*nexus_info->region.width;
4645 }
4646 break;
4647 }
4648 case DiskCache:
4649 {
4650 /*
4651 Read meta content from disk.
4652 */
4653 LockSemaphoreInfo(cache_info->file_semaphore);
4654 if (OpenPixelCacheOnDisk(cache_info,IOMode) == MagickFalse)
4655 {
4656 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
4657 cache_info->cache_filename);
4658 UnlockSemaphoreInfo(cache_info->file_semaphore);
4659 return(MagickFalse);
4660 }
4661 if ((cache_info->columns == nexus_info->region.width) &&
4662 (extent <= MagickMaxBufferExtent))
4663 {
4664 length=extent;
4665 rows=1UL;
4666 }
4667 extent=(MagickSizeType) cache_info->columns*cache_info->rows;
4668 for (y=0; y < (ssize_t) rows; y++)
4669 {
4670 count=ReadPixelCacheRegion(cache_info,cache_info->offset+
4671 (MagickOffsetType) extent*(MagickOffsetType)
4672 cache_info->number_channels*(MagickOffsetType) sizeof(Quantum)+offset*
4673 (MagickOffsetType) cache_info->metacontent_extent,length,
4674 (unsigned char *) q);
4675 if (count != (MagickOffsetType) length)
4676 break;
4677 offset+=(MagickOffsetType) cache_info->columns;
4678 q+=(ptrdiff_t) cache_info->metacontent_extent*nexus_info->region.width;
4679 }
4680 if (IsFileDescriptorLimitExceeded() != MagickFalse)
4681 (void) ClosePixelCacheOnDisk(cache_info);
4682 UnlockSemaphoreInfo(cache_info->file_semaphore);
4683 break;
4684 }
4685 case DistributedCache:
4686 {
4687 RectangleInfo
4688 region;
4689
4690 /*
4691 Read metacontent from distributed cache.
4692 */
4693 LockSemaphoreInfo(cache_info->file_semaphore);
4694 region=nexus_info->region;
4695 if ((cache_info->columns != nexus_info->region.width) ||
4696 (extent > MagickMaxBufferExtent))
4697 region.height=1UL;
4698 else
4699 {
4700 length=extent;
4701 rows=1UL;
4702 }
4703 for (y=0; y < (ssize_t) rows; y++)
4704 {
4705 count=ReadDistributePixelCacheMetacontent((DistributeCacheInfo *)
4706 cache_info->server_info,&region,length,(unsigned char *) q);
4707 if (count != (MagickOffsetType) length)
4708 break;
4709 q+=(ptrdiff_t) cache_info->metacontent_extent*nexus_info->region.width;
4710 region.y++;
4711 }
4712 UnlockSemaphoreInfo(cache_info->file_semaphore);
4713 break;
4714 }
4715 default:
4716 break;
4717 }
4718 if (y < (ssize_t) rows)
4719 {
4720 ThrowFileException(exception,CacheError,"UnableToReadPixelCache",
4721 cache_info->cache_filename);
4722 return(MagickFalse);
4723 }
4724 if ((cache_info->debug != MagickFalse) &&
4725 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
4726 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
4727 "%s[%.20gx%.20g%+.20g%+.20g]",cache_info->filename,(double)
4728 nexus_info->region.width,(double) nexus_info->region.height,(double)
4729 nexus_info->region.x,(double) nexus_info->region.y);
4730 return(MagickTrue);
4731}
4732␌
4733/*
4734%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4735% %
4736% %
4737% %
4738+ R e a d P i x e l C a c h e P i x e l s %
4739% %
4740% %
4741% %
4742%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4743%
4744% ReadPixelCachePixels() reads pixels from the specified region of the pixel
4745% cache.
4746%
4747% The format of the ReadPixelCachePixels() method is:
4748%
4749% MagickBooleanType ReadPixelCachePixels(CacheInfo *cache_info,
4750% NexusInfo *nexus_info,ExceptionInfo *exception)
4751%
4752% A description of each parameter follows:
4753%
4754% o cache_info: the pixel cache.
4755%
4756% o nexus_info: the cache nexus to read the pixels.
4757%
4758% o exception: return any errors or warnings in this structure.
4759%
4760*/
4761static MagickBooleanType ReadPixelCachePixels(
4762 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
4763 ExceptionInfo *exception)
4764{
4765 MagickOffsetType
4766 count,
4767 offset;
4768
4769 MagickSizeType
4770 extent,
4771 length;
4772
4773 Quantum
4774 *magick_restrict q;
4775
4776 size_t
4777 number_channels,
4778 rows;
4779
4780 ssize_t
4781 y;
4782
4783 if (nexus_info->authentic_pixel_cache != MagickFalse)
4784 return(MagickTrue);
4785 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
4786 return(MagickFalse);
4787 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns;
4788 if ((ssize_t) (offset/cache_info->columns) != nexus_info->region.y)
4789 return(MagickFalse);
4790 offset+=nexus_info->region.x;
4791 number_channels=cache_info->number_channels;
4792 length=(MagickSizeType) number_channels*nexus_info->region.width*
4793 sizeof(Quantum);
4794 if ((length/number_channels/sizeof(Quantum)) != nexus_info->region.width)
4795 return(MagickFalse);
4796 rows=nexus_info->region.height;
4797 extent=length*rows;
4798 if ((extent == 0) || ((extent/length) != rows))
4799 return(MagickFalse);
4800 y=0;
4801 q=nexus_info->pixels;
4802 switch (cache_info->type)
4803 {
4804 case MemoryCache:
4805 case MapCache:
4806 {
4807 Quantum
4808 *magick_restrict p;
4809
4810 /*
4811 Read pixels from memory.
4812 */
4813 if ((cache_info->columns == nexus_info->region.width) &&
4814 (extent == (MagickSizeType) ((size_t) extent)))
4815 {
4816 length=extent;
4817 rows=1UL;
4818 }
4819 p=cache_info->pixels+(MagickOffsetType) cache_info->number_channels*
4820 offset;
4821 for (y=0; y < (ssize_t) rows; y++)
4822 {
4823 (void) memcpy(q,p,(size_t) length);
4824 p+=(ptrdiff_t) cache_info->number_channels*cache_info->columns;
4825 q+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
4826 }
4827 break;
4828 }
4829 case DiskCache:
4830 {
4831 /*
4832 Read pixels from disk.
4833 */
4834 LockSemaphoreInfo(cache_info->file_semaphore);
4835 if (OpenPixelCacheOnDisk(cache_info,IOMode) == MagickFalse)
4836 {
4837 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
4838 cache_info->cache_filename);
4839 UnlockSemaphoreInfo(cache_info->file_semaphore);
4840 return(MagickFalse);
4841 }
4842 if ((cache_info->columns == nexus_info->region.width) &&
4843 (extent <= MagickMaxBufferExtent))
4844 {
4845 length=extent;
4846 rows=1UL;
4847 }
4848 for (y=0; y < (ssize_t) rows; y++)
4849 {
4850 count=ReadPixelCacheRegion(cache_info,cache_info->offset+offset*
4851 (MagickOffsetType) cache_info->number_channels*(MagickOffsetType)
4852 sizeof(*q),length,(unsigned char *) q);
4853 if (count != (MagickOffsetType) length)
4854 break;
4855 offset+=(MagickOffsetType) cache_info->columns;
4856 q+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
4857 }
4858 if (IsFileDescriptorLimitExceeded() != MagickFalse)
4859 (void) ClosePixelCacheOnDisk(cache_info);
4860 UnlockSemaphoreInfo(cache_info->file_semaphore);
4861 break;
4862 }
4863 case DistributedCache:
4864 {
4865 RectangleInfo
4866 region;
4867
4868 /*
4869 Read pixels from distributed cache.
4870 */
4871 LockSemaphoreInfo(cache_info->file_semaphore);
4872 region=nexus_info->region;
4873 if ((cache_info->columns != nexus_info->region.width) ||
4874 (extent > MagickMaxBufferExtent))
4875 region.height=1UL;
4876 else
4877 {
4878 length=extent;
4879 rows=1UL;
4880 }
4881 for (y=0; y < (ssize_t) rows; y++)
4882 {
4883 count=ReadDistributePixelCachePixels((DistributeCacheInfo *)
4884 cache_info->server_info,&region,length,(unsigned char *) q);
4885 if (count != (MagickOffsetType) length)
4886 break;
4887 q+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
4888 region.y++;
4889 }
4890 UnlockSemaphoreInfo(cache_info->file_semaphore);
4891 break;
4892 }
4893 default:
4894 break;
4895 }
4896 if (y < (ssize_t) rows)
4897 {
4898 ThrowFileException(exception,CacheError,"UnableToReadPixelCache",
4899 cache_info->cache_filename);
4900 return(MagickFalse);
4901 }
4902 if ((cache_info->debug != MagickFalse) &&
4903 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
4904 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
4905 "%s[%.20gx%.20g%+.20g%+.20g]",cache_info->filename,(double)
4906 nexus_info->region.width,(double) nexus_info->region.height,(double)
4907 nexus_info->region.x,(double) nexus_info->region.y);
4908 return(MagickTrue);
4909}
4910␌
4911/*
4912%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4913% %
4914% %
4915% %
4916+ R e f e r e n c e P i x e l C a c h e %
4917% %
4918% %
4919% %
4920%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4921%
4922% ReferencePixelCache() increments the reference count associated with the
4923% pixel cache returning a pointer to the cache.
4924%
4925% The format of the ReferencePixelCache method is:
4926%
4927% Cache ReferencePixelCache(Cache cache_info)
4928%
4929% A description of each parameter follows:
4930%
4931% o cache_info: the pixel cache.
4932%
4933*/
4934MagickPrivate Cache ReferencePixelCache(Cache cache)
4935{
4936 CacheInfo
4937 *magick_restrict cache_info;
4938
4939 assert(cache != (Cache *) NULL);
4940 cache_info=(CacheInfo *) cache;
4941 assert(cache_info->signature == MagickCoreSignature);
4942 LockSemaphoreInfo(cache_info->semaphore);
4943 cache_info->reference_count++;
4944 UnlockSemaphoreInfo(cache_info->semaphore);
4945 return(cache_info);
4946}
4947␌
4948/*
4949%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4950% %
4951% %
4952% %
4953+ R e s e t P i x e l C a c h e C h a n n e l s %
4954% %
4955% %
4956% %
4957%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4958%
4959% ResetPixelCacheChannels() resets the pixel cache channels.
4960%
4961% The format of the ResetPixelCacheChannels method is:
4962%
4963% void ResetPixelCacheChannels(Image *)
4964%
4965% A description of each parameter follows:
4966%
4967% o image: the image.
4968%
4969*/
4970MagickPrivate void ResetPixelCacheChannels(Image *image)
4971{
4972 CacheInfo
4973 *magick_restrict cache_info;
4974
4975 assert(image != (const Image *) NULL);
4976 assert(image->signature == MagickCoreSignature);
4977 assert(image->cache != (Cache) NULL);
4978 cache_info=(CacheInfo *) image->cache;
4979 assert(cache_info->signature == MagickCoreSignature);
4980 cache_info->number_channels=GetPixelChannels(image);
4981}
4982␌
4983/*
4984%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4985% %
4986% %
4987% %
4988+ R e s e t C a c h e A n o n y m o u s M e m o r y %
4989% %
4990% %
4991% %
4992%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4993%
4994% ResetCacheAnonymousMemory() resets the anonymous_memory value.
4995%
4996% The format of the ResetCacheAnonymousMemory method is:
4997%
4998% void ResetCacheAnonymousMemory(void)
4999%
5000*/
5001MagickPrivate void ResetCacheAnonymousMemory(void)
5002{
5003 cache_anonymous_memory=0;
5004}
5005␌
5006/*
5007%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5008% %
5009% %
5010% %
5011% R e s h a p e P i x e l C a c h e %
5012% %
5013% %
5014% %
5015%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5016%
5017% ReshapePixelCache() reshapes an existing pixel cache.
5018%
5019% The format of the ReshapePixelCache() method is:
5020%
5021% MagickBooleanType ReshapePixelCache(Image *image,const size_t columns,
5022% const size_t rows,ExceptionInfo *exception)
5023%
5024% A description of each parameter follows:
5025%
5026% o image: the image.
5027%
5028% o columns: the number of columns in the reshaped pixel cache.
5029%
5030% o rows: number of rows in the reshaped pixel cache.
5031%
5032% o exception: return any errors or warnings in this structure.
5033%
5034*/
5035MagickExport MagickBooleanType ReshapePixelCache(Image *image,
5036 const size_t columns,const size_t rows,ExceptionInfo *exception)
5037{
5038 CacheInfo
5039 *cache_info;
5040
5041 MagickSizeType
5042 extent;
5043
5044 assert(image != (Image *) NULL);
5045 assert(image->signature == MagickCoreSignature);
5046 if (IsEventLogging() != MagickFalse)
5047 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
5048 assert(image->cache != (void *) NULL);
5049 extent=(MagickSizeType) columns*rows;
5050 if (extent > ((MagickSizeType) image->columns*image->rows))
5051 ThrowBinaryException(ImageError,"WidthOrHeightExceedsLimit",
5052 image->filename);
5053 image->columns=columns;
5054 image->rows=rows;
5055 cache_info=(CacheInfo *) image->cache;
5056 cache_info->columns=columns;
5057 cache_info->rows=rows;
5058 return(SyncImagePixelCache(image,exception));
5059}
5060␌
5061/*
5062%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5063% %
5064% %
5065% %
5066+ S e t P i x e l C a c h e M e t h o d s %
5067% %
5068% %
5069% %
5070%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5071%
5072% SetPixelCacheMethods() sets the image pixel methods to the specified ones.
5073%
5074% The format of the SetPixelCacheMethods() method is:
5075%
5076% SetPixelCacheMethods(Cache *,CacheMethods *cache_methods)
5077%
5078% A description of each parameter follows:
5079%
5080% o cache: the pixel cache.
5081%
5082% o cache_methods: Specifies a pointer to a CacheMethods structure.
5083%
5084*/
5085MagickPrivate void SetPixelCacheMethods(Cache cache,CacheMethods *cache_methods)
5086{
5087 CacheInfo
5088 *magick_restrict cache_info;
5089
5090 GetOneAuthenticPixelFromHandler
5091 get_one_authentic_pixel_from_handler;
5092
5093 GetOneVirtualPixelFromHandler
5094 get_one_virtual_pixel_from_handler;
5095
5096 /*
5097 Set cache pixel methods.
5098 */
5099 assert(cache != (Cache) NULL);
5100 assert(cache_methods != (CacheMethods *) NULL);
5101 cache_info=(CacheInfo *) cache;
5102 assert(cache_info->signature == MagickCoreSignature);
5103 if (IsEventLogging() != MagickFalse)
5104 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
5105 cache_info->filename);
5106 if (cache_methods->get_virtual_pixel_handler != (GetVirtualPixelHandler) NULL)
5107 cache_info->methods.get_virtual_pixel_handler=
5108 cache_methods->get_virtual_pixel_handler;
5109 if (cache_methods->destroy_pixel_handler != (DestroyPixelHandler) NULL)
5110 cache_info->methods.destroy_pixel_handler=
5111 cache_methods->destroy_pixel_handler;
5112 if (cache_methods->get_virtual_metacontent_from_handler !=
5113 (GetVirtualMetacontentFromHandler) NULL)
5114 cache_info->methods.get_virtual_metacontent_from_handler=
5115 cache_methods->get_virtual_metacontent_from_handler;
5116 if (cache_methods->get_authentic_pixels_handler !=
5117 (GetAuthenticPixelsHandler) NULL)
5118 cache_info->methods.get_authentic_pixels_handler=
5119 cache_methods->get_authentic_pixels_handler;
5120 if (cache_methods->queue_authentic_pixels_handler !=
5121 (QueueAuthenticPixelsHandler) NULL)
5122 cache_info->methods.queue_authentic_pixels_handler=
5123 cache_methods->queue_authentic_pixels_handler;
5124 if (cache_methods->sync_authentic_pixels_handler !=
5125 (SyncAuthenticPixelsHandler) NULL)
5126 cache_info->methods.sync_authentic_pixels_handler=
5127 cache_methods->sync_authentic_pixels_handler;
5128 if (cache_methods->get_authentic_pixels_from_handler !=
5129 (GetAuthenticPixelsFromHandler) NULL)
5130 cache_info->methods.get_authentic_pixels_from_handler=
5131 cache_methods->get_authentic_pixels_from_handler;
5132 if (cache_methods->get_authentic_metacontent_from_handler !=
5133 (GetAuthenticMetacontentFromHandler) NULL)
5134 cache_info->methods.get_authentic_metacontent_from_handler=
5135 cache_methods->get_authentic_metacontent_from_handler;
5136 get_one_virtual_pixel_from_handler=
5137 cache_info->methods.get_one_virtual_pixel_from_handler;
5138 if (get_one_virtual_pixel_from_handler !=
5139 (GetOneVirtualPixelFromHandler) NULL)
5140 cache_info->methods.get_one_virtual_pixel_from_handler=
5141 cache_methods->get_one_virtual_pixel_from_handler;
5142 get_one_authentic_pixel_from_handler=
5143 cache_methods->get_one_authentic_pixel_from_handler;
5144 if (get_one_authentic_pixel_from_handler !=
5145 (GetOneAuthenticPixelFromHandler) NULL)
5146 cache_info->methods.get_one_authentic_pixel_from_handler=
5147 cache_methods->get_one_authentic_pixel_from_handler;
5148}
5149␌
5150/*
5151%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5152% %
5153% %
5154% %
5155+ S e t P i x e l C a c h e N e x u s P i x e l s %
5156% %
5157% %
5158% %
5159%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5160%
5161% SetPixelCacheNexusPixels() defines the region of the cache for the
5162% specified cache nexus.
5163%
5164% The format of the SetPixelCacheNexusPixels() method is:
5165%
5166% Quantum SetPixelCacheNexusPixels(
5167% const CacheInfo *magick_restrict cache_info,const MapMode mode,
5168% const ssize_t x,const ssize_t y,const size_t width,const size_t height,
5169% const MagickBooleanType buffered,NexusInfo *magick_restrict nexus_info,
5170% ExceptionInfo *exception)
5171%
5172% A description of each parameter follows:
5173%
5174% o cache_info: the pixel cache.
5175%
5176% o mode: ReadMode, WriteMode, or IOMode.
5177%
5178% o x,y,width,height: define the region of this particular cache nexus.
5179%
5180% o buffered: if true, nexus pixels are buffered.
5181%
5182% o nexus_info: the cache nexus to set.
5183%
5184% o exception: return any errors or warnings in this structure.
5185%
5186*/
5187
5188static inline MagickBooleanType AcquireCacheNexusPixels(
5189 const CacheInfo *magick_restrict cache_info,const MagickSizeType length,
5190 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
5191{
5192 if (length != (MagickSizeType) ((size_t) length))
5193 {
5194 (void) ThrowMagickException(exception,GetMagickModule(),
5195 ResourceLimitError,"PixelCacheAllocationFailed","`%s'",
5196 cache_info->filename);
5197 return(MagickFalse);
5198 }
5199 nexus_info->length=0;
5200 nexus_info->mapped=MagickFalse;
5201 if (cache_anonymous_memory <= 0)
5202 {
5203 nexus_info->cache=(Quantum *) MagickAssumeAligned(AcquireAlignedMemory(1,
5204 (size_t) length));
5205 if (nexus_info->cache != (Quantum *) NULL)
5206 (void) memset(nexus_info->cache,0,(size_t) length);
5207 }
5208 else
5209 {
5210 nexus_info->cache=(Quantum *) MapBlob(-1,IOMode,0,(size_t) length);
5211 if (nexus_info->cache != (Quantum *) NULL)
5212 nexus_info->mapped=MagickTrue;
5213 }
5214 if (nexus_info->cache == (Quantum *) NULL)
5215 {
5216 (void) ThrowMagickException(exception,GetMagickModule(),
5217 ResourceLimitError,"PixelCacheAllocationFailed","`%s'",
5218 cache_info->filename);
5219 return(MagickFalse);
5220 }
5221 nexus_info->length=length;
5222 return(MagickTrue);
5223}
5224
5225static inline void PrefetchPixelCacheNexusPixels(const NexusInfo *nexus_info,
5226 const MapMode mode)
5227{
5228 if (nexus_info->length < CACHE_LINE_SIZE)
5229 return;
5230 if (mode == ReadMode)
5231 {
5232 MagickCachePrefetch((unsigned char *) nexus_info->pixels+CACHE_LINE_SIZE,
5233 0,1);
5234 return;
5235 }
5236 MagickCachePrefetch((unsigned char *) nexus_info->pixels+CACHE_LINE_SIZE,1,1);
5237}
5238
5239static Quantum *SetPixelCacheNexusPixels(
5240 const CacheInfo *magick_restrict cache_info,const MapMode mode,
5241 const ssize_t x,const ssize_t y,const size_t width,const size_t height,
5242 const MagickBooleanType buffered,NexusInfo *magick_restrict nexus_info,
5243 ExceptionInfo *exception)
5244{
5245 MagickBooleanType
5246 status;
5247
5248 MagickSizeType
5249 length,
5250 number_pixels;
5251
5252 assert(cache_info != (const CacheInfo *) NULL);
5253 assert(cache_info->signature == MagickCoreSignature);
5254 if (cache_info->type == UndefinedCache)
5255 return((Quantum *) NULL);
5256 assert(nexus_info->signature == MagickCoreSignature);
5257 (void) memset(&nexus_info->region,0,sizeof(nexus_info->region));
5258 if ((width == 0) || (height == 0))
5259 {
5260 (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
5261 "NoPixelsDefinedInCache","`%s'",cache_info->filename);
5262 return((Quantum *) NULL);
5263 }
5264 if (((MagickSizeType) width > cache_info->width_limit) ||
5265 ((MagickSizeType) height > cache_info->height_limit))
5266 {
5267 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
5268 "WidthOrHeightExceedsLimit","`%s'",cache_info->filename);
5269 return((Quantum *) NULL);
5270 }
5271 if ((IsValidPixelOffset(x,width) == MagickFalse) ||
5272 (IsValidPixelOffset(y,height) == MagickFalse))
5273 {
5274 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
5275 "InvalidPixel","`%s'",cache_info->filename);
5276 return((Quantum *) NULL);
5277 }
5278 if (((cache_info->type == MemoryCache) || (cache_info->type == MapCache)) &&
5279 (buffered == MagickFalse))
5280 {
5281 if (((x >= 0) && (y >= 0) &&
5282 (((ssize_t) height+y-1) < (ssize_t) cache_info->rows)) &&
5283 (((x == 0) && (width == cache_info->columns)) || ((height == 1) &&
5284 (((ssize_t) width+x-1) < (ssize_t) cache_info->columns))))
5285 {
5286 MagickOffsetType
5287 offset;
5288
5289 /*
5290 Pixels are accessed directly from memory.
5291 */
5292 if (IsValidPixelOffset(y,cache_info->columns) == MagickFalse)
5293 return((Quantum *) NULL);
5294 offset=y*(MagickOffsetType) cache_info->columns+x;
5295 nexus_info->pixels=cache_info->pixels+(MagickOffsetType)
5296 cache_info->number_channels*offset;
5297 nexus_info->metacontent=(void *) NULL;
5298 if (cache_info->metacontent_extent != 0)
5299 nexus_info->metacontent=(unsigned char *) cache_info->metacontent+
5300 offset*(MagickOffsetType) cache_info->metacontent_extent;
5301 nexus_info->region.width=width;
5302 nexus_info->region.height=height;
5303 nexus_info->region.x=x;
5304 nexus_info->region.y=y;
5305 nexus_info->authentic_pixel_cache=MagickTrue;
5306 PrefetchPixelCacheNexusPixels(nexus_info,mode);
5307 return(nexus_info->pixels);
5308 }
5309 }
5310 /*
5311 Pixels are stored in a staging region until they are synced to the cache.
5312 */
5313 number_pixels=(MagickSizeType) width*height;
5314 length=MagickMax(number_pixels,MagickMax(cache_info->columns,
5315 cache_info->rows))*cache_info->number_channels*sizeof(*nexus_info->pixels);
5316 if (cache_info->metacontent_extent != 0)
5317 length+=number_pixels*cache_info->metacontent_extent;
5318 status=MagickTrue;
5319 if (nexus_info->cache == (Quantum *) NULL)
5320 status=AcquireCacheNexusPixels(cache_info,length,nexus_info,exception);
5321 else
5322 if (nexus_info->length < length)
5323 {
5324 RelinquishCacheNexusPixels(nexus_info);
5325 status=AcquireCacheNexusPixels(cache_info,length,nexus_info,exception);
5326 }
5327 if (status == MagickFalse)
5328 return((Quantum *) NULL);
5329 nexus_info->pixels=nexus_info->cache;
5330 nexus_info->metacontent=(void *) NULL;
5331 if (cache_info->metacontent_extent != 0)
5332 nexus_info->metacontent=(void *) (nexus_info->pixels+
5333 cache_info->number_channels*number_pixels);
5334 nexus_info->region.width=width;
5335 nexus_info->region.height=height;
5336 nexus_info->region.x=x;
5337 nexus_info->region.y=y;
5338 nexus_info->authentic_pixel_cache=cache_info->type == PingCache ?
5339 MagickTrue : MagickFalse;
5340 PrefetchPixelCacheNexusPixels(nexus_info,mode);
5341 return(nexus_info->pixels);
5342}
5343␌
5344/*
5345%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5346% %
5347% %
5348% %
5349% S e t P i x e l C a c h e V i r t u a l M e t h o d %
5350% %
5351% %
5352% %
5353%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5354%
5355% SetPixelCacheVirtualMethod() sets the "virtual pixels" method for the
5356% pixel cache and returns the previous setting. A virtual pixel is any pixel
5357% access that is outside the boundaries of the image cache.
5358%
5359% The format of the SetPixelCacheVirtualMethod() method is:
5360%
5361% VirtualPixelMethod SetPixelCacheVirtualMethod(Image *image,
5362% const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
5363%
5364% A description of each parameter follows:
5365%
5366% o image: the image.
5367%
5368% o virtual_pixel_method: choose the type of virtual pixel.
5369%
5370% o exception: return any errors or warnings in this structure.
5371%
5372*/
5373
5374static MagickBooleanType SetCacheAlphaChannel(Image *image,const Quantum alpha,
5375 ExceptionInfo *exception)
5376{
5377 CacheView
5378 *magick_restrict image_view;
5379
5380 MagickBooleanType
5381 status;
5382
5383 ssize_t
5384 y;
5385
5386 assert(image != (Image *) NULL);
5387 assert(image->signature == MagickCoreSignature);
5388 if (IsEventLogging() != MagickFalse)
5389 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
5390 assert(image->cache != (Cache) NULL);
5391 image->alpha_trait=BlendPixelTrait;
5392 status=MagickTrue;
5393 image_view=AcquireVirtualCacheView(image,exception); /* must be virtual */
5394#if defined(MAGICKCORE_OPENMP_SUPPORT)
5395 #pragma omp parallel for schedule(static) shared(status) \
5396 magick_number_threads(image,image,image->rows,2)
5397#endif
5398 for (y=0; y < (ssize_t) image->rows; y++)
5399 {
5400 Quantum
5401 *magick_restrict q;
5402
5403 ssize_t
5404 x;
5405
5406 if (status == MagickFalse)
5407 continue;
5408 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
5409 if (q == (Quantum *) NULL)
5410 {
5411 status=MagickFalse;
5412 continue;
5413 }
5414 for (x=0; x < (ssize_t) image->columns; x++)
5415 {
5416 SetPixelAlpha(image,alpha,q);
5417 q+=(ptrdiff_t) GetPixelChannels(image);
5418 }
5419 status=SyncCacheViewAuthenticPixels(image_view,exception);
5420 }
5421 image_view=DestroyCacheView(image_view);
5422 return(status);
5423}
5424
5425MagickPrivate VirtualPixelMethod SetPixelCacheVirtualMethod(Image *image,
5426 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
5427{
5428 CacheInfo
5429 *magick_restrict cache_info;
5430
5431 VirtualPixelMethod
5432 method;
5433
5434 assert(image != (Image *) NULL);
5435 assert(image->signature == MagickCoreSignature);
5436 if (IsEventLogging() != MagickFalse)
5437 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
5438 assert(image->cache != (Cache) NULL);
5439 cache_info=(CacheInfo *) image->cache;
5440 assert(cache_info->signature == MagickCoreSignature);
5441 method=cache_info->virtual_pixel_method;
5442 cache_info->virtual_pixel_method=virtual_pixel_method;
5443 if ((image->columns != 0) && (image->rows != 0))
5444 switch (virtual_pixel_method)
5445 {
5446 case BackgroundVirtualPixelMethod:
5447 {
5448 if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
5449 ((image->alpha_trait & BlendPixelTrait) == 0))
5450 (void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
5451 if ((IsPixelInfoGray(&image->background_color) == MagickFalse) &&
5452 (IsGrayColorspace(image->colorspace) != MagickFalse))
5453 (void) SetImageColorspace(image,sRGBColorspace,exception);
5454 break;
5455 }
5456 case TransparentVirtualPixelMethod:
5457 {
5458 if ((image->alpha_trait & BlendPixelTrait) == 0)
5459 (void) SetCacheAlphaChannel(image,OpaqueAlpha,exception);
5460 break;
5461 }
5462 default:
5463 break;
5464 }
5465 return(method);
5466}
5467
5468#if defined(MAGICKCORE_OPENCL_SUPPORT)
5469/*
5470%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5471% %
5472% %
5473% %
5474+ S y n c A u t h e n t i c O p e n C L B u f f e r %
5475% %
5476% %
5477% %
5478%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5479%
5480% SyncAuthenticOpenCLBuffer() makes sure that all the OpenCL operations have
5481% been completed and updates the host memory.
5482%
5483% The format of the SyncAuthenticOpenCLBuffer() method is:
5484%
5485% void SyncAuthenticOpenCLBuffer(const Image *image)
5486%
5487% A description of each parameter follows:
5488%
5489% o image: the image.
5490%
5491*/
5492
5493static void CopyOpenCLBuffer(CacheInfo *magick_restrict cache_info)
5494{
5495 assert(cache_info != (CacheInfo *) NULL);
5496 assert(cache_info->signature == MagickCoreSignature);
5497 if ((cache_info->type != MemoryCache) ||
5498 (cache_info->opencl == (MagickCLCacheInfo) NULL))
5499 return;
5500 /*
5501 Ensure single threaded access to OpenCL environment.
5502 */
5503 LockSemaphoreInfo(cache_info->semaphore);
5504 cache_info->opencl=CopyMagickCLCacheInfo(cache_info->opencl);
5505 UnlockSemaphoreInfo(cache_info->semaphore);
5506}
5507
5508MagickPrivate void SyncAuthenticOpenCLBuffer(const Image *image)
5509{
5510 CacheInfo
5511 *magick_restrict cache_info;
5512
5513 assert(image != (const Image *) NULL);
5514 cache_info=(CacheInfo *) image->cache;
5515 CopyOpenCLBuffer(cache_info);
5516}
5517#endif
5518␌
5519/*
5520%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5521% %
5522% %
5523% %
5524+ S y n c A u t h e n t i c P i x e l C a c h e N e x u s %
5525% %
5526% %
5527% %
5528%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5529%
5530% SyncAuthenticPixelCacheNexus() saves the authentic image pixels to the
5531% in-memory or disk cache. The method returns MagickTrue if the pixel region
5532% is synced, otherwise MagickFalse.
5533%
5534% The format of the SyncAuthenticPixelCacheNexus() method is:
5535%
5536% MagickBooleanType SyncAuthenticPixelCacheNexus(Image *image,
5537% NexusInfo *nexus_info,ExceptionInfo *exception)
5538%
5539% A description of each parameter follows:
5540%
5541% o image: the image.
5542%
5543% o nexus_info: the cache nexus to sync.
5544%
5545% o exception: return any errors or warnings in this structure.
5546%
5547*/
5548MagickPrivate MagickBooleanType SyncAuthenticPixelCacheNexus(Image *image,
5549 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
5550{
5551 CacheInfo
5552 *magick_restrict cache_info;
5553
5554 MagickBooleanType
5555 status;
5556
5557 /*
5558 Transfer pixels to the cache.
5559 */
5560 assert(image != (Image *) NULL);
5561 assert(image->signature == MagickCoreSignature);
5562 if (image->cache == (Cache) NULL)
5563 ThrowBinaryException(CacheError,"PixelCacheIsNotOpen",image->filename);
5564 cache_info=(CacheInfo *) image->cache;
5565 assert(cache_info->signature == MagickCoreSignature);
5566 if (cache_info->type == UndefinedCache)
5567 return(MagickFalse);
5568 if ((image->mask_trait & UpdatePixelTrait) != 0)
5569 {
5570 if (((image->channels & WriteMaskChannel) != 0) &&
5571 (ClipPixelCacheNexus(image,nexus_info,exception) == MagickFalse))
5572 return(MagickFalse);
5573 if (((image->channels & CompositeMaskChannel) != 0) &&
5574 (MaskPixelCacheNexus(image,nexus_info,exception) == MagickFalse))
5575 return(MagickFalse);
5576 }
5577 if (nexus_info->authentic_pixel_cache != MagickFalse)
5578 {
5579 if (image->taint == MagickFalse)
5580 image->taint=MagickTrue;
5581 return(MagickTrue);
5582 }
5583 assert(cache_info->signature == MagickCoreSignature);
5584 status=WritePixelCachePixels(cache_info,nexus_info,exception);
5585 if ((cache_info->metacontent_extent != 0) &&
5586 (WritePixelCacheMetacontent(cache_info,nexus_info,exception) == MagickFalse))
5587 return(MagickFalse);
5588 if ((status != MagickFalse) && (image->taint == MagickFalse))
5589 image->taint=MagickTrue;
5590 return(status);
5591}
5592␌
5593/*
5594%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5595% %
5596% %
5597% %
5598+ S y n c A u t h e n t i c P i x e l C a c h e %
5599% %
5600% %
5601% %
5602%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5603%
5604% SyncAuthenticPixelsCache() saves the authentic image pixels to the in-memory
5605% or disk cache. The method returns MagickTrue if the pixel region is synced,
5606% otherwise MagickFalse.
5607%
5608% The format of the SyncAuthenticPixelsCache() method is:
5609%
5610% MagickBooleanType SyncAuthenticPixelsCache(Image *image,
5611% ExceptionInfo *exception)
5612%
5613% A description of each parameter follows:
5614%
5615% o image: the image.
5616%
5617% o exception: return any errors or warnings in this structure.
5618%
5619*/
5620static MagickBooleanType SyncAuthenticPixelsCache(Image *image,
5621 ExceptionInfo *exception)
5622{
5623 CacheInfo
5624 *magick_restrict cache_info;
5625
5626 const int
5627 id = GetOpenMPThreadId();
5628
5629 MagickBooleanType
5630 status;
5631
5632 assert(image != (Image *) NULL);
5633 assert(image->signature == MagickCoreSignature);
5634 assert(image->cache != (Cache) NULL);
5635 cache_info=(CacheInfo *) image->cache;
5636 assert(cache_info->signature == MagickCoreSignature);
5637 assert(id < (int) cache_info->number_threads);
5638 status=SyncAuthenticPixelCacheNexus(image,cache_info->nexus_info[id],
5639 exception);
5640 return(status);
5641}
5642␌
5643/*
5644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5645% %
5646% %
5647% %
5648% S y n c A u t h e n t i c P i x e l s %
5649% %
5650% %
5651% %
5652%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5653%
5654% SyncAuthenticPixels() saves the image pixels to the in-memory or disk cache.
5655% The method returns MagickTrue if the pixel region is flushed, otherwise
5656% MagickFalse.
5657%
5658% The format of the SyncAuthenticPixels() method is:
5659%
5660% MagickBooleanType SyncAuthenticPixels(Image *image,
5661% ExceptionInfo *exception)
5662%
5663% A description of each parameter follows:
5664%
5665% o image: the image.
5666%
5667% o exception: return any errors or warnings in this structure.
5668%
5669*/
5670MagickExport MagickBooleanType SyncAuthenticPixels(Image *image,
5671 ExceptionInfo *exception)
5672{
5673 CacheInfo
5674 *magick_restrict cache_info;
5675
5676 const int
5677 id = GetOpenMPThreadId();
5678
5679 MagickBooleanType
5680 status;
5681
5682 assert(image != (Image *) NULL);
5683 assert(image->signature == MagickCoreSignature);
5684 assert(image->cache != (Cache) NULL);
5685 cache_info=(CacheInfo *) image->cache;
5686 assert(cache_info->signature == MagickCoreSignature);
5687 if (cache_info->methods.sync_authentic_pixels_handler != (SyncAuthenticPixelsHandler) NULL)
5688 {
5689 status=cache_info->methods.sync_authentic_pixels_handler(image,
5690 exception);
5691 return(status);
5692 }
5693 assert(id < (int) cache_info->number_threads);
5694 status=SyncAuthenticPixelCacheNexus(image,cache_info->nexus_info[id],
5695 exception);
5696 return(status);
5697}
5698␌
5699/*
5700%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5701% %
5702% %
5703% %
5704+ S y n c I m a g e P i x e l C a c h e %
5705% %
5706% %
5707% %
5708%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5709%
5710% SyncImagePixelCache() saves the image pixels to the in-memory or disk cache.
5711% The method returns MagickTrue if the pixel region is flushed, otherwise
5712% MagickFalse.
5713%
5714% The format of the SyncImagePixelCache() method is:
5715%
5716% MagickBooleanType SyncImagePixelCache(Image *image,
5717% ExceptionInfo *exception)
5718%
5719% A description of each parameter follows:
5720%
5721% o image: the image.
5722%
5723% o exception: return any errors or warnings in this structure.
5724%
5725*/
5726MagickPrivate MagickBooleanType SyncImagePixelCache(Image *image,
5727 ExceptionInfo *exception)
5728{
5729 CacheInfo
5730 *magick_restrict cache_info;
5731
5732 assert(image != (Image *) NULL);
5733 assert(exception != (ExceptionInfo *) NULL);
5734 cache_info=(CacheInfo *) GetImagePixelCache(image,MagickTrue,exception);
5735 return(cache_info == (CacheInfo *) NULL ? MagickFalse : MagickTrue);
5736}
5737␌
5738/*
5739%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5740% %
5741% %
5742% %
5743+ W r i t e P i x e l C a c h e M e t a c o n t e n t %
5744% %
5745% %
5746% %
5747%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5748%
5749% WritePixelCacheMetacontent() writes the meta-content to the specified region
5750% of the pixel cache.
5751%
5752% The format of the WritePixelCacheMetacontent() method is:
5753%
5754% MagickBooleanType WritePixelCacheMetacontent(CacheInfo *cache_info,
5755% NexusInfo *nexus_info,ExceptionInfo *exception)
5756%
5757% A description of each parameter follows:
5758%
5759% o cache_info: the pixel cache.
5760%
5761% o nexus_info: the cache nexus to write the meta-content.
5762%
5763% o exception: return any errors or warnings in this structure.
5764%
5765*/
5766static MagickBooleanType WritePixelCacheMetacontent(CacheInfo *cache_info,
5767 NexusInfo *magick_restrict nexus_info,ExceptionInfo *exception)
5768{
5769 MagickOffsetType
5770 count,
5771 offset;
5772
5773 MagickSizeType
5774 extent,
5775 length;
5776
5777 const unsigned char
5778 *magick_restrict p;
5779
5780 ssize_t
5781 y;
5782
5783 size_t
5784 rows;
5785
5786 if (cache_info->metacontent_extent == 0)
5787 return(MagickFalse);
5788 if (nexus_info->authentic_pixel_cache != MagickFalse)
5789 return(MagickTrue);
5790 if (nexus_info->metacontent == (unsigned char *) NULL)
5791 return(MagickFalse);
5792 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
5793 return(MagickFalse);
5794 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
5795 nexus_info->region.x;
5796 length=(MagickSizeType) nexus_info->region.width*
5797 cache_info->metacontent_extent;
5798 extent=(MagickSizeType) length*nexus_info->region.height;
5799 rows=nexus_info->region.height;
5800 y=0;
5801 p=(unsigned char *) nexus_info->metacontent;
5802 switch (cache_info->type)
5803 {
5804 case MemoryCache:
5805 case MapCache:
5806 {
5807 unsigned char
5808 *magick_restrict q;
5809
5810 /*
5811 Write associated pixels to memory.
5812 */
5813 if ((cache_info->columns == nexus_info->region.width) &&
5814 (extent == (MagickSizeType) ((size_t) extent)))
5815 {
5816 length=extent;
5817 rows=1UL;
5818 }
5819 q=(unsigned char *) cache_info->metacontent+offset*
5820 (MagickOffsetType) cache_info->metacontent_extent;
5821 for (y=0; y < (ssize_t) rows; y++)
5822 {
5823 (void) memcpy(q,p,(size_t) length);
5824 p+=(ptrdiff_t) nexus_info->region.width*cache_info->metacontent_extent;
5825 q+=(ptrdiff_t) cache_info->columns*cache_info->metacontent_extent;
5826 }
5827 break;
5828 }
5829 case DiskCache:
5830 {
5831 /*
5832 Write associated pixels to disk.
5833 */
5834 LockSemaphoreInfo(cache_info->file_semaphore);
5835 if (OpenPixelCacheOnDisk(cache_info,IOMode) == MagickFalse)
5836 {
5837 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
5838 cache_info->cache_filename);
5839 UnlockSemaphoreInfo(cache_info->file_semaphore);
5840 return(MagickFalse);
5841 }
5842 if ((cache_info->columns == nexus_info->region.width) &&
5843 (extent <= MagickMaxBufferExtent))
5844 {
5845 length=extent;
5846 rows=1UL;
5847 }
5848 extent=(MagickSizeType) cache_info->columns*cache_info->rows;
5849 for (y=0; y < (ssize_t) rows; y++)
5850 {
5851 count=WritePixelCacheRegion(cache_info,cache_info->offset+
5852 (MagickOffsetType) extent*(MagickOffsetType)
5853 cache_info->number_channels*(MagickOffsetType) sizeof(Quantum)+offset*
5854 (MagickOffsetType) cache_info->metacontent_extent,length,
5855 (const unsigned char *) p);
5856 if (count != (MagickOffsetType) length)
5857 break;
5858 p+=(ptrdiff_t) cache_info->metacontent_extent*nexus_info->region.width;
5859 offset+=(MagickOffsetType) cache_info->columns;
5860 }
5861 if (IsFileDescriptorLimitExceeded() != MagickFalse)
5862 (void) ClosePixelCacheOnDisk(cache_info);
5863 UnlockSemaphoreInfo(cache_info->file_semaphore);
5864 break;
5865 }
5866 case DistributedCache:
5867 {
5868 RectangleInfo
5869 region;
5870
5871 /*
5872 Write metacontent to distributed cache.
5873 */
5874 LockSemaphoreInfo(cache_info->file_semaphore);
5875 region=nexus_info->region;
5876 if ((cache_info->columns != nexus_info->region.width) ||
5877 (extent > MagickMaxBufferExtent))
5878 region.height=1UL;
5879 else
5880 {
5881 length=extent;
5882 rows=1UL;
5883 }
5884 for (y=0; y < (ssize_t) rows; y++)
5885 {
5886 count=WriteDistributePixelCacheMetacontent((DistributeCacheInfo *)
5887 cache_info->server_info,&region,length,(const unsigned char *) p);
5888 if (count != (MagickOffsetType) length)
5889 break;
5890 p+=(ptrdiff_t) cache_info->metacontent_extent*nexus_info->region.width;
5891 region.y++;
5892 }
5893 UnlockSemaphoreInfo(cache_info->file_semaphore);
5894 break;
5895 }
5896 default:
5897 break;
5898 }
5899 if (y < (ssize_t) rows)
5900 {
5901 ThrowFileException(exception,CacheError,"UnableToWritePixelCache",
5902 cache_info->cache_filename);
5903 return(MagickFalse);
5904 }
5905 if ((cache_info->debug != MagickFalse) &&
5906 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
5907 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
5908 "%s[%.20gx%.20g%+.20g%+.20g]",cache_info->filename,(double)
5909 nexus_info->region.width,(double) nexus_info->region.height,(double)
5910 nexus_info->region.x,(double) nexus_info->region.y);
5911 return(MagickTrue);
5912}
5913␌
5914/*
5915%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5916% %
5917% %
5918% %
5919+ W r i t e C a c h e P i x e l s %
5920% %
5921% %
5922% %
5923%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5924%
5925% WritePixelCachePixels() writes image pixels to the specified region of the
5926% pixel cache.
5927%
5928% The format of the WritePixelCachePixels() method is:
5929%
5930% MagickBooleanType WritePixelCachePixels(CacheInfo *cache_info,
5931% NexusInfo *nexus_info,ExceptionInfo *exception)
5932%
5933% A description of each parameter follows:
5934%
5935% o cache_info: the pixel cache.
5936%
5937% o nexus_info: the cache nexus to write the pixels.
5938%
5939% o exception: return any errors or warnings in this structure.
5940%
5941*/
5942static MagickBooleanType WritePixelCachePixels(
5943 CacheInfo *magick_restrict cache_info,NexusInfo *magick_restrict nexus_info,
5944 ExceptionInfo *exception)
5945{
5946 MagickOffsetType
5947 count,
5948 offset;
5949
5950 MagickSizeType
5951 extent,
5952 length;
5953
5954 const Quantum
5955 *magick_restrict p;
5956
5957 ssize_t
5958 y;
5959
5960 size_t
5961 rows;
5962
5963 if (nexus_info->authentic_pixel_cache != MagickFalse)
5964 return(MagickTrue);
5965 if (IsValidPixelOffset(nexus_info->region.y,cache_info->columns) == MagickFalse)
5966 return(MagickFalse);
5967 offset=nexus_info->region.y*(MagickOffsetType) cache_info->columns+
5968 nexus_info->region.x;
5969 length=(MagickSizeType) cache_info->number_channels*nexus_info->region.width*
5970 sizeof(Quantum);
5971 extent=length*nexus_info->region.height;
5972 rows=nexus_info->region.height;
5973 y=0;
5974 p=nexus_info->pixels;
5975 switch (cache_info->type)
5976 {
5977 case MemoryCache:
5978 case MapCache:
5979 {
5980 Quantum
5981 *magick_restrict q;
5982
5983 /*
5984 Write pixels to memory.
5985 */
5986 if ((cache_info->columns == nexus_info->region.width) &&
5987 (extent == (MagickSizeType) ((size_t) extent)))
5988 {
5989 length=extent;
5990 rows=1UL;
5991 }
5992 q=cache_info->pixels+(MagickOffsetType) cache_info->number_channels*
5993 offset;
5994 for (y=0; y < (ssize_t) rows; y++)
5995 {
5996 (void) memcpy(q,p,(size_t) length);
5997 p+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
5998 q+=(ptrdiff_t) cache_info->number_channels*cache_info->columns;
5999 }
6000 break;
6001 }
6002 case DiskCache:
6003 {
6004 /*
6005 Write pixels to disk.
6006 */
6007 LockSemaphoreInfo(cache_info->file_semaphore);
6008 if (OpenPixelCacheOnDisk(cache_info,IOMode) == MagickFalse)
6009 {
6010 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
6011 cache_info->cache_filename);
6012 UnlockSemaphoreInfo(cache_info->file_semaphore);
6013 return(MagickFalse);
6014 }
6015 if ((cache_info->columns == nexus_info->region.width) &&
6016 (extent <= MagickMaxBufferExtent))
6017 {
6018 length=extent;
6019 rows=1UL;
6020 }
6021 for (y=0; y < (ssize_t) rows; y++)
6022 {
6023 count=WritePixelCacheRegion(cache_info,cache_info->offset+offset*
6024 (MagickOffsetType) cache_info->number_channels*(MagickOffsetType)
6025 sizeof(*p),length,(const unsigned char *) p);
6026 if (count != (MagickOffsetType) length)
6027 break;
6028 p+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
6029 offset+=(MagickOffsetType) cache_info->columns;
6030 }
6031 if (IsFileDescriptorLimitExceeded() != MagickFalse)
6032 (void) ClosePixelCacheOnDisk(cache_info);
6033 UnlockSemaphoreInfo(cache_info->file_semaphore);
6034 break;
6035 }
6036 case DistributedCache:
6037 {
6038 RectangleInfo
6039 region;
6040
6041 /*
6042 Write pixels to distributed cache.
6043 */
6044 LockSemaphoreInfo(cache_info->file_semaphore);
6045 region=nexus_info->region;
6046 if ((cache_info->columns != nexus_info->region.width) ||
6047 (extent > MagickMaxBufferExtent))
6048 region.height=1UL;
6049 else
6050 {
6051 length=extent;
6052 rows=1UL;
6053 }
6054 for (y=0; y < (ssize_t) rows; y++)
6055 {
6056 count=WriteDistributePixelCachePixels((DistributeCacheInfo *)
6057 cache_info->server_info,&region,length,(const unsigned char *) p);
6058 if (count != (MagickOffsetType) length)
6059 break;
6060 p+=(ptrdiff_t) cache_info->number_channels*nexus_info->region.width;
6061 region.y++;
6062 }
6063 UnlockSemaphoreInfo(cache_info->file_semaphore);
6064 break;
6065 }
6066 default:
6067 break;
6068 }
6069 if (y < (ssize_t) rows)
6070 {
6071 ThrowFileException(exception,CacheError,"UnableToWritePixelCache",
6072 cache_info->cache_filename);
6073 return(MagickFalse);
6074 }
6075 if ((cache_info->debug != MagickFalse) &&
6076 (CacheTick(nexus_info->region.y,cache_info->rows) != MagickFalse))
6077 (void) LogMagickEvent(CacheEvent,GetMagickModule(),
6078 "%s[%.20gx%.20g%+.20g%+.20g]",cache_info->filename,(double)
6079 nexus_info->region.width,(double) nexus_info->region.height,(double)
6080 nexus_info->region.x,(double) nexus_info->region.y);
6081 return(MagickTrue);
6082}
_CacheInfo
Definition cache-private.h:133
_CacheMethods
Definition cache-private.h:69
_CacheView
Definition cache-view.c:66
_DistributeCacheInfo
Definition distribute-cache-private.h:29
_ExceptionInfo
Definition exception.h:102
_Image
Definition image.h:132
_MagickModulo
Definition cache.c:99
_NexusInfo
Definition cache-private.h:105
_PixelChannelMap
Definition pixel.h:170
_PixelInfo
Definition pixel.h:182
_RandomInfo
Definition random.c:84
_RectangleInfo
Definition geometry.h:130