MagickCore 7.1.2-22
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
image.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% IIIII M M AAA GGGG EEEEE %
7% I MM MM A A G E %
8% I M M M AAAAA G GG EEE %
9% I M M A A G G E %
10% IIIII M M A A GGGG EEEEE %
11% %
12% %
13% MagickCore Image Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1992 %
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/animate.h"
45#include "MagickCore/artifact.h"
46#include "MagickCore/attribute.h"
47#include "MagickCore/blob.h"
48#include "MagickCore/blob-private.h"
49#include "MagickCore/cache.h"
50#include "MagickCore/cache-private.h"
51#include "MagickCore/cache-view.h"
52#include "MagickCore/channel.h"
53#include "MagickCore/client.h"
54#include "MagickCore/color.h"
55#include "MagickCore/color-private.h"
56#include "MagickCore/colormap.h"
57#include "MagickCore/colorspace.h"
58#include "MagickCore/colorspace-private.h"
59#include "MagickCore/composite.h"
60#include "MagickCore/composite-private.h"
61#include "MagickCore/compress.h"
62#include "MagickCore/constitute.h"
63#include "MagickCore/delegate.h"
64#include "MagickCore/display.h"
65#include "MagickCore/draw.h"
66#include "MagickCore/enhance.h"
67#include "MagickCore/exception.h"
68#include "MagickCore/exception-private.h"
69#include "MagickCore/gem.h"
70#include "MagickCore/geometry.h"
71#include "MagickCore/histogram.h"
72#include "MagickCore/image-private.h"
73#include "MagickCore/list.h"
74#include "MagickCore/magic.h"
75#include "MagickCore/magick.h"
76#include "MagickCore/magick-private.h"
77#include "MagickCore/memory_.h"
78#include "MagickCore/memory-private.h"
79#include "MagickCore/module.h"
80#include "MagickCore/monitor.h"
81#include "MagickCore/monitor-private.h"
82#include "MagickCore/option.h"
83#include "MagickCore/paint.h"
84#include "MagickCore/pixel-accessor.h"
85#include "MagickCore/profile.h"
86#include "MagickCore/property.h"
87#include "MagickCore/quantize.h"
88#include "MagickCore/random_.h"
89#include "MagickCore/resource_.h"
90#include "MagickCore/segment.h"
91#include "MagickCore/semaphore.h"
92#include "MagickCore/signature-private.h"
93#include "MagickCore/statistic.h"
94#include "MagickCore/string_.h"
95#include "MagickCore/string-private.h"
96#include "MagickCore/thread-private.h"
97#include "MagickCore/threshold.h"
98#include "MagickCore/timer.h"
99#include "MagickCore/timer-private.h"
100#include "MagickCore/token.h"
101#include "MagickCore/token-private.h"
102#include "MagickCore/utility.h"
103#include "MagickCore/utility-private.h"
104#include "MagickCore/version.h"
105#include "MagickCore/xwindow-private.h"
106␌
107/*
108%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
109% %
110% %
111% %
112% A c q u i r e I m a g e %
113% %
114% %
115% %
116%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117%
118% AcquireImage() returns a pointer to an image structure initialized to
119% default values.
120%
121% The format of the AcquireImage method is:
122%
123% Image *AcquireImage(const ImageInfo *image_info,ExceptionInfo *exception)
124%
125% A description of each parameter follows:
126%
127% o image_info: Many of the image default values are set from this
128% structure. For example, filename, compression, depth, background color,
129% and others.
130%
131% o exception: return any errors or warnings in this structure.
132%
133*/
134MagickExport Image *AcquireImage(const ImageInfo *image_info,
135 ExceptionInfo *exception)
136{
137 const char
138 *option;
139
140 Image
141 *image;
142
143 MagickSizeType
144 time_limit;
145
146 MagickStatusType
147 flags;
148
149 /*
150 Allocate image structure.
151 */
152 if (IsEventLogging() != MagickFalse)
153 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
154 image=(Image *) AcquireCriticalMemory(sizeof(*image));
155 (void) memset(image,0,sizeof(*image));
156 /*
157 Initialize Image structure.
158 */
159 (void) CopyMagickString(image->magick,"MIFF",MagickPathExtent);
160 image->storage_class=DirectClass;
161 image->depth=MAGICKCORE_QUANTUM_DEPTH;
162 image->colorspace=sRGBColorspace;
163 image->rendering_intent=PerceptualIntent;
164 image->gamma=1.000/2.200;
165 image->chromaticity.red_primary.x=0.6400;
166 image->chromaticity.red_primary.y=0.3300;
167 image->chromaticity.red_primary.z=0.0300;
168 image->chromaticity.green_primary.x=0.3000;
169 image->chromaticity.green_primary.y=0.6000;
170 image->chromaticity.green_primary.z=0.1000;
171 image->chromaticity.blue_primary.x=0.1500;
172 image->chromaticity.blue_primary.y=0.0600;
173 image->chromaticity.blue_primary.z=0.7900;
174 image->chromaticity.white_point.x=0.3127;
175 image->chromaticity.white_point.y=0.3290;
176 image->chromaticity.white_point.z=0.3583;
177 image->interlace=NoInterlace;
178 image->ticks_per_second=UndefinedTicksPerSecond;
179 image->compose=OverCompositeOp;
180 GetPixelInfoRGBA(BackgroundColorRGBA,&image->background_color);
181 GetPixelInfoRGBA(BorderColorRGBA,&image->border_color);
182 GetPixelInfoRGBA(MatteColorRGBA,&image->matte_color);
183 GetPixelInfoRGBA(TransparentColorRGBA,&image->transparent_color);
184 GetTimerInfo(&image->timer);
185 image->cache=AcquirePixelCache(0);
186 image->channel_mask=AllChannels;
187 image->channel_map=AcquirePixelChannelMap();
188 image->blob=CloneBlobInfo((BlobInfo *) NULL);
189#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
190 image->timestamp=0; /* Deterministic for fuzzing */
191#else
192 image->timestamp=time((time_t *) NULL);
193#endif
194 time_limit=GetMagickResourceLimit(TimeResource);
195 if (time_limit != MagickResourceInfinity)
196 image->ttl=image->timestamp+(time_t) time_limit;
197 image->debug=(GetLogEventMask() & (ImageEvent | TransformEvent | CoderEvent))
198 != 0 ? MagickTrue : MagickFalse;
199 image->reference_count=1;
200 image->semaphore=AcquireSemaphoreInfo();
201 image->signature=MagickCoreSignature;
202 if (image_info == (ImageInfo *) NULL)
203 return(image);
204 /*
205 Transfer image info.
206 */
207 SetBlobExempt(image,image_info->file != (FILE *) NULL ? MagickTrue :
208 MagickFalse);
209 (void) CopyMagickString(image->filename,image_info->filename,
210 MagickPathExtent);
211 (void) CopyMagickString(image->magick_filename,image_info->filename,
212 MagickPathExtent);
213 (void) CopyMagickString(image->magick,image_info->magick,MagickPathExtent);
214 if (image_info->size != (char *) NULL)
215 {
216 (void) ParseAbsoluteGeometry(image_info->size,&image->extract_info);
217 image->columns=image->extract_info.width;
218 image->rows=image->extract_info.height;
219 image->offset=image->extract_info.x;
220 image->extract_info.x=0;
221 image->extract_info.y=0;
222 }
223 if (image_info->extract != (char *) NULL)
224 {
225 RectangleInfo
226 geometry;
227
228 (void) memset(&geometry,0,sizeof(geometry));
229 flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
230 if (((flags & XValue) != 0) || ((flags & YValue) != 0))
231 {
232 image->extract_info=geometry;
233 Swap(image->columns,image->extract_info.width);
234 Swap(image->rows,image->extract_info.height);
235 }
236 }
237 image->compression=image_info->compression;
238 image->quality=image_info->quality;
239 image->endian=image_info->endian;
240 image->interlace=image_info->interlace;
241 image->units=image_info->units;
242 if (image_info->density != (char *) NULL)
243 {
244 GeometryInfo
245 geometry_info;
246
247 flags=ParseGeometry(image_info->density,&geometry_info);
248 if ((flags & RhoValue) != 0)
249 image->resolution.x=geometry_info.rho;
250 image->resolution.y=image->resolution.x;
251 if ((flags & SigmaValue) != 0)
252 image->resolution.y=geometry_info.sigma;
253 }
254 if (image_info->page != (char *) NULL)
255 {
256 char
257 *geometry;
258
259 image->page=image->extract_info;
260 geometry=GetPageGeometry(image_info->page);
261 (void) ParseAbsoluteGeometry(geometry,&image->page);
262 geometry=DestroyString(geometry);
263 }
264 if (image_info->depth != 0)
265 image->depth=image_info->depth;
266 image->dither=image_info->dither;
267 image->matte_color=image_info->matte_color;
268 image->background_color=image_info->background_color;
269 image->border_color=image_info->border_color;
270 image->transparent_color=image_info->transparent_color;
271 image->ping=image_info->ping;
272 image->progress_monitor=image_info->progress_monitor;
273 image->client_data=image_info->client_data;
274 if (image_info->cache != (void *) NULL)
275 ClonePixelCacheMethods(image->cache,image_info->cache);
276 /*
277 Set all global options that map to per-image settings.
278 */
279 (void) SyncImageSettings(image_info,image,exception);
280 /*
281 Global options that are only set for new images.
282 */
283 option=GetImageOption(image_info,"delay");
284 if (option != (const char *) NULL)
285 {
286 GeometryInfo
287 geometry_info;
288
289 flags=ParseGeometry(option,&geometry_info);
290 if ((flags & GreaterValue) != 0)
291 {
292 if ((double) image->delay > floor(geometry_info.rho+0.5))
293 image->delay=(size_t) CastDoubleToSsizeT(floor(geometry_info.rho+
294 0.5));
295 }
296 else
297 if ((flags & LessValue) != 0)
298 {
299 if ((double) image->delay < floor(geometry_info.rho+0.5))
300 image->ticks_per_second=CastDoubleToSsizeT(floor(
301 geometry_info.sigma+0.5));
302 }
303 else
304 image->delay=(size_t) CastDoubleToSsizeT(floor(geometry_info.rho+
305 0.5));
306 if ((flags & SigmaValue) != 0)
307 image->ticks_per_second=CastDoubleToSsizeT(floor(geometry_info.sigma+
308 0.5));
309 }
310 option=GetImageOption(image_info,"dispose");
311 if (option != (const char *) NULL)
312 image->dispose=(DisposeType) ParseCommandOption(MagickDisposeOptions,
313 MagickFalse,option);
314 return(image);
315}
316␌
317/*
318%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
319% %
320% %
321% %
322% A c q u i r e I m a g e I n f o %
323% %
324% %
325% %
326%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
327%
328% AcquireImageInfo() allocates the ImageInfo structure.
329%
330% The format of the AcquireImageInfo method is:
331%
332% ImageInfo *AcquireImageInfo(void)
333%
334*/
335MagickExport ImageInfo *AcquireImageInfo(void)
336{
337 ImageInfo
338 *image_info;
339
340 image_info=(ImageInfo *) AcquireCriticalMemory(sizeof(*image_info));
341 GetImageInfo(image_info);
342 return(image_info);
343}
344␌
345/*
346%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
347% %
348% %
349% %
350% A c q u i r e N e x t I m a g e %
351% %
352% %
353% %
354%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
355%
356% AcquireNextImage() initializes the next image in a sequence to
357% default values. The next member of image points to the newly allocated
358% image. If there is a memory shortage, next is assigned NULL.
359%
360% The format of the AcquireNextImage method is:
361%
362% void AcquireNextImage(const ImageInfo *image_info,Image *image,
363% ExceptionInfo *exception)
364%
365% A description of each parameter follows:
366%
367% o image_info: Many of the image default values are set from this
368% structure. For example, filename, compression, depth, background color,
369% and others.
370%
371% o image: the image.
372%
373% o exception: return any errors or warnings in this structure.
374%
375*/
376MagickExport void AcquireNextImage(const ImageInfo *image_info,Image *image,
377 ExceptionInfo *exception)
378{
379 /*
380 Allocate image structure.
381 */
382 assert(image != (Image *) NULL);
383 assert(image->signature == MagickCoreSignature);
384 if (IsEventLogging() != MagickFalse)
385 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
386 image->next=AcquireImage(image_info,exception);
387 if (GetNextImageInList(image) == (Image *) NULL)
388 return;
389 (void) CopyMagickString(GetNextImageInList(image)->filename,image->filename,
390 MagickPathExtent);
391 if (image_info != (ImageInfo *) NULL)
392 (void) CopyMagickString(GetNextImageInList(image)->filename,
393 image_info->filename,MagickPathExtent);
394 DestroyBlob(GetNextImageInList(image));
395 image->next->blob=ReferenceBlob(image->blob);
396 image->next->endian=image->endian;
397 image->next->scene=image->scene+1;
398 image->next->previous=image;
399}
400␌
401/*
402%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
403% %
404% %
405% %
406% A p p e n d I m a g e s %
407% %
408% %
409% %
410%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
411%
412% AppendImages() takes all images from the current image pointer to the end
413% of the image list and appends them to each other top-to-bottom if the
414% stack parameter is true, otherwise left-to-right.
415%
416% The current gravity setting effects how the image is justified in the
417% final image.
418%
419% The format of the AppendImages method is:
420%
421% Image *AppendImages(const Image *images,const MagickBooleanType stack,
422% ExceptionInfo *exception)
423%
424% A description of each parameter follows:
425%
426% o images: the image sequence.
427%
428% o stack: A value other than 0 stacks the images top-to-bottom.
429%
430% o exception: return any errors or warnings in this structure.
431%
432*/
433MagickExport Image *AppendImages(const Image *images,
434 const MagickBooleanType stack,ExceptionInfo *exception)
435{
436#define AppendImageTag "Append/Image"
437
438 CacheView
439 *append_view;
440
441 Image
442 *append_image;
443
444 ImageType
445 image_type;
446
447 MagickBooleanType
448 homogeneous_colorspace,
449 status;
450
451 MagickOffsetType
452 n;
453
454 PixelTrait
455 alpha_trait;
456
457 RectangleInfo
458 geometry;
459
460 const Image
461 *next;
462
463 size_t
464 depth,
465 height,
466 number_images,
467 width;
468
469 ssize_t
470 x_offset,
471 y,
472 y_offset;
473
474 /*
475 Compute maximum area of appended area.
476 */
477 assert(images != (Image *) NULL);
478 assert(images->signature == MagickCoreSignature);
479 assert(exception != (ExceptionInfo *) NULL);
480 assert(exception->signature == MagickCoreSignature);
481 if (IsEventLogging() != MagickFalse)
482 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
483 alpha_trait=images->alpha_trait;
484 number_images=1;
485 width=images->columns;
486 height=images->rows;
487 depth=images->depth;
488 image_type=images->type;
489 homogeneous_colorspace=MagickTrue;
490 next=GetNextImageInList(images);
491 for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
492 {
493 if (next->depth > depth)
494 depth=next->depth;
495 if (next->type != images->type)
496 image_type=UndefinedType;
497 if (next->colorspace != images->colorspace)
498 homogeneous_colorspace=MagickFalse;
499 if (next->alpha_trait != UndefinedPixelTrait)
500 alpha_trait=BlendPixelTrait;
501 number_images++;
502 if (stack != MagickFalse)
503 {
504 if (next->columns > width)
505 width=next->columns;
506 height+=next->rows;
507 continue;
508 }
509 width+=next->columns;
510 if (next->rows > height)
511 height=next->rows;
512 }
513 /*
514 Append images.
515 */
516 append_image=CloneImage(images,width,height,MagickTrue,exception);
517 if (append_image == (Image *) NULL)
518 return((Image *) NULL);
519 if (image_type != BilevelType)
520 {
521 if (SetImageStorageClass(append_image,DirectClass,exception) == MagickFalse)
522 {
523 append_image=DestroyImage(append_image);
524 return((Image *) NULL);
525 }
526 if (homogeneous_colorspace == MagickFalse)
527 (void) SetImageColorspace(append_image,sRGBColorspace,exception);
528 }
529 append_image->depth=depth;
530 append_image->alpha_trait=alpha_trait;
531 append_image->page=images->page;
532 (void) SetImageBackgroundColor(append_image,exception);
533 status=MagickTrue;
534 x_offset=0;
535 y_offset=0;
536 next=images;
537 append_view=AcquireAuthenticCacheView(append_image,exception);
538 for (n=0; n < (MagickOffsetType) number_images; n++)
539 {
540 CacheView
541 *image_view;
542
543 MagickBooleanType
544 proceed;
545
546 SetGeometry(append_image,&geometry);
547 GravityAdjustGeometry(next->columns,next->rows,next->gravity,&geometry);
548 if (stack != MagickFalse)
549 x_offset-=geometry.x;
550 else
551 y_offset-=geometry.y;
552 image_view=AcquireVirtualCacheView(next,exception);
553#if defined(MAGICKCORE_OPENMP_SUPPORT)
554 #pragma omp parallel for schedule(static) shared(status) \
555 magick_number_threads(next,next,next->rows,2)
556#endif
557 for (y=0; y < (ssize_t) next->rows; y++)
558 {
559 MagickBooleanType
560 sync;
561
562 PixelInfo
563 pixel;
564
565 const Quantum
566 *magick_restrict p;
567
568 Quantum
569 *magick_restrict q;
570
571 ssize_t
572 x;
573
574 if (status == MagickFalse)
575 continue;
576 p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);
577 q=QueueCacheViewAuthenticPixels(append_view,x_offset,y+y_offset,
578 next->columns,1,exception);
579 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
580 {
581 status=MagickFalse;
582 continue;
583 }
584 GetPixelInfo(next,&pixel);
585 for (x=0; x < (ssize_t) next->columns; x++)
586 {
587 GetPixelInfoPixel(next,p,&pixel);
588 SetPixelViaPixelInfo(append_image,&pixel,q);
589 p+=(ptrdiff_t) GetPixelChannels(next);
590 q+=(ptrdiff_t) GetPixelChannels(append_image);
591 }
592 sync=SyncCacheViewAuthenticPixels(append_view,exception);
593 if (sync == MagickFalse)
594 status=MagickFalse;
595 }
596 image_view=DestroyCacheView(image_view);
597 if (stack == MagickFalse)
598 {
599 x_offset+=(ssize_t) next->columns;
600 y_offset=0;
601 }
602 else
603 {
604 x_offset=0;
605 y_offset+=(ssize_t) next->rows;
606 }
607 proceed=SetImageProgress(append_image,AppendImageTag,n,number_images);
608 if (proceed == MagickFalse)
609 break;
610 next=GetNextImageInList(next);
611 }
612 append_view=DestroyCacheView(append_view);
613 if (status == MagickFalse)
614 append_image=DestroyImage(append_image);
615 return(append_image);
616}
617␌
618/*
619%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
620% %
621% %
622% %
623% C a t c h I m a g e E x c e p t i o n %
624% %
625% %
626% %
627%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
628%
629% CatchImageException() returns if no exceptions are found in the image
630% sequence, otherwise it determines the most severe exception and reports
631% it as a warning or error depending on the severity.
632%
633% The format of the CatchImageException method is:
634%
635% ExceptionType CatchImageException(Image *image)
636%
637% A description of each parameter follows:
638%
639% o image: An image sequence.
640%
641*/
642MagickExport ExceptionType CatchImageException(Image *image)
643{
644 ExceptionInfo
645 *exception;
646
647 ExceptionType
648 severity;
649
650 assert(image != (const Image *) NULL);
651 assert(image->signature == MagickCoreSignature);
652 if (IsEventLogging() != MagickFalse)
653 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
654 exception=AcquireExceptionInfo();
655 CatchException(exception);
656 severity=exception->severity;
657 exception=DestroyExceptionInfo(exception);
658 return(severity);
659}
660␌
661/*
662%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
663% %
664% %
665% %
666% C l i p I m a g e P a t h %
667% %
668% %
669% %
670%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
671%
672% ClipImagePath() sets the image clip mask based any clipping path information
673% if it exists.
674%
675% The format of the ClipImagePath method is:
676%
677% MagickBooleanType ClipImagePath(Image *image,const char *pathname,
678% const MagickBooleanType inside,ExceptionInfo *exception)
679%
680% A description of each parameter follows:
681%
682% o image: the image.
683%
684% o pathname: name of clipping path resource. If name is preceded by #, use
685% clipping path numbered by name.
686%
687% o inside: if non-zero, later operations take effect inside clipping path.
688% Otherwise later operations take effect outside clipping path.
689%
690% o exception: return any errors or warnings in this structure.
691%
692*/
693
694MagickExport MagickBooleanType ClipImage(Image *image,ExceptionInfo *exception)
695{
696 return(ClipImagePath(image,"#1",MagickTrue,exception));
697}
698
699MagickExport MagickBooleanType ClipImagePath(Image *image,const char *pathname,
700 const MagickBooleanType inside,ExceptionInfo *exception)
701{
702#define ClipImagePathTag "ClipPath/Image"
703
704 char
705 *property,
706 *sanitized_pathname;
707
708 const char
709 *value;
710
711 Image
712 *clip_mask;
713
714 ImageInfo
715 *image_info;
716
717 assert(image != (const Image *) NULL);
718 assert(image->signature == MagickCoreSignature);
719 assert(pathname != NULL);
720 if (IsEventLogging() != MagickFalse)
721 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
722 property=AcquireString(pathname);
723 (void) FormatLocaleString(property,MagickPathExtent,"8BIM:1999,2998:%s",
724 pathname);
725 value=GetImageProperty(image,property,exception);
726 property=DestroyString(property);
727 if (value == (const char *) NULL)
728 {
729 ThrowFileException(exception,OptionError,"NoClipPathDefined",
730 image->filename);
731 return(MagickFalse);
732 }
733 image_info=AcquireImageInfo();
734 (void) CopyMagickString(image_info->filename,image->filename,
735 MagickPathExtent);
736 (void) ConcatenateMagickString(image_info->filename,"_",MagickPathExtent);
737 sanitized_pathname=SanitizeString(pathname);
738 (void) ConcatenateMagickString(image_info->filename,sanitized_pathname,
739 MagickPathExtent);
740 sanitized_pathname=DestroyString(sanitized_pathname);
741 clip_mask=BlobToImage(image_info,value,strlen(value),exception);
742 image_info=DestroyImageInfo(image_info);
743 if (clip_mask == (Image *) NULL)
744 return(MagickFalse);
745 if (clip_mask->storage_class == PseudoClass)
746 {
747 (void) SyncImage(clip_mask,exception);
748 if (SetImageStorageClass(clip_mask,DirectClass,exception) == MagickFalse)
749 return(MagickFalse);
750 }
751 if (inside != MagickFalse)
752 (void) NegateImage(clip_mask,MagickFalse,exception);
753 (void) FormatLocaleString(clip_mask->magick_filename,MagickPathExtent,
754 "8BIM:1999,2998:%s\nPS",pathname);
755 (void) SetImageMask(image,WritePixelMask,clip_mask,exception);
756 image->mask_trait=UpdatePixelTrait;
757 clip_mask=DestroyImage(clip_mask);
758 return(MagickTrue);
759}
760␌
761/*
762%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
763% %
764% %
765% %
766% C l o n e I m a g e %
767% %
768% %
769% %
770%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
771%
772% CloneImage() copies an image and returns the copy as a new image object.
773%
774% If the specified columns and rows is 0, an exact copy of the image is
775% returned, otherwise the pixel data is undefined and must be initialized
776% with the QueueAuthenticPixels() and SyncAuthenticPixels() methods. On
777% failure, a NULL image is returned and exception describes the reason for the
778% failure.
779%
780% The format of the CloneImage method is:
781%
782% Image *CloneImage(const Image *image,const size_t columns,
783% const size_t rows,const MagickBooleanType orphan,
784% ExceptionInfo *exception)
785%
786% A description of each parameter follows:
787%
788% o image: the image.
789%
790% o columns: the number of columns in the cloned image.
791%
792% o rows: the number of rows in the cloned image.
793%
794% o detach: With a value other than 0, the cloned image is detached from
795% its parent I/O stream.
796%
797% o exception: return any errors or warnings in this structure.
798%
799*/
800MagickExport Image *CloneImage(const Image *image,const size_t columns,
801 const size_t rows,const MagickBooleanType detach,ExceptionInfo *exception)
802{
803 double
804 scale_x,
805 scale_y;
806
807 Image
808 *clone_image;
809
810 size_t
811 length;
812
813 /*
814 Clone the image.
815 */
816 assert(image != (const Image *) NULL);
817 assert(image->signature == MagickCoreSignature);
818 assert(exception != (ExceptionInfo *) NULL);
819 assert(exception->signature == MagickCoreSignature);
820 if (IsEventLogging() != MagickFalse)
821 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
822 if ((image->columns == 0) || (image->rows == 0))
823 {
824 (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
825 "NegativeOrZeroImageSize","`%s'",image->filename);
826 return((Image *) NULL);
827 }
828 clone_image=(Image *) AcquireCriticalMemory(sizeof(*clone_image));
829 (void) memset(clone_image,0,sizeof(*clone_image));
830 clone_image->signature=MagickCoreSignature;
831 clone_image->storage_class=image->storage_class;
832 clone_image->number_channels=image->number_channels;
833 clone_image->number_meta_channels=image->number_meta_channels;
834 clone_image->metacontent_extent=image->metacontent_extent;
835 clone_image->colorspace=image->colorspace;
836 clone_image->alpha_trait=image->alpha_trait;
837 clone_image->channels=image->channels;
838 clone_image->mask_trait=image->mask_trait;
839 clone_image->columns=image->columns;
840 clone_image->rows=image->rows;
841 clone_image->dither=image->dither;
842 clone_image->image_info=CloneImageInfo(image->image_info);
843 (void) CloneImageProfiles(clone_image,image);
844 (void) CloneImageProperties(clone_image,image);
845 (void) CloneImageArtifacts(clone_image,image);
846 GetTimerInfo(&clone_image->timer);
847 if (image->ascii85 != (void *) NULL)
848 Ascii85Initialize(clone_image);
849 clone_image->extent=image->extent;
850 clone_image->magick_columns=image->magick_columns;
851 clone_image->magick_rows=image->magick_rows;
852 clone_image->type=image->type;
853 clone_image->channel_mask=image->channel_mask;
854 clone_image->channel_map=ClonePixelChannelMap(image->channel_map);
855 (void) CopyMagickString(clone_image->magick_filename,image->magick_filename,
856 MagickPathExtent);
857 (void) CopyMagickString(clone_image->magick,image->magick,MagickPathExtent);
858 (void) CopyMagickString(clone_image->filename,image->filename,
859 MagickPathExtent);
860 clone_image->progress_monitor=image->progress_monitor;
861 clone_image->client_data=image->client_data;
862 clone_image->reference_count=1;
863 clone_image->next=image->next;
864 clone_image->previous=image->previous;
865 clone_image->list=NewImageList();
866 if (detach == MagickFalse)
867 clone_image->blob=ReferenceBlob(image->blob);
868 else
869 {
870 clone_image->next=NewImageList();
871 clone_image->previous=NewImageList();
872 clone_image->blob=CloneBlobInfo((BlobInfo *) NULL);
873 }
874 clone_image->ping=image->ping;
875 clone_image->timestamp=image->timestamp;
876 clone_image->ttl=image->ttl;
877 clone_image->debug=image->debug;
878 clone_image->semaphore=AcquireSemaphoreInfo();
879 if (image->colormap != (PixelInfo *) NULL)
880 {
881 /*
882 Allocate and copy the image colormap.
883 */
884 clone_image->colors=image->colors;
885 length=(size_t) image->colors;
886 clone_image->colormap=(PixelInfo *) AcquireQuantumMemory(length+1,
887 sizeof(*clone_image->colormap));
888 if (clone_image->colormap == (PixelInfo *) NULL)
889 {
890 clone_image=DestroyImage(clone_image);
891 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
892 }
893 (void) memcpy(clone_image->colormap,image->colormap,length*
894 sizeof(*clone_image->colormap));
895 }
896 if ((columns == 0) || (rows == 0))
897 {
898 if (image->montage != (char *) NULL)
899 (void) CloneString(&clone_image->montage,image->montage);
900 if (image->directory != (char *) NULL)
901 (void) CloneString(&clone_image->directory,image->directory);
902 clone_image->cache=ReferencePixelCache(image->cache);
903 return(clone_image);
904 }
905 scale_x=1.0;
906 scale_y=1.0;
907 if (image->columns != 0)
908 scale_x=(double) columns/(double) image->columns;
909 if (image->rows != 0)
910 scale_y=(double) rows/(double) image->rows;
911 clone_image->page.width=(size_t) CastDoubleToSsizeT(floor(scale_x*
912 image->page.width+0.5));
913 clone_image->page.height=(size_t) CastDoubleToSsizeT(floor(scale_y*
914 image->page.height+0.5));
915 if (MagickAbsoluteValue(scale_x-scale_y) < 2.0)
916 scale_x=scale_y=MagickMin(scale_x,scale_y);
917 clone_image->page.x=CastDoubleToSsizeT(ceil(scale_x*image->page.x-0.5));
918 clone_image->tile_offset.x=CastDoubleToSsizeT(ceil(scale_x*
919 image->tile_offset.x-0.5));
920 clone_image->page.y=CastDoubleToSsizeT(ceil(scale_y*image->page.y-0.5));
921 clone_image->tile_offset.y=CastDoubleToSsizeT(ceil(scale_y*
922 image->tile_offset.y-0.5));
923 clone_image->cache=ClonePixelCache(image->cache);
924 if (SetImageExtent(clone_image,columns,rows,exception) == MagickFalse)
925 clone_image=DestroyImage(clone_image);
926 return(clone_image);
927}
928␌
929/*
930%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
931% %
932% %
933% %
934% C l o n e I m a g e I n f o %
935% %
936% %
937% %
938%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
939%
940% CloneImageInfo() makes a copy of the given image info structure. If
941% NULL is specified, a new image info structure is created initialized to
942% default values.
943%
944% The format of the CloneImageInfo method is:
945%
946% ImageInfo *CloneImageInfo(const ImageInfo *image_info)
947%
948% A description of each parameter follows:
949%
950% o image_info: the image info.
951%
952*/
953MagickExport ImageInfo *CloneImageInfo(const ImageInfo *image_info)
954{
955 ImageInfo
956 *clone_info;
957
958 clone_info=AcquireImageInfo();
959 if (image_info == (ImageInfo *) NULL)
960 return(clone_info);
961 clone_info->compression=image_info->compression;
962 clone_info->temporary=image_info->temporary;
963 clone_info->adjoin=image_info->adjoin;
964 clone_info->antialias=image_info->antialias;
965 clone_info->scene=image_info->scene;
966 clone_info->number_scenes=image_info->number_scenes;
967 clone_info->depth=image_info->depth;
968 if (image_info->size != (char *) NULL)
969 (void) CloneString(&clone_info->size,image_info->size);
970 if (image_info->extract != (char *) NULL)
971 (void) CloneString(&clone_info->extract,image_info->extract);
972 if (image_info->scenes != (char *) NULL)
973 (void) CloneString(&clone_info->scenes,image_info->scenes);
974 if (image_info->page != (char *) NULL)
975 (void) CloneString(&clone_info->page,image_info->page);
976 clone_info->interlace=image_info->interlace;
977 clone_info->endian=image_info->endian;
978 clone_info->units=image_info->units;
979 clone_info->quality=image_info->quality;
980 if (image_info->sampling_factor != (char *) NULL)
981 (void) CloneString(&clone_info->sampling_factor,
982 image_info->sampling_factor);
983 if (image_info->server_name != (char *) NULL)
984 (void) CloneString(&clone_info->server_name,image_info->server_name);
985 if (image_info->font != (char *) NULL)
986 (void) CloneString(&clone_info->font,image_info->font);
987 if (image_info->texture != (char *) NULL)
988 (void) CloneString(&clone_info->texture,image_info->texture);
989 if (image_info->density != (char *) NULL)
990 (void) CloneString(&clone_info->density,image_info->density);
991 clone_info->pointsize=image_info->pointsize;
992 clone_info->fuzz=image_info->fuzz;
993 clone_info->matte_color=image_info->matte_color;
994 clone_info->background_color=image_info->background_color;
995 clone_info->border_color=image_info->border_color;
996 clone_info->transparent_color=image_info->transparent_color;
997 clone_info->dither=image_info->dither;
998 clone_info->monochrome=image_info->monochrome;
999 clone_info->colorspace=image_info->colorspace;
1000 clone_info->type=image_info->type;
1001 clone_info->orientation=image_info->orientation;
1002 clone_info->ping=image_info->ping;
1003 clone_info->verbose=image_info->verbose;
1004 clone_info->progress_monitor=image_info->progress_monitor;
1005 clone_info->client_data=image_info->client_data;
1006 clone_info->cache=image_info->cache;
1007 if (image_info->cache != (void *) NULL)
1008 clone_info->cache=ReferencePixelCache(image_info->cache);
1009 if (image_info->profile != (void *) NULL)
1010 clone_info->profile=(void *) CloneStringInfo((StringInfo *)
1011 image_info->profile);
1012 SetImageInfoFile(clone_info,image_info->file);
1013 SetImageInfoBlob(clone_info,image_info->blob,image_info->length);
1014 clone_info->stream=image_info->stream;
1015 clone_info->custom_stream=image_info->custom_stream;
1016 (void) CopyMagickString(clone_info->magick,image_info->magick,
1017 MagickPathExtent);
1018 (void) CopyMagickString(clone_info->unique,image_info->unique,
1019 MagickPathExtent);
1020 (void) CopyMagickString(clone_info->filename,image_info->filename,
1021 MagickPathExtent);
1022 clone_info->channel=image_info->channel;
1023 (void) CloneImageOptions(clone_info,image_info);
1024 clone_info->debug=image_info->debug;
1025 clone_info->signature=image_info->signature;
1026 return(clone_info);
1027}
1028␌
1029/*
1030%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1031% %
1032% %
1033% %
1034% C o p y I m a g e P i x e l s %
1035% %
1036% %
1037% %
1038%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1039%
1040% CopyImagePixels() copies pixels from the source image as defined by the
1041% geometry the destination image at the specified offset.
1042%
1043% The format of the CopyImagePixels method is:
1044%
1045% MagickBooleanType CopyImagePixels(Image *image,const Image *source_image,
1046% const RectangleInfo *geometry,const OffsetInfo *offset,
1047% ExceptionInfo *exception)
1048%
1049% A description of each parameter follows:
1050%
1051% o image: the destination image.
1052%
1053% o source_image: the source image.
1054%
1055% o geometry: define the dimensions of the source pixel rectangle.
1056%
1057% o offset: define the offset in the destination image.
1058%
1059% o exception: return any errors or warnings in this structure.
1060%
1061*/
1062MagickExport MagickBooleanType CopyImagePixels(Image *image,
1063 const Image *source_image,const RectangleInfo *geometry,
1064 const OffsetInfo *offset,ExceptionInfo *exception)
1065{
1066#define CopyImageTag "Copy/Image"
1067
1068 CacheView
1069 *image_view,
1070 *source_view;
1071
1072 MagickBooleanType
1073 status;
1074
1075 MagickOffsetType
1076 progress;
1077
1078 ssize_t
1079 y;
1080
1081 assert(image != (Image *) NULL);
1082 assert(source_image != (Image *) NULL);
1083 assert(geometry != (RectangleInfo *) NULL);
1084 assert(offset != (OffsetInfo *) NULL);
1085 if (IsEventLogging() != MagickFalse)
1086 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1087 if ((offset->x < 0) || (offset->y < 0) ||
1088 ((offset->x+(ssize_t) geometry->width) > (ssize_t) image->columns) ||
1089 ((offset->y+(ssize_t) geometry->height) > (ssize_t) image->rows))
1090 ThrowBinaryException(OptionError,"GeometryDoesNotContainImage",
1091 image->filename);
1092 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1093 return(MagickFalse);
1094 /*
1095 Copy image pixels.
1096 */
1097 status=MagickTrue;
1098 progress=0;
1099 source_view=AcquireVirtualCacheView(source_image,exception);
1100 image_view=AcquireAuthenticCacheView(image,exception);
1101#if defined(MAGICKCORE_OPENMP_SUPPORT)
1102 #pragma omp parallel for schedule(static) shared(progress,status) \
1103 magick_number_threads(image,source_image,geometry->height,2)
1104#endif
1105 for (y=0; y < (ssize_t) geometry->height; y++)
1106 {
1107 MagickBooleanType
1108 sync;
1109
1110 const Quantum
1111 *magick_restrict p;
1112
1113 ssize_t
1114 x;
1115
1116 Quantum
1117 *magick_restrict q;
1118
1119 if (status == MagickFalse)
1120 continue;
1121 p=GetCacheViewVirtualPixels(source_view,geometry->x,y+geometry->y,
1122 geometry->width,1,exception);
1123 q=QueueCacheViewAuthenticPixels(image_view,offset->x,y+offset->y,
1124 geometry->width,1,exception);
1125 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1126 {
1127 status=MagickFalse;
1128 continue;
1129 }
1130 for (x=0; x < (ssize_t) geometry->width; x++)
1131 {
1132 ssize_t
1133 i;
1134
1135 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1136 {
1137 PixelChannel channel = GetPixelChannelChannel(image,i);
1138 PixelTrait traits = GetPixelChannelTraits(image,channel);
1139 PixelTrait source_traits=GetPixelChannelTraits(source_image,channel);
1140 if ((traits == UndefinedPixelTrait) ||
1141 ((traits & UpdatePixelTrait) == 0) ||
1142 (source_traits == UndefinedPixelTrait))
1143 continue;
1144 SetPixelChannel(image,channel,p[i],q);
1145 }
1146 p+=(ptrdiff_t) GetPixelChannels(source_image);
1147 q+=(ptrdiff_t) GetPixelChannels(image);
1148 }
1149 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1150 if (sync == MagickFalse)
1151 status=MagickFalse;
1152 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1153 {
1154 MagickBooleanType
1155 proceed;
1156
1157#if defined(MAGICKCORE_OPENMP_SUPPORT)
1158 #pragma omp atomic
1159#endif
1160 progress++;
1161 proceed=SetImageProgress(image,CopyImageTag,progress,image->rows);
1162 if (proceed == MagickFalse)
1163 status=MagickFalse;
1164 }
1165 }
1166 source_view=DestroyCacheView(source_view);
1167 image_view=DestroyCacheView(image_view);
1168 return(status);
1169}
1170␌
1171/*
1172%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1173% %
1174% %
1175% %
1176% D e s t r o y I m a g e %
1177% %
1178% %
1179% %
1180%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1181%
1182% DestroyImage() dereferences an image, deallocating memory associated with
1183% the image if the reference count becomes zero.
1184%
1185% The format of the DestroyImage method is:
1186%
1187% Image *DestroyImage(Image *image)
1188%
1189% A description of each parameter follows:
1190%
1191% o image: the image.
1192%
1193*/
1194MagickExport Image *DestroyImage(Image *image)
1195{
1196 MagickBooleanType
1197 destroy;
1198
1199 /*
1200 Dereference image.
1201 */
1202 assert(image != (Image *) NULL);
1203 assert(image->signature == MagickCoreSignature);
1204 if (IsEventLogging() != MagickFalse)
1205 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1206 destroy=MagickFalse;
1207 LockSemaphoreInfo(image->semaphore);
1208 image->reference_count--;
1209 if (image->reference_count == 0)
1210 destroy=MagickTrue;
1211 UnlockSemaphoreInfo(image->semaphore);
1212 if (destroy == MagickFalse)
1213 return((Image *) NULL);
1214 /*
1215 Destroy image.
1216 */
1217 DestroyImagePixels(image);
1218 image->channel_map=DestroyPixelChannelMap(image->channel_map);
1219 if (image->montage != (char *) NULL)
1220 image->montage=DestroyString(image->montage);
1221 if (image->directory != (char *) NULL)
1222 image->directory=DestroyString(image->directory);
1223 if (image->colormap != (PixelInfo *) NULL)
1224 image->colormap=(PixelInfo *) RelinquishMagickMemory(image->colormap);
1225 if (image->geometry != (char *) NULL)
1226 image->geometry=DestroyString(image->geometry);
1227 DestroyImageProfiles(image);
1228 DestroyImageProperties(image);
1229 DestroyImageArtifacts(image);
1230 if (image->ascii85 != (Ascii85Info *) NULL)
1231 image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85);
1232 if (image->image_info != (ImageInfo *) NULL)
1233 image->image_info=DestroyImageInfo(image->image_info);
1234 DestroyBlob(image);
1235 if (image->semaphore != (SemaphoreInfo *) NULL)
1236 RelinquishSemaphoreInfo(&image->semaphore);
1237 image->signature=(~MagickCoreSignature);
1238 image=(Image *) RelinquishMagickMemory(image);
1239 return(image);
1240}
1241␌
1242/*
1243%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1244% %
1245% %
1246% %
1247% D e s t r o y I m a g e I n f o %
1248% %
1249% %
1250% %
1251%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1252%
1253% DestroyImageInfo() deallocates memory associated with an ImageInfo
1254% structure.
1255%
1256% The format of the DestroyImageInfo method is:
1257%
1258% ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1259%
1260% A description of each parameter follows:
1261%
1262% o image_info: the image info.
1263%
1264*/
1265MagickExport ImageInfo *DestroyImageInfo(ImageInfo *image_info)
1266{
1267 assert(image_info != (ImageInfo *) NULL);
1268 assert(image_info->signature == MagickCoreSignature);
1269 if (IsEventLogging() != MagickFalse)
1270 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1271 image_info->filename);
1272 if (image_info->size != (char *) NULL)
1273 image_info->size=DestroyString(image_info->size);
1274 if (image_info->extract != (char *) NULL)
1275 image_info->extract=DestroyString(image_info->extract);
1276 if (image_info->scenes != (char *) NULL)
1277 image_info->scenes=DestroyString(image_info->scenes);
1278 if (image_info->page != (char *) NULL)
1279 image_info->page=DestroyString(image_info->page);
1280 if (image_info->sampling_factor != (char *) NULL)
1281 image_info->sampling_factor=DestroyString(
1282 image_info->sampling_factor);
1283 if (image_info->server_name != (char *) NULL)
1284 image_info->server_name=DestroyString(
1285 image_info->server_name);
1286 if (image_info->font != (char *) NULL)
1287 image_info->font=DestroyString(image_info->font);
1288 if (image_info->texture != (char *) NULL)
1289 image_info->texture=DestroyString(image_info->texture);
1290 if (image_info->density != (char *) NULL)
1291 image_info->density=DestroyString(image_info->density);
1292 if (image_info->cache != (void *) NULL)
1293 image_info->cache=DestroyPixelCache(image_info->cache);
1294 if (image_info->profile != (StringInfo *) NULL)
1295 image_info->profile=(void *) DestroyStringInfo((StringInfo *)
1296 image_info->profile);
1297 DestroyImageOptions(image_info);
1298 image_info->signature=(~MagickCoreSignature);
1299 image_info=(ImageInfo *) RelinquishMagickMemory(image_info);
1300 return(image_info);
1301}
1302␌
1303/*
1304%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1305% %
1306% %
1307% %
1308+ D i s a s s o c i a t e I m a g e S t r e a m %
1309% %
1310% %
1311% %
1312%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1313%
1314% DisassociateImageStream() disassociates the image stream. It checks if the
1315% blob of the specified image is referenced by other images. If the reference
1316% count is higher then 1 a new blob is assigned to the specified image.
1317%
1318% The format of the DisassociateImageStream method is:
1319%
1320% void DisassociateImageStream(const Image *image)
1321%
1322% A description of each parameter follows:
1323%
1324% o image: the image.
1325%
1326*/
1327MagickExport void DisassociateImageStream(Image *image)
1328{
1329 assert(image != (Image *) NULL);
1330 assert(image->signature == MagickCoreSignature);
1331 if (IsEventLogging() != MagickFalse)
1332 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1333 DisassociateBlob(image);
1334}
1335␌
1336/*
1337%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1338% %
1339% %
1340% %
1341% G e t I m a g e I n f o %
1342% %
1343% %
1344% %
1345%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1346%
1347% GetImageInfo() initializes image_info to default values.
1348%
1349% The format of the GetImageInfo method is:
1350%
1351% void GetImageInfo(ImageInfo *image_info)
1352%
1353% A description of each parameter follows:
1354%
1355% o image_info: the image info.
1356%
1357*/
1358MagickExport void GetImageInfo(ImageInfo *image_info)
1359{
1360 char
1361 *synchronize;
1362
1363 /*
1364 File and image dimension members.
1365 */
1366 assert(image_info != (ImageInfo *) NULL);
1367 if (IsEventLogging() != MagickFalse)
1368 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1369 (void) memset(image_info,0,sizeof(*image_info));
1370 image_info->adjoin=MagickTrue;
1371 image_info->interlace=NoInterlace;
1372 image_info->channel=AllChannels;
1373 image_info->quality=UndefinedCompressionQuality;
1374 image_info->antialias=MagickTrue;
1375 image_info->dither=MagickTrue;
1376 image_info->depth=0;
1377 synchronize=GetEnvironmentValue("MAGICK_SYNCHRONIZE");
1378 if (synchronize != (const char *) NULL)
1379 {
1380 image_info->synchronize=IsStringTrue(synchronize);
1381 synchronize=DestroyString(synchronize);
1382 }
1383 GetPixelInfoRGBA(BackgroundColorRGBA,&image_info->background_color);
1384 GetPixelInfoRGBA(BorderColorRGBA,&image_info->border_color);
1385 GetPixelInfoRGBA(MatteColorRGBA,&image_info->matte_color);
1386 GetPixelInfoRGBA(TransparentColorRGBA,&image_info->transparent_color);
1387 image_info->debug=(GetLogEventMask() & ImageEvent) != 0 ? MagickTrue :
1388 MagickFalse;
1389 image_info->signature=MagickCoreSignature;
1390}
1391␌
1392/*
1393%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1394% %
1395% %
1396% %
1397% G e t I m a g e I n f o F i l e %
1398% %
1399% %
1400% %
1401%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1402%
1403% GetImageInfoFile() returns the image info file member.
1404%
1405% The format of the GetImageInfoFile method is:
1406%
1407% FILE *GetImageInfoFile(const ImageInfo *image_info)
1408%
1409% A description of each parameter follows:
1410%
1411% o image_info: the image info.
1412%
1413*/
1414MagickExport FILE *GetImageInfoFile(const ImageInfo *image_info)
1415{
1416 return(image_info->file);
1417}
1418␌
1419/*
1420%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1421% %
1422% %
1423% %
1424% G e t I m a g e M a s k %
1425% %
1426% %
1427% %
1428%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1429%
1430% GetImageMask() returns the mask associated with the image.
1431%
1432% The format of the GetImageMask method is:
1433%
1434% Image *GetImageMask(const Image *image,const PixelMask type,
1435% ExceptionInfo *exception)
1436%
1437% A description of each parameter follows:
1438%
1439% o image: the image.
1440%
1441% o type: the mask type, ReadPixelMask or WritePixelMask.
1442%
1443*/
1444MagickExport Image *GetImageMask(const Image *image,const PixelMask type,
1445 ExceptionInfo *exception)
1446{
1447 CacheView
1448 *mask_view,
1449 *image_view;
1450
1451 Image
1452 *mask_image;
1453
1454 MagickBooleanType
1455 status;
1456
1457 ssize_t
1458 y;
1459
1460 /*
1461 Get image mask.
1462 */
1463 assert(image != (Image *) NULL);
1464 assert(image->signature == MagickCoreSignature);
1465 if (IsEventLogging() != MagickFalse)
1466 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1467 switch (type)
1468 {
1469 case ReadPixelMask:
1470 {
1471 if ((image->channels & ReadMaskChannel) == 0)
1472 return((Image *) NULL);
1473 break;
1474 }
1475 case WritePixelMask:
1476 {
1477 if ((image->channels & WriteMaskChannel) == 0)
1478 return((Image *) NULL);
1479 break;
1480 }
1481 default:
1482 {
1483 if ((image->channels & CompositeMaskChannel) == 0)
1484 return((Image *) NULL);
1485 break;
1486 }
1487 }
1488 mask_image=AcquireImage((ImageInfo *) NULL,exception);
1489 status=SetImageExtent(mask_image,image->columns,image->rows,exception);
1490 if (status == MagickFalse)
1491 return(DestroyImage(mask_image));
1492 status=MagickTrue;
1493 mask_image->alpha_trait=UndefinedPixelTrait;
1494 (void) SetImageColorspace(mask_image,GRAYColorspace,exception);
1495 image_view=AcquireVirtualCacheView(image,exception);
1496 mask_view=AcquireAuthenticCacheView(mask_image,exception);
1497#if defined(MAGICKCORE_OPENMP_SUPPORT)
1498 #pragma omp parallel for schedule(static) shared(status) \
1499 magick_number_threads(image,image,image->rows,2)
1500#endif
1501 for (y=0; y < (ssize_t) image->rows; y++)
1502 {
1503 const Quantum
1504 *magick_restrict p;
1505
1506 Quantum
1507 *magick_restrict q;
1508
1509 ssize_t
1510 x;
1511
1512 if (status == MagickFalse)
1513 continue;
1514 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1515 q=GetCacheViewAuthenticPixels(mask_view,0,y,mask_image->columns,1,
1516 exception);
1517 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
1518 {
1519 status=MagickFalse;
1520 continue;
1521 }
1522 for (x=0; x < (ssize_t) image->columns; x++)
1523 {
1524 switch (type)
1525 {
1526 case ReadPixelMask:
1527 {
1528 SetPixelGray(mask_image,GetPixelReadMask(image,p),q);
1529 break;
1530 }
1531 case WritePixelMask:
1532 {
1533 SetPixelGray(mask_image,GetPixelWriteMask(image,p),q);
1534 break;
1535 }
1536 default:
1537 {
1538 SetPixelGray(mask_image,GetPixelCompositeMask(image,p),q);
1539 break;
1540 }
1541 }
1542 p+=(ptrdiff_t) GetPixelChannels(image);
1543 q+=(ptrdiff_t) GetPixelChannels(mask_image);
1544 }
1545 if (SyncCacheViewAuthenticPixels(mask_view,exception) == MagickFalse)
1546 status=MagickFalse;
1547 }
1548 mask_view=DestroyCacheView(mask_view);
1549 image_view=DestroyCacheView(image_view);
1550 if (status == MagickFalse)
1551 mask_image=DestroyImage(mask_image);
1552 return(mask_image);
1553}
1554␌
1555/*
1556%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1557% %
1558% %
1559% %
1560+ G e t I m a g e R e f e r e n c e C o u n t %
1561% %
1562% %
1563% %
1564%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1565%
1566% GetImageReferenceCount() returns the image reference count.
1567%
1568% The format of the GetReferenceCount method is:
1569%
1570% ssize_t GetImageReferenceCount(Image *image)
1571%
1572% A description of each parameter follows:
1573%
1574% o image: the image.
1575%
1576*/
1577MagickExport ssize_t GetImageReferenceCount(Image *image)
1578{
1579 ssize_t
1580 reference_count;
1581
1582 assert(image != (Image *) NULL);
1583 assert(image->signature == MagickCoreSignature);
1584 if (IsEventLogging() != MagickFalse)
1585 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1586 LockSemaphoreInfo(image->semaphore);
1587 reference_count=image->reference_count;
1588 UnlockSemaphoreInfo(image->semaphore);
1589 return(reference_count);
1590}
1591␌
1592/*
1593%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1594% %
1595% %
1596% %
1597% G e t I m a g e V i r t u a l P i x e l M e t h o d %
1598% %
1599% %
1600% %
1601%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1602%
1603% GetImageVirtualPixelMethod() gets the "virtual pixels" method for the
1604% image. A virtual pixel is any pixel access that is outside the boundaries
1605% of the image cache.
1606%
1607% The format of the GetImageVirtualPixelMethod() method is:
1608%
1609% VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1610%
1611% A description of each parameter follows:
1612%
1613% o image: the image.
1614%
1615*/
1616MagickExport VirtualPixelMethod GetImageVirtualPixelMethod(const Image *image)
1617{
1618 assert(image != (Image *) NULL);
1619 assert(image->signature == MagickCoreSignature);
1620 if (IsEventLogging() != MagickFalse)
1621 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1622 return(GetPixelCacheVirtualMethod(image));
1623}
1624␌
1625/*
1626%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1627% %
1628% %
1629% %
1630% I n t e r p r e t I m a g e F i l e n a m e %
1631% %
1632% %
1633% %
1634%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1635%
1636% InterpretImageFilename() interprets embedded characters in an image filename.
1637% The filename length is returned.
1638%
1639% The format of the InterpretImageFilename method is:
1640%
1641% size_t InterpretImageFilename(const ImageInfo *image_info,Image *image,
1642% const char *format,int value,char *filename,ExceptionInfo *exception)
1643%
1644% A description of each parameter follows.
1645%
1646% o image_info: the image info.
1647%
1648% o image: the image.
1649%
1650% o format: A filename describing the format to use to write the numeric
1651% argument. Only the first numeric format identifier is replaced.
1652%
1653% o value: Numeric value to substitute into format filename.
1654%
1655% o filename: return the formatted filename in this character buffer.
1656%
1657% o exception: return any errors or warnings in this structure.
1658%
1659*/
1660
1661static inline MagickBooleanType IsValidFormatSpecifier(const char *start,
1662 const char *end)
1663{
1664 char
1665 specifier = end[-1];
1666
1667 size_t
1668 length = end-start;
1669
1670 /*
1671 Is this a valid format specifier?
1672 */
1673 if ((specifier != 'd') && (specifier != 'x') && (specifier != 'o'))
1674 return(MagickFalse);
1675 if ((length == 1) && (*start == specifier))
1676 return(MagickTrue);
1677 if (length >= 2)
1678 {
1679 size_t
1680 i = 0;
1681
1682 if (*start == '0')
1683 {
1684 if ((length >= 3) && (start[1] == '0'))
1685 return(MagickFalse);
1686 i=1;
1687 }
1688 for ( ; i < (length-1); i++)
1689 if (isdigit((int) ((unsigned char) start[i])) == 0)
1690 return(MagickFalse);
1691 return(MagickTrue);
1692 }
1693 return(MagickFalse);
1694}
1695
1696MagickExport size_t InterpretImageFilename(const ImageInfo *image_info,
1697 Image *image,const char *format,int value,char *filename,
1698 ExceptionInfo *exception)
1699{
1700 char
1701 *p = filename,
1702 pattern[MagickPathExtent];
1703
1704 const char
1705 *cursor = format;
1706
1707 assert(format != (const char *) NULL);
1708 assert(filename != (char *) NULL);
1709 if (IsStringTrue(GetImageOption(image_info,"filename:literal")) != MagickFalse)
1710 {
1711 (void) CopyMagickString(filename,format,MagickPathExtent);
1712 return(strlen(filename));
1713 }
1714 while ((*cursor != '\0') && ((p-filename) < ((ssize_t) MagickPathExtent-1)))
1715 {
1716 const char
1717 *specifier_start,
1718 *start;
1719
1720 if (*cursor != '%')
1721 {
1722 *p++=(*cursor++);
1723 continue;
1724 }
1725 start=cursor++; /* Skip '%' */
1726 if (*cursor == '%')
1727 {
1728 *p++='%';
1729 cursor++;
1730 continue;
1731 }
1732 specifier_start=cursor;
1733 while (isdigit((int) ((unsigned char) *cursor)) != 0)
1734 cursor++;
1735 if ((*cursor == 'd') || (*cursor == 'o') || (*cursor == 'x'))
1736 {
1737 const char
1738 *specifier_end = cursor+1;
1739
1740 if (IsValidFormatSpecifier(specifier_start,specifier_end) != MagickFalse)
1741 {
1742 char
1743 format_specifier[MagickPathExtent];
1744
1745 size_t
1746 length = cursor-specifier_start,
1747 pattern_length;
1748
1749 ssize_t
1750 count;
1751
1752 (void) snprintf(format_specifier,sizeof(format_specifier),
1753 "%%%.*s%c",(int) length,specifier_start,*cursor);
1754 count=FormatLocaleString(pattern,sizeof(pattern),format_specifier,
1755 value);
1756 pattern_length=strlen(pattern);
1757 if ((count <= 0) || ((size_t) count != pattern_length))
1758 return(0);
1759 if ((p-filename+pattern_length) >= MagickPathExtent)
1760 return(0);
1761 (void) CopyMagickString(p,pattern,MagickPathExtent-(p-filename));
1762 p+=pattern_length;
1763 cursor++;
1764 continue;
1765 }
1766 else
1767 {
1768 /*
1769 Invalid specifier — treat as literal.
1770 */
1771 cursor=start;
1772 *p++=(*cursor++);
1773 continue;
1774 }
1775 }
1776 if (*cursor == '[')
1777 {
1778 const char
1779 *end = strchr(cursor,']'),
1780 *option = (const char *) NULL;
1781
1782 size_t
1783 extent,
1784 option_length;
1785
1786 if (end == (const char *) NULL)
1787 continue;
1788 extent=(size_t) (end-cursor-1);
1789 if (extent >= sizeof(pattern))
1790 continue;
1791 (void) CopyMagickString(pattern,cursor+1,extent+1);
1792 pattern[extent]='\0';
1793 if (image != NULL)
1794 {
1795 option=GetImageProperty(image,pattern,exception);
1796 if (option == (const char *) NULL)
1797 option=GetImageArtifact(image,pattern);
1798 }
1799 if ((option == (const char *) NULL) &&
1800 (image_info != (ImageInfo *) NULL))
1801 option=GetImageOption(image_info,pattern);
1802 if (option == (const char *) NULL)
1803 continue;
1804 option_length=strlen(option);
1805 if ((p-filename+option_length) >= MagickPathExtent)
1806 return(0);
1807 (void) CopyMagickString(p,option,MagickPathExtent-(p-filename));
1808 p+=option_length;
1809 cursor=end+1;
1810 continue;
1811 }
1812 /*
1813 Invalid or unsupported specifier — treat as literal.
1814 */
1815 cursor=start;
1816 if ((p-filename+1) >= MagickPathExtent)
1817 return(0);
1818 *p++=(*cursor++);
1819 }
1820 *p='\0';
1821 return(strlen(filename));
1822}
1823␌
1824/*
1825%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1826% %
1827% %
1828% %
1829% I s H i g h D y n a m i c R a n g e I m a g e %
1830% %
1831% %
1832% %
1833%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1834%
1835% IsHighDynamicRangeImage() returns MagickTrue if any pixel component is
1836% non-integer or exceeds the bounds of the quantum depth (e.g. for Q16
1837% 0..65535.
1838%
1839% The format of the IsHighDynamicRangeImage method is:
1840%
1841% MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1842% ExceptionInfo *exception)
1843%
1844% A description of each parameter follows:
1845%
1846% o image: the image.
1847%
1848% o exception: return any errors or warnings in this structure.
1849%
1850*/
1851MagickExport MagickBooleanType IsHighDynamicRangeImage(const Image *image,
1852 ExceptionInfo *exception)
1853{
1854#if !defined(MAGICKCORE_HDRI_SUPPORT)
1855 (void) image;
1856 (void) exception;
1857 return(MagickFalse);
1858#else
1859 CacheView
1860 *image_view;
1861
1862 MagickBooleanType
1863 hdri = MagickFalse;
1864
1865 ssize_t
1866 y;
1867
1868 assert(image != (Image *) NULL);
1869 assert(image->signature == MagickCoreSignature);
1870 if (IsEventLogging() != MagickFalse)
1871 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1872 image_view=AcquireVirtualCacheView(image,exception);
1873#if defined(MAGICKCORE_OPENMP_SUPPORT)
1874 #pragma omp parallel for schedule(static) shared(hdri) \
1875 magick_number_threads(image,image,image->rows,2)
1876#endif
1877 for (y=0; y < (ssize_t) image->rows; y++)
1878 {
1879 const Quantum
1880 *p;
1881
1882 ssize_t
1883 x;
1884
1885 if (hdri != MagickFalse)
1886 continue;
1887 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
1888 if (p == (const Quantum *) NULL)
1889 continue;
1890 for (x=0; x < (ssize_t) image->columns; x++)
1891 {
1892 ssize_t
1893 i;
1894
1895 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
1896 {
1897 double
1898 pixel;
1899
1900 PixelTrait
1901 traits;
1902
1903 traits=GetPixelChannelTraits(image,(PixelChannel) i);
1904 if (traits == UndefinedPixelTrait)
1905 continue;
1906 pixel=(double) p[i];
1907 if ((pixel < 0.0) || (pixel > (double) QuantumRange) ||
1908 (pixel != (double) ((QuantumAny) pixel)))
1909 {
1910 hdri=MagickTrue;
1911 break;
1912 }
1913 }
1914 if (hdri != MagickFalse)
1915 break;
1916 p+=(ptrdiff_t) GetPixelChannels(image);
1917 }
1918 }
1919 image_view=DestroyCacheView(image_view);
1920 return(hdri);
1921#endif
1922}
1923␌
1924/*
1925%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1926% %
1927% %
1928% %
1929% I s I m a g e O b j e c t %
1930% %
1931% %
1932% %
1933%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1934%
1935% IsImageObject() returns MagickTrue if the image sequence contains a valid
1936% set of image objects.
1937%
1938% The format of the IsImageObject method is:
1939%
1940% MagickBooleanType IsImageObject(const Image *image)
1941%
1942% A description of each parameter follows:
1943%
1944% o image: the image.
1945%
1946*/
1947MagickExport MagickBooleanType IsImageObject(const Image *image)
1948{
1949 const Image
1950 *p;
1951
1952 assert(image != (Image *) NULL);
1953 if (IsEventLogging() != MagickFalse)
1954 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1955 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
1956 if (p->signature != MagickCoreSignature)
1957 return(MagickFalse);
1958 return(MagickTrue);
1959}
1960␌
1961/*
1962%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1963% %
1964% %
1965% %
1966% I s T a i n t I m a g e %
1967% %
1968% %
1969% %
1970%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1971%
1972% IsTaintImage() returns MagickTrue any pixel in the image has been altered
1973% since it was first constituted.
1974%
1975% The format of the IsTaintImage method is:
1976%
1977% MagickBooleanType IsTaintImage(const Image *image)
1978%
1979% A description of each parameter follows:
1980%
1981% o image: the image.
1982%
1983*/
1984MagickExport MagickBooleanType IsTaintImage(const Image *image)
1985{
1986 char
1987 magick[MagickPathExtent],
1988 filename[MagickPathExtent];
1989
1990 const Image
1991 *p;
1992
1993 assert(image != (Image *) NULL);
1994 assert(image->signature == MagickCoreSignature);
1995 if (IsEventLogging() != MagickFalse)
1996 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1997 (void) CopyMagickString(magick,image->magick,MagickPathExtent);
1998 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
1999 for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
2000 {
2001 if (p->taint != MagickFalse)
2002 return(MagickTrue);
2003 if (LocaleCompare(p->magick,magick) != 0)
2004 return(MagickTrue);
2005 if (LocaleCompare(p->filename,filename) != 0)
2006 return(MagickTrue);
2007 }
2008 return(MagickFalse);
2009}
2010␌
2011/*
2012%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2013% %
2014% %
2015% %
2016% M o d i f y I m a g e %
2017% %
2018% %
2019% %
2020%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2021%
2022% ModifyImage() ensures that there is only a single reference to the image
2023% to be modified, updating the provided image pointer to point to a clone of
2024% the original image if necessary.
2025%
2026% The format of the ModifyImage method is:
2027%
2028% MagickBooleanType ModifyImage(Image *image,ExceptionInfo *exception)
2029%
2030% A description of each parameter follows:
2031%
2032% o image: the image.
2033%
2034% o exception: return any errors or warnings in this structure.
2035%
2036*/
2037MagickExport MagickBooleanType ModifyImage(Image **image,
2038 ExceptionInfo *exception)
2039{
2040 Image
2041 *clone_image;
2042
2043 assert(image != (Image **) NULL);
2044 assert(*image != (Image *) NULL);
2045 assert((*image)->signature == MagickCoreSignature);
2046 if (IsEventLogging() != MagickFalse)
2047 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
2048 if (GetImageReferenceCount(*image) <= 1)
2049 return(MagickTrue);
2050 clone_image=CloneImage(*image,0,0,MagickTrue,exception);
2051 LockSemaphoreInfo((*image)->semaphore);
2052 (*image)->reference_count--;
2053 UnlockSemaphoreInfo((*image)->semaphore);
2054 *image=clone_image;
2055 return(MagickTrue);
2056}
2057␌
2058/*
2059%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2060% %
2061% %
2062% %
2063% N e w M a g i c k I m a g e %
2064% %
2065% %
2066% %
2067%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2068%
2069% NewMagickImage() creates a blank image canvas of the specified size and
2070% background color.
2071%
2072% The format of the NewMagickImage method is:
2073%
2074% Image *NewMagickImage(const ImageInfo *image_info,const size_t width,
2075% const size_t height,const PixelInfo *background,
2076% ExceptionInfo *exception)
2077%
2078% A description of each parameter follows:
2079%
2080% o image: the image.
2081%
2082% o width: the image width.
2083%
2084% o height: the image height.
2085%
2086% o background: the image color.
2087%
2088% o exception: return any errors or warnings in this structure.
2089%
2090*/
2091MagickExport Image *NewMagickImage(const ImageInfo *image_info,
2092 const size_t width,const size_t height,const PixelInfo *background,
2093 ExceptionInfo *exception)
2094{
2095 CacheView
2096 *image_view;
2097
2098 Image
2099 *image;
2100
2101 MagickBooleanType
2102 status;
2103
2104 ssize_t
2105 y;
2106
2107 assert(image_info != (const ImageInfo *) NULL);
2108 assert(image_info->signature == MagickCoreSignature);
2109 assert(background != (const PixelInfo *) NULL);
2110 if (IsEventLogging() != MagickFalse)
2111 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2112 image=AcquireImage(image_info,exception);
2113 image->columns=width;
2114 image->rows=height;
2115 image->colorspace=background->colorspace;
2116 image->alpha_trait=background->alpha_trait;
2117 image->fuzz=background->fuzz;
2118 image->depth=background->depth;
2119 status=MagickTrue;
2120 image_view=AcquireAuthenticCacheView(image,exception);
2121#if defined(MAGICKCORE_OPENMP_SUPPORT)
2122 #pragma omp parallel for schedule(static) shared(status) \
2123 magick_number_threads(image,image,image->rows,2)
2124#endif
2125 for (y=0; y < (ssize_t) image->rows; y++)
2126 {
2127 Quantum
2128 *magick_restrict q;
2129
2130 ssize_t
2131 x;
2132
2133 if (status == MagickFalse)
2134 continue;
2135 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2136 if (q == (Quantum *) NULL)
2137 {
2138 status=MagickFalse;
2139 continue;
2140 }
2141 for (x=0; x < (ssize_t) image->columns; x++)
2142 {
2143 SetPixelViaPixelInfo(image,background,q);
2144 q+=(ptrdiff_t) GetPixelChannels(image);
2145 }
2146 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2147 status=MagickFalse;
2148 }
2149 image_view=DestroyCacheView(image_view);
2150 if (status == MagickFalse)
2151 image=DestroyImage(image);
2152 return(image);
2153}
2154␌
2155/*
2156%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2157% %
2158% %
2159% %
2160% R e f e r e n c e I m a g e %
2161% %
2162% %
2163% %
2164%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2165%
2166% ReferenceImage() increments the reference count associated with an image
2167% returning a pointer to the image.
2168%
2169% The format of the ReferenceImage method is:
2170%
2171% Image *ReferenceImage(Image *image)
2172%
2173% A description of each parameter follows:
2174%
2175% o image: the image.
2176%
2177*/
2178MagickExport Image *ReferenceImage(Image *image)
2179{
2180 assert(image != (Image *) NULL);
2181 assert(image->signature == MagickCoreSignature);
2182 if (IsEventLogging() != MagickFalse)
2183 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2184 LockSemaphoreInfo(image->semaphore);
2185 image->reference_count++;
2186 UnlockSemaphoreInfo(image->semaphore);
2187 return(image);
2188}
2189␌
2190/*
2191%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2192% %
2193% %
2194% %
2195% R e s e t I m a g e P a g e %
2196% %
2197% %
2198% %
2199%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2200%
2201% ResetImagePage() resets the image page canvas and position.
2202%
2203% The format of the ResetImagePage method is:
2204%
2205% MagickBooleanType ResetImagePage(Image *image,const char *page)
2206%
2207% A description of each parameter follows:
2208%
2209% o image: the image.
2210%
2211% o page: the relative page specification.
2212%
2213*/
2214MagickExport MagickBooleanType ResetImagePage(Image *image,const char *page)
2215{
2216 MagickStatusType
2217 flags;
2218
2219 RectangleInfo
2220 geometry;
2221
2222 assert(image != (Image *) NULL);
2223 assert(image->signature == MagickCoreSignature);
2224 if (IsEventLogging() != MagickFalse)
2225 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2226 flags=ParseAbsoluteGeometry(page,&geometry);
2227 if ((flags & WidthValue) != 0)
2228 {
2229 if ((flags & HeightValue) == 0)
2230 geometry.height=geometry.width;
2231 image->page.width=geometry.width;
2232 image->page.height=geometry.height;
2233 }
2234 if ((flags & AspectValue) != 0)
2235 {
2236 if ((flags & XValue) != 0)
2237 image->page.x+=geometry.x;
2238 if ((flags & YValue) != 0)
2239 image->page.y+=geometry.y;
2240 }
2241 else
2242 {
2243 if ((flags & XValue) != 0)
2244 {
2245 image->page.x=geometry.x;
2246 if ((image->page.width == 0) && (geometry.x > 0))
2247 image->page.width=(size_t) ((ssize_t) image->columns+geometry.x);
2248 }
2249 if ((flags & YValue) != 0)
2250 {
2251 image->page.y=geometry.y;
2252 if ((image->page.height == 0) && (geometry.y > 0))
2253 image->page.height=(size_t) ((ssize_t) image->rows+geometry.y);
2254 }
2255 }
2256 return(MagickTrue);
2257}
2258␌
2259/*
2260%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2261% %
2262% %
2263% %
2264% R e s e t I m a g e P i x e l s %
2265% %
2266% %
2267% %
2268%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2269%
2270% ResetImagePixels() reset the image pixels, that is, all the pixel components
2271% are zeroed.
2272%
2273% The format of the SetImage method is:
2274%
2275% MagickBooleanType ResetImagePixels(Image *image,
2276% ExceptionInfo *exception)
2277%
2278% A description of each parameter follows:
2279%
2280% o image: the image.
2281%
2282% o exception: return any errors or warnings in this structure.
2283%
2284*/
2285MagickExport MagickBooleanType ResetImagePixels(Image *image,
2286 ExceptionInfo *exception)
2287{
2288 CacheView
2289 *image_view;
2290
2291 MagickBooleanType
2292 status;
2293
2294 size_t
2295 length;
2296
2297 ssize_t
2298 y;
2299
2300 void
2301 *pixels;
2302
2303 assert(image != (Image *) NULL);
2304 assert(image->signature == MagickCoreSignature);
2305 if (IsEventLogging() != MagickFalse)
2306 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2307 pixels=AcquirePixelCachePixels(image,&length,exception);
2308 if (pixels != (void *) NULL)
2309 {
2310 /*
2311 Reset in-core image pixels.
2312 */
2313 (void) memset(pixels,0,length);
2314 return(MagickTrue);
2315 }
2316 /*
2317 Reset image pixels.
2318 */
2319 status=MagickTrue;
2320 image_view=AcquireAuthenticCacheView(image,exception);
2321#if defined(MAGICKCORE_OPENMP_SUPPORT)
2322 #pragma omp parallel for schedule(static) shared(status) \
2323 magick_number_threads(image,image,image->rows,2)
2324#endif
2325 for (y=0; y < (ssize_t) image->rows; y++)
2326 {
2327 Quantum
2328 *magick_restrict q;
2329
2330 ssize_t
2331 x;
2332
2333 if (status == MagickFalse)
2334 continue;
2335 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2336 if (q == (Quantum *) NULL)
2337 {
2338 status=MagickFalse;
2339 continue;
2340 }
2341 for (x=0; x < (ssize_t) image->columns; x++)
2342 {
2343 (void) memset(q,0,GetPixelChannels(image)*sizeof(Quantum));
2344 q+=(ptrdiff_t) GetPixelChannels(image);
2345 }
2346 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2347 status=MagickFalse;
2348 }
2349 image_view=DestroyCacheView(image_view);
2350 return(status);
2351}
2352␌
2353/*
2354%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2355% %
2356% %
2357% %
2358% S e t I m a g e A l p h a %
2359% %
2360% %
2361% %
2362%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2363%
2364% SetImageAlpha() sets the alpha levels of the image.
2365%
2366% The format of the SetImageAlpha method is:
2367%
2368% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2369% ExceptionInfo *exception)
2370%
2371% A description of each parameter follows:
2372%
2373% o image: the image.
2374%
2375% o alpha: the level of transparency: 0 is fully transparent and QuantumRange
2376% is fully opaque.
2377%
2378% o exception: return any errors or warnings in this structure.
2379%
2380*/
2381MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
2382 ExceptionInfo *exception)
2383{
2384 CacheView
2385 *image_view;
2386
2387 MagickBooleanType
2388 status;
2389
2390 ssize_t
2391 y;
2392
2393 assert(image != (Image *) NULL);
2394 assert(image->signature == MagickCoreSignature);
2395 if (IsEventLogging() != MagickFalse)
2396 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2397 image->alpha_trait=BlendPixelTrait;
2398 status=MagickTrue;
2399 image_view=AcquireAuthenticCacheView(image,exception);
2400#if defined(MAGICKCORE_OPENMP_SUPPORT)
2401 #pragma omp parallel for schedule(static) shared(status) \
2402 magick_number_threads(image,image,image->rows,2)
2403#endif
2404 for (y=0; y < (ssize_t) image->rows; y++)
2405 {
2406 Quantum
2407 *magick_restrict q;
2408
2409 ssize_t
2410 x;
2411
2412 if (status == MagickFalse)
2413 continue;
2414 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2415 if (q == (Quantum *) NULL)
2416 {
2417 status=MagickFalse;
2418 continue;
2419 }
2420 for (x=0; x < (ssize_t) image->columns; x++)
2421 {
2422 if (GetPixelWriteMask(image,q) > (QuantumRange/2))
2423 SetPixelAlpha(image,alpha,q);
2424 q+=(ptrdiff_t) GetPixelChannels(image);
2425 }
2426 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2427 status=MagickFalse;
2428 }
2429 image_view=DestroyCacheView(image_view);
2430 return(status);
2431}
2432␌
2433/*
2434%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2435% %
2436% %
2437% %
2438% S e t I m a g e B a c k g r o u n d C o l o r %
2439% %
2440% %
2441% %
2442%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2443%
2444% SetImageBackgroundColor() initializes the image pixels to the image
2445% background color. The background color is defined by the background_color
2446% member of the image structure.
2447%
2448% The format of the SetImage method is:
2449%
2450% MagickBooleanType SetImageBackgroundColor(Image *image,
2451% ExceptionInfo *exception)
2452%
2453% A description of each parameter follows:
2454%
2455% o image: the image.
2456%
2457% o exception: return any errors or warnings in this structure.
2458%
2459*/
2460MagickExport MagickBooleanType SetImageBackgroundColor(Image *image,
2461 ExceptionInfo *exception)
2462{
2463 CacheView
2464 *image_view;
2465
2466 MagickBooleanType
2467 status;
2468
2469 PixelInfo
2470 background;
2471
2472 ssize_t
2473 y;
2474
2475 assert(image != (Image *) NULL);
2476 assert(image->signature == MagickCoreSignature);
2477 if (IsEventLogging() != MagickFalse)
2478 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2479 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2480 return(MagickFalse);
2481 if ((image->background_color.alpha_trait != UndefinedPixelTrait) &&
2482 ((image->alpha_trait & BlendPixelTrait) == 0))
2483 (void) SetImageAlphaChannel(image,ActivateAlphaChannel,exception);
2484 ConformPixelInfo(image,&image->background_color,&background,exception);
2485 /*
2486 Set image background color.
2487 */
2488 status=MagickTrue;
2489 image_view=AcquireAuthenticCacheView(image,exception);
2490#if defined(MAGICKCORE_OPENMP_SUPPORT)
2491 #pragma omp parallel for schedule(static) shared(status) \
2492 magick_number_threads(image,image,image->rows,2)
2493#endif
2494 for (y=0; y < (ssize_t) image->rows; y++)
2495 {
2496 Quantum
2497 *magick_restrict q;
2498
2499 ssize_t
2500 x;
2501
2502 if (status == MagickFalse)
2503 continue;
2504 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2505 if (q == (Quantum *) NULL)
2506 {
2507 status=MagickFalse;
2508 continue;
2509 }
2510 for (x=0; x < (ssize_t) image->columns; x++)
2511 {
2512 SetPixelViaPixelInfo(image,&background,q);
2513 q+=(ptrdiff_t) GetPixelChannels(image);
2514 }
2515 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2516 status=MagickFalse;
2517 }
2518 image_view=DestroyCacheView(image_view);
2519 return(status);
2520}
2521␌
2522/*
2523%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2524% %
2525% %
2526% %
2527% S e t I m a g e C h a n n e l M a s k %
2528% %
2529% %
2530% %
2531%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2532%
2533% SetImageChannelMask() sets the image channel mask from the specified channel
2534% mask.
2535%
2536% The format of the SetImageChannelMask method is:
2537%
2538% ChannelType SetImageChannelMask(Image *image,
2539% const ChannelType channel_mask)
2540%
2541% A description of each parameter follows:
2542%
2543% o image: the image.
2544%
2545% o channel_mask: the channel mask.
2546%
2547*/
2548MagickExport ChannelType SetImageChannelMask(Image *image,
2549 const ChannelType channel_mask)
2550{
2551 return(SetPixelChannelMask(image,channel_mask));
2552}
2553␌
2554/*
2555%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2556% %
2557% %
2558% %
2559% S e t I m a g e C o l o r %
2560% %
2561% %
2562% %
2563%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2564%
2565% SetImageColor() set the entire image canvas to the specified color.
2566%
2567% The format of the SetImageColor method is:
2568%
2569% MagickBooleanType SetImageColor(Image *image,const PixelInfo *color,
2570% ExceptionInfo *exception)
2571%
2572% A description of each parameter follows:
2573%
2574% o image: the image.
2575%
2576% o background: the image color.
2577%
2578% o exception: return any errors or warnings in this structure.
2579%
2580*/
2581MagickExport MagickBooleanType SetImageColor(Image *image,
2582 const PixelInfo *color,ExceptionInfo *exception)
2583{
2584 CacheView
2585 *image_view;
2586
2587 MagickBooleanType
2588 status;
2589
2590 ssize_t
2591 y;
2592
2593 assert(image != (Image *) NULL);
2594 assert(image->signature == MagickCoreSignature);
2595 assert(color != (const PixelInfo *) NULL);
2596 if (IsEventLogging() != MagickFalse)
2597 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2598 image->colorspace=color->colorspace;
2599 image->alpha_trait=color->alpha_trait;
2600 image->fuzz=color->fuzz;
2601 image->depth=color->depth;
2602 status=MagickTrue;
2603 image_view=AcquireAuthenticCacheView(image,exception);
2604#if defined(MAGICKCORE_OPENMP_SUPPORT)
2605 #pragma omp parallel for schedule(static) shared(status) \
2606 magick_number_threads(image,image,image->rows,2)
2607#endif
2608 for (y=0; y < (ssize_t) image->rows; y++)
2609 {
2610 Quantum
2611 *magick_restrict q;
2612
2613 ssize_t
2614 x;
2615
2616 if (status == MagickFalse)
2617 continue;
2618 q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
2619 if (q == (Quantum *) NULL)
2620 {
2621 status=MagickFalse;
2622 continue;
2623 }
2624 for (x=0; x < (ssize_t) image->columns; x++)
2625 {
2626 SetPixelViaPixelInfo(image,color,q);
2627 q+=(ptrdiff_t) GetPixelChannels(image);
2628 }
2629 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
2630 status=MagickFalse;
2631 }
2632 image_view=DestroyCacheView(image_view);
2633 return(status);
2634}
2635␌
2636/*
2637%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2638% %
2639% %
2640% %
2641% S e t I m a g e S t o r a g e C l a s s %
2642% %
2643% %
2644% %
2645%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2646%
2647% SetImageStorageClass() sets the image class: DirectClass for true color
2648% images or PseudoClass for colormapped images.
2649%
2650% The format of the SetImageStorageClass method is:
2651%
2652% MagickBooleanType SetImageStorageClass(Image *image,
2653% const ClassType storage_class,ExceptionInfo *exception)
2654%
2655% A description of each parameter follows:
2656%
2657% o image: the image.
2658%
2659% o storage_class: The image class.
2660%
2661% o exception: return any errors or warnings in this structure.
2662%
2663*/
2664MagickExport MagickBooleanType SetImageStorageClass(Image *image,
2665 const ClassType storage_class,ExceptionInfo *exception)
2666{
2667 assert(image != (Image *) NULL);
2668 assert(image->signature == MagickCoreSignature);
2669 assert(exception != (ExceptionInfo *) NULL);
2670 assert(exception->signature == MagickCoreSignature);
2671 if (IsEventLogging() != MagickFalse)
2672 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2673 image->storage_class=storage_class;
2674 return(SyncImagePixelCache(image,exception));
2675}
2676␌
2677/*
2678%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2679% %
2680% %
2681% %
2682% S e t I m a g e E x t e n t %
2683% %
2684% %
2685% %
2686%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2687%
2688% SetImageExtent() sets the image size (i.e. columns & rows).
2689%
2690% The format of the SetImageExtent method is:
2691%
2692% MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2693% const size_t rows,ExceptionInfo *exception)
2694%
2695% A description of each parameter follows:
2696%
2697% o image: the image.
2698%
2699% o columns: The image width in pixels.
2700%
2701% o rows: The image height in pixels.
2702%
2703% o exception: return any errors or warnings in this structure.
2704%
2705*/
2706MagickExport MagickBooleanType SetImageExtent(Image *image,const size_t columns,
2707 const size_t rows,ExceptionInfo *exception)
2708{
2709 if ((columns == 0) || (rows == 0))
2710 ThrowBinaryException(ImageError,"NegativeOrZeroImageSize",image->filename);
2711 image->columns=columns;
2712 image->rows=rows;
2713 if (image->depth == 0)
2714 {
2715 image->depth=8;
2716 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2717 "ImageDepthNotSupported","`%s'",image->filename);
2718 }
2719 if (image->depth > (8*sizeof(MagickSizeType)))
2720 {
2721 image->depth=8*sizeof(MagickSizeType);
2722 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2723 "ImageDepthNotSupported","`%s'",image->filename);
2724 }
2725 return(SyncImagePixelCache(image,exception));
2726}
2727␌
2728/*
2729%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2730% %
2731% %
2732% %
2733+ S e t I m a g e I n f o %
2734% %
2735% %
2736% %
2737%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2738%
2739% SetImageInfo() initializes the 'magick' field of the ImageInfo structure.
2740% It is set to a type of image format based on the prefix or suffix of the
2741% filename. For example, 'ps:image' returns PS indicating a Postscript image.
2742% JPEG is returned for this filename: 'image.jpg'. The filename prefix has
2743% precedence over the suffix. Use an optional index enclosed in brackets
2744% after a file name to specify a desired scene of a multi-resolution image
2745% format like Photo CD (e.g. img0001.pcd[4]). A True (non-zero) return value
2746% indicates success.
2747%
2748% The format of the SetImageInfo method is:
2749%
2750% MagickBooleanType SetImageInfo(ImageInfo *image_info,
2751% const unsigned int frames,ExceptionInfo *exception)
2752%
2753% A description of each parameter follows:
2754%
2755% o image_info: the image info.
2756%
2757% o frames: the number of images you intend to write.
2758%
2759% o exception: return any errors or warnings in this structure.
2760%
2761*/
2762
2763static const MagickInfo *SetImageInfoFromExtension(ImageInfo *image_info,
2764 const char *component,char *magic,ExceptionInfo *exception)
2765{
2766 const MagickInfo
2767 *magick_info;
2768
2769 MagickFormatType
2770 format_type;
2771
2772 ssize_t
2773 i;
2774
2775 static const char
2776 *format_type_formats[] =
2777 {
2778 "AUTOTRACE",
2779 "BROWSE",
2780 "DCRAW",
2781 "EDIT",
2782 "LAUNCH",
2783 "MPEG:DECODE",
2784 "MPEG:ENCODE",
2785 "PRINT",
2786 "PS:ALPHA",
2787 "PS:CMYK",
2788 "PS:COLOR",
2789 "PS:GRAY",
2790 "PS:MONO",
2791 "SCAN",
2792 "SHOW",
2793 "WIN",
2794 (char *) NULL
2795 };
2796
2797 /*
2798 User specified image format.
2799 */
2800 (void) CopyMagickString(magic,component,MagickPathExtent);
2801 LocaleUpper(magic);
2802 /*
2803 Look for explicit image formats.
2804 */
2805 format_type=UndefinedFormatType;
2806 magick_info=GetMagickInfo(magic,exception);
2807 if ((magick_info != (const MagickInfo *) NULL) &&
2808 (magick_info->format_type != UndefinedFormatType))
2809 format_type=magick_info->format_type;
2810 i=0;
2811 while ((format_type == UndefinedFormatType) &&
2812 (format_type_formats[i] != (char *) NULL))
2813 {
2814 if ((*magic == *format_type_formats[i]) &&
2815 (LocaleCompare(magic,format_type_formats[i]) == 0))
2816 format_type=ExplicitFormatType;
2817 i++;
2818 }
2819 if (format_type == UndefinedFormatType)
2820 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2821 else
2822 if (format_type == ExplicitFormatType)
2823 {
2824 image_info->affirm=MagickTrue;
2825 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2826 }
2827 if (LocaleCompare(magic,"RGB") == 0)
2828 image_info->affirm=MagickFalse; /* maybe SGI disguised as RGB */
2829 return(magick_info);
2830}
2831
2832MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info,
2833 const unsigned int frames,ExceptionInfo *exception)
2834{
2835 char
2836 component[MagickPathExtent],
2837 magic[MagickPathExtent],
2838 path[MagickPathExtent],
2839 *q;
2840
2841 const char
2842 *p;
2843
2844 const MagicInfo
2845 *magic_info;
2846
2847 const MagickInfo
2848 *magick_info;
2849
2850 ExceptionInfo
2851 *sans_exception;
2852
2853 Image
2854 *image;
2855
2856 MagickBooleanType
2857 status;
2858
2859 ssize_t
2860 count;
2861
2862 /*
2863 Look for 'image.format' in filename.
2864 */
2865 assert(image_info != (ImageInfo *) NULL);
2866 assert(image_info->signature == MagickCoreSignature);
2867 if (IsEventLogging() != MagickFalse)
2868 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2869 image_info->filename);
2870 *component='\0';
2871 GetPathComponent(image_info->filename,SubimagePath,component);
2872 if (*component != '\0')
2873 {
2874 /*
2875 Look for scene specification (e.g. img0001.pcd[4]).
2876 */
2877 if (IsSceneGeometry(component,MagickFalse) == MagickFalse)
2878 {
2879 if (IsGeometry(component) != MagickFalse)
2880 (void) CloneString(&image_info->extract,component);
2881 }
2882 else
2883 {
2884 size_t
2885 first,
2886 last;
2887
2888 (void) CloneString(&image_info->scenes,component);
2889 image_info->scene=StringToUnsignedLong(image_info->scenes);
2890 image_info->number_scenes=image_info->scene;
2891 p=image_info->scenes;
2892 for (q=(char *) image_info->scenes; *q != '\0'; p++)
2893 {
2894 while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
2895 p++;
2896 first=(size_t) strtol(p,&q,10);
2897 last=first;
2898 while (isspace((int) ((unsigned char) *q)) != 0)
2899 q++;
2900 if (*q == '-')
2901 last=(size_t) strtol(q+1,&q,10);
2902 if (first > last)
2903 Swap(first,last);
2904 if (first < image_info->scene)
2905 image_info->scene=first;
2906 if (last > image_info->number_scenes)
2907 image_info->number_scenes=last;
2908 p=q;
2909 }
2910 image_info->number_scenes-=image_info->scene-1;
2911 }
2912 }
2913 *component='\0';
2914 if (*image_info->magick == '\0')
2915 GetPathComponent(image_info->filename,ExtensionPath,component);
2916 if (*component != '\0')
2917 {
2918 /*
2919 Base path sans any compression extension.
2920 */
2921 GetPathComponent(image_info->filename,BasePathSansCompressExtension,path);
2922 GetPathComponent(path,ExtensionPath,component);
2923 }
2924 image_info->affirm=MagickFalse;
2925 sans_exception=AcquireExceptionInfo();
2926 if ((*component != '\0') && (IsGlob(component) == MagickFalse))
2927 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2928 sans_exception);
2929 /*
2930 Look for explicit 'format:image' in filename.
2931 */
2932 *magic='\0';
2933 GetPathComponent(image_info->filename,MagickPath,magic);
2934 if (*magic == '\0')
2935 {
2936 (void) CopyMagickString(magic,image_info->magick,MagickPathExtent);
2937 magick_info=GetMagickInfo(magic,sans_exception);
2938 if ((magick_info != (const MagickInfo *) NULL) &&
2939 (magick_info->format_type == ExplicitFormatType))
2940 image_info->affirm=MagickTrue;
2941 if (frames == 0)
2942 GetPathComponent(image_info->filename,CanonicalPath,component);
2943 else
2944 GetPathComponent(image_info->filename,SubcanonicalPath,component);
2945 (void) CopyMagickString(image_info->filename,component,MagickPathExtent);
2946 }
2947 else
2948 {
2949 const DelegateInfo
2950 *delegate_info;
2951
2952 /*
2953 User specified image format.
2954 */
2955 LocaleUpper(magic);
2956 magick_info=GetMagickInfo(magic,sans_exception);
2957 delegate_info=(const DelegateInfo *) NULL;
2958 if (magick_info == (const MagickInfo *) NULL)
2959 {
2960 delegate_info=GetDelegateInfo(magic,"*",sans_exception);
2961 if (delegate_info == (const DelegateInfo *) NULL)
2962 delegate_info=GetDelegateInfo("*",magic,sans_exception);
2963 if ((delegate_info == (const DelegateInfo *) NULL) &&
2964 ((*component != '\0') && (IsGlob(component) == MagickFalse)))
2965 {
2966 /*
2967 Retry in case GetMagickInfo loaded a custom module.
2968 */
2969 magick_info=SetImageInfoFromExtension(image_info,component,magic,
2970 sans_exception);
2971 }
2972 }
2973 if (((magick_info != (const MagickInfo *) NULL) ||
2974 (delegate_info != (const DelegateInfo *) NULL)) &&
2975 (IsMagickConflict(magic) == MagickFalse))
2976 {
2977 image_info->affirm=MagickTrue;
2978 (void) CopyMagickString(image_info->magick,magic,MagickPathExtent);
2979 GetPathComponent(image_info->filename,CanonicalPath,component);
2980 if (IsStringTrue(GetImageOption(image_info,"filename:literal")) != MagickFalse)
2981 GetPathComponent(image_info->filename,SubcanonicalPath,component);
2982 (void) CopyMagickString(image_info->filename,component,
2983 MagickPathExtent);
2984 }
2985 }
2986 sans_exception=DestroyExceptionInfo(sans_exception);
2987 if ((magick_info == (const MagickInfo *) NULL) ||
2988 (GetMagickEndianSupport(magick_info) == MagickFalse))
2989 image_info->endian=UndefinedEndian;
2990 if ((image_info->adjoin != MagickFalse) && (frames > 1))
2991 {
2992 /*
2993 Test for multiple image support (e.g. image%02d.png).
2994 */
2995 (void) InterpretImageFilename(image_info,(Image *) NULL,
2996 image_info->filename,(int) image_info->scene,component,exception);
2997 if ((LocaleCompare(component,image_info->filename) != 0) &&
2998 (strchr(component,'%') == (char *) NULL))
2999 image_info->adjoin=MagickFalse;
3000 }
3001 if ((image_info->adjoin != MagickFalse) && (frames > 0))
3002 {
3003 /*
3004 Some image formats do not support multiple frames per file.
3005 */
3006 magick_info=GetMagickInfo(magic,exception);
3007 if (magick_info != (const MagickInfo *) NULL)
3008 if (GetMagickAdjoin(magick_info) == MagickFalse)
3009 image_info->adjoin=MagickFalse;
3010 }
3011 if (image_info->affirm != MagickFalse)
3012 return(MagickTrue);
3013 if (frames == 0)
3014 {
3015 unsigned char
3016 *magick;
3017
3018 size_t
3019 magick_size;
3020
3021 /*
3022 Determine the image format from the first few bytes of the file.
3023 */
3024 magick_size=GetMagicPatternExtent(exception);
3025 if (magick_size == 0)
3026 return(MagickFalse);
3027 image=AcquireImage(image_info,exception);
3028 (void) CopyMagickString(image->filename,image_info->filename,
3029 MagickPathExtent);
3030 sans_exception=AcquireExceptionInfo();
3031 status=OpenBlob(image_info,image,ReadBinaryBlobMode,sans_exception);
3032 sans_exception=DestroyExceptionInfo(sans_exception);
3033 if (status == MagickFalse)
3034 {
3035 image=DestroyImage(image);
3036 return(MagickFalse);
3037 }
3038 if ((IsBlobSeekable(image) == MagickFalse) ||
3039 (IsBlobExempt(image) != MagickFalse))
3040 {
3041 /*
3042 Copy image to seekable temporary file.
3043 */
3044 *component='\0';
3045 status=ImageToFile(image,component,exception);
3046 if (CloseBlob(image) == MagickFalse)
3047 status=MagickFalse;
3048 if (status == MagickFalse)
3049 {
3050 (void) RelinquishUniqueFileResource(component);
3051 image=DestroyImage(image);
3052 return(MagickFalse);
3053 }
3054 SetImageInfoFile(image_info,(FILE *) NULL);
3055 (void) CopyMagickString(image->filename,component,MagickPathExtent);
3056 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
3057 if (status == MagickFalse)
3058 {
3059 (void) RelinquishUniqueFileResource(component);
3060 image=DestroyImage(image);
3061 return(MagickFalse);
3062 }
3063 (void) CopyMagickString(image_info->filename,component,
3064 MagickPathExtent);
3065 image_info->temporary=MagickTrue;
3066 }
3067 magick=(unsigned char *) AcquireQuantumMemory(1,magick_size);
3068 if (magick == (unsigned char *) NULL)
3069 {
3070 (void) CloseBlob(image);
3071 image=DestroyImage(image);
3072 return(MagickFalse);
3073 }
3074 (void) memset(magick,0,magick_size);
3075 count=ReadBlob(image,magick_size,magick);
3076 (void) SeekBlob(image,-((MagickOffsetType) count),SEEK_CUR);
3077 (void) CloseBlob(image);
3078 image=DestroyImage(image);
3079 /*
3080 Check magic cache.
3081 */
3082 sans_exception=AcquireExceptionInfo();
3083 magic_info=GetMagicInfo(magick,(size_t) count,sans_exception);
3084 magick=(unsigned char *) RelinquishMagickMemory(magick);
3085 if ((magic_info != (const MagicInfo *) NULL) &&
3086 (GetMagicName(magic_info) != (char *) NULL))
3087 {
3088 /*
3089 Try to use magick_info that was determined earlier by the extension
3090 */
3091 if ((magick_info != (const MagickInfo *) NULL) &&
3092 (GetMagickUseExtension(magick_info) != MagickFalse) &&
3093 (LocaleCompare(magick_info->magick_module,GetMagicName(
3094 magic_info)) == 0))
3095 (void) CopyMagickString(image_info->magick,magick_info->name,
3096 MagickPathExtent);
3097 else
3098 {
3099 (void) CopyMagickString(image_info->magick,GetMagicName(
3100 magic_info),MagickPathExtent);
3101 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3102 }
3103 if ((magick_info == (const MagickInfo *) NULL) ||
3104 (GetMagickEndianSupport(magick_info) == MagickFalse))
3105 image_info->endian=UndefinedEndian;
3106 sans_exception=DestroyExceptionInfo(sans_exception);
3107 return(MagickTrue);
3108 }
3109 magick_info=GetMagickInfo(image_info->magick,sans_exception);
3110 if ((magick_info == (const MagickInfo *) NULL) ||
3111 (GetMagickEndianSupport(magick_info) == MagickFalse))
3112 image_info->endian=UndefinedEndian;
3113 sans_exception=DestroyExceptionInfo(sans_exception);
3114 }
3115 return(MagickTrue);
3116}
3117␌
3118/*
3119%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3120% %
3121% %
3122% %
3123% S e t I m a g e I n f o B l o b %
3124% %
3125% %
3126% %
3127%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3128%
3129% SetImageInfoBlob() sets the image info blob member.
3130%
3131% The format of the SetImageInfoBlob method is:
3132%
3133% void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3134% const size_t length)
3135%
3136% A description of each parameter follows:
3137%
3138% o image_info: the image info.
3139%
3140% o blob: the blob.
3141%
3142% o length: the blob length.
3143%
3144*/
3145MagickExport void SetImageInfoBlob(ImageInfo *image_info,const void *blob,
3146 const size_t length)
3147{
3148 assert(image_info != (ImageInfo *) NULL);
3149 assert(image_info->signature == MagickCoreSignature);
3150 if (IsEventLogging() != MagickFalse)
3151 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3152 image_info->filename);
3153 image_info->blob=(void *) blob;
3154 image_info->length=length;
3155}
3156␌
3157/*
3158%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3159% %
3160% %
3161% %
3162% S e t I m a g e I n f o C u s t o m S t r e a m %
3163% %
3164% %
3165% %
3166%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3167%
3168% SetImageInfoCustomStream() sets the image info custom stream handlers.
3169%
3170% The format of the SetImageInfoCustomStream method is:
3171%
3172% void SetImageInfoCustomStream(ImageInfo *image_info,
3173% CustomStreamInfo *custom_stream)
3174%
3175% A description of each parameter follows:
3176%
3177% o image_info: the image info.
3178%
3179% o custom_stream: your custom stream methods.
3180%
3181*/
3182MagickExport void SetImageInfoCustomStream(ImageInfo *image_info,
3183 CustomStreamInfo *custom_stream)
3184{
3185 assert(image_info != (ImageInfo *) NULL);
3186 assert(image_info->signature == MagickCoreSignature);
3187 if (IsEventLogging() != MagickFalse)
3188 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3189 image_info->filename);
3190 image_info->custom_stream=(CustomStreamInfo *) custom_stream;
3191}
3192␌
3193/*
3194%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3195% %
3196% %
3197% %
3198% S e t I m a g e I n f o F i l e %
3199% %
3200% %
3201% %
3202%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3203%
3204% SetImageInfoFile() sets the image info file member.
3205%
3206% The format of the SetImageInfoFile method is:
3207%
3208% void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3209%
3210% A description of each parameter follows:
3211%
3212% o image_info: the image info.
3213%
3214% o file: the file.
3215%
3216*/
3217MagickExport void SetImageInfoFile(ImageInfo *image_info,FILE *file)
3218{
3219 assert(image_info != (ImageInfo *) NULL);
3220 assert(image_info->signature == MagickCoreSignature);
3221 if (IsEventLogging() != MagickFalse)
3222 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3223 image_info->filename);
3224 image_info->file=file;
3225}
3226␌
3227/*
3228%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3229% %
3230% %
3231% %
3232% S e t I m a g e M a s k %
3233% %
3234% %
3235% %
3236%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3237%
3238% SetImageMask() associates a mask with the image. The mask must be the same
3239% dimensions as the image.
3240%
3241% The format of the SetImageMask method is:
3242%
3243% MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3244% const Image *mask,ExceptionInfo *exception)
3245%
3246% A description of each parameter follows:
3247%
3248% o image: the image.
3249%
3250% o type: the mask type, ReadPixelMask or WritePixelMask.
3251%
3252% o mask: the image mask.
3253%
3254% o exception: return any errors or warnings in this structure.
3255%
3256*/
3257MagickExport MagickBooleanType SetImageMask(Image *image,const PixelMask type,
3258 const Image *mask,ExceptionInfo *exception)
3259{
3260 CacheView
3261 *mask_view,
3262 *image_view;
3263
3264 MagickBooleanType
3265 status;
3266
3267 ssize_t
3268 y;
3269
3270 /*
3271 Set image mask.
3272 */
3273 assert(image != (Image *) NULL);
3274 if (IsEventLogging() != MagickFalse)
3275 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3276 assert(image->signature == MagickCoreSignature);
3277 if (mask == (const Image *) NULL)
3278 {
3279 switch (type)
3280 {
3281 case ReadPixelMask:
3282 {
3283 image->channels=(ChannelType) ((unsigned int) image->channels &
3284 (unsigned int) ~ReadMaskChannel);
3285 break;
3286 }
3287 case WritePixelMask:
3288 {
3289 image->channels=(ChannelType) ((unsigned int) image->channels &
3290 (unsigned int) ~WriteMaskChannel);
3291 magick_fallthrough;
3292 }
3293 default:
3294 {
3295 image->channels=(ChannelType) ((unsigned int) image->channels &
3296 (unsigned int) ~CompositeMaskChannel);
3297 break;
3298 }
3299 }
3300 return(SyncImagePixelCache(image,exception));
3301 }
3302 switch (type)
3303 {
3304 case ReadPixelMask:
3305 {
3306 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3307 break;
3308 }
3309 case WritePixelMask:
3310 {
3311 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3312 break;
3313 }
3314 default:
3315 {
3316 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3317 break;
3318 }
3319 }
3320 if (SyncImagePixelCache(image,exception) == MagickFalse)
3321 return(MagickFalse);
3322 status=MagickTrue;
3323 mask_view=AcquireVirtualCacheView(mask,exception);
3324 image_view=AcquireAuthenticCacheView(image,exception);
3325#if defined(MAGICKCORE_OPENMP_SUPPORT)
3326 #pragma omp parallel for schedule(static) shared(status) \
3327 magick_number_threads(mask,image,image->rows,2)
3328#endif
3329 for (y=0; y < (ssize_t) image->rows; y++)
3330 {
3331 const Quantum
3332 *magick_restrict p;
3333
3334 Quantum
3335 *magick_restrict q;
3336
3337 ssize_t
3338 x;
3339
3340 if (status == MagickFalse)
3341 continue;
3342 p=GetCacheViewVirtualPixels(mask_view,0,y,mask->columns,1,exception);
3343 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3344 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3345 {
3346 status=MagickFalse;
3347 continue;
3348 }
3349 for (x=0; x < (ssize_t) image->columns; x++)
3350 {
3351 MagickRealType
3352 intensity;
3353
3354 intensity=0.0;
3355 if ((x < (ssize_t) mask->columns) && (y < (ssize_t) mask->rows))
3356 intensity=GetPixelIntensity(mask,p);
3357 switch (type)
3358 {
3359 case ReadPixelMask:
3360 {
3361 SetPixelReadMask(image,ClampToQuantum(intensity),q);
3362 break;
3363 }
3364 case WritePixelMask:
3365 {
3366 SetPixelWriteMask(image,ClampToQuantum(intensity),q);
3367 break;
3368 }
3369 default:
3370 {
3371 SetPixelCompositeMask(image,ClampToQuantum(intensity),q);
3372 break;
3373 }
3374 }
3375 p+=(ptrdiff_t) GetPixelChannels(mask);
3376 q+=(ptrdiff_t) GetPixelChannels(image);
3377 }
3378 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3379 status=MagickFalse;
3380 }
3381 image->mask_trait=UpdatePixelTrait;
3382 mask_view=DestroyCacheView(mask_view);
3383 image_view=DestroyCacheView(image_view);
3384 return(status);
3385}
3386␌
3387/*
3388%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3389% %
3390% %
3391% %
3392% S e t I m a g e R e g i o n M a s k %
3393% %
3394% %
3395% %
3396%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3397%
3398% SetImageRegionMask() associates a mask with the image as defined by the
3399% specified region.
3400%
3401% The format of the SetImageRegionMask method is:
3402%
3403% MagickBooleanType SetImageRegionMask(Image *image,const PixelMask type,
3404% const RectangleInfo *region,ExceptionInfo *exception)
3405%
3406% A description of each parameter follows:
3407%
3408% o image: the image.
3409%
3410% o type: the mask type, ReadPixelMask or WritePixelMask.
3411%
3412% o geometry: the mask region.
3413%
3414% o exception: return any errors or warnings in this structure.
3415%
3416*/
3417MagickExport MagickBooleanType SetImageRegionMask(Image *image,
3418 const PixelMask type,const RectangleInfo *region,ExceptionInfo *exception)
3419{
3420 CacheView
3421 *image_view;
3422
3423 MagickBooleanType
3424 status;
3425
3426 ssize_t
3427 y;
3428
3429 /*
3430 Set image mask as defined by the region.
3431 */
3432 assert(image != (Image *) NULL);
3433 assert(image->signature == MagickCoreSignature);
3434 if (IsEventLogging() != MagickFalse)
3435 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3436 if (region == (const RectangleInfo *) NULL)
3437 {
3438 switch (type)
3439 {
3440 case ReadPixelMask:
3441 {
3442 image->channels=(ChannelType) ((unsigned int) image->channels &
3443 (unsigned int) ~ReadMaskChannel);
3444 break;
3445 }
3446 case WritePixelMask:
3447 {
3448 image->channels=(ChannelType) ((unsigned int) image->channels &
3449 (unsigned int) ~WriteMaskChannel);
3450 break;
3451 }
3452 default:
3453 {
3454 image->channels=(ChannelType) ((unsigned int) image->channels &
3455 (unsigned int) ~CompositeMaskChannel);
3456 break;
3457 }
3458 }
3459 return(SyncImagePixelCache(image,exception));
3460 }
3461 switch (type)
3462 {
3463 case ReadPixelMask:
3464 {
3465 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3466 break;
3467 }
3468 case WritePixelMask:
3469 {
3470 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3471 break;
3472 }
3473 default:
3474 {
3475 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3476 break;
3477 }
3478 }
3479 if (SyncImagePixelCache(image,exception) == MagickFalse)
3480 return(MagickFalse);
3481 status=MagickTrue;
3482 image_view=AcquireAuthenticCacheView(image,exception);
3483#if defined(MAGICKCORE_OPENMP_SUPPORT)
3484 #pragma omp parallel for schedule(static) shared(status) \
3485 magick_number_threads(image,image,image->rows,2)
3486#endif
3487 for (y=0; y < (ssize_t) image->rows; y++)
3488 {
3489 Quantum
3490 *magick_restrict q;
3491
3492 ssize_t
3493 x;
3494
3495 if (status == MagickFalse)
3496 continue;
3497 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3498 if (q == (Quantum *) NULL)
3499 {
3500 status=MagickFalse;
3501 continue;
3502 }
3503 for (x=0; x < (ssize_t) image->columns; x++)
3504 {
3505 Quantum
3506 pixel;
3507
3508 pixel=QuantumRange;
3509 if (((x >= region->x) && (x < (region->x+(ssize_t) region->width))) &&
3510 ((y >= region->y) && (y < (region->y+(ssize_t) region->height))))
3511 pixel=(Quantum) 0;
3512 switch (type)
3513 {
3514 case ReadPixelMask:
3515 {
3516 SetPixelReadMask(image,pixel,q);
3517 break;
3518 }
3519 case WritePixelMask:
3520 {
3521 SetPixelWriteMask(image,pixel,q);
3522 break;
3523 }
3524 default:
3525 {
3526 SetPixelCompositeMask(image,pixel,q);
3527 break;
3528 }
3529 }
3530 q+=(ptrdiff_t) GetPixelChannels(image);
3531 }
3532 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3533 status=MagickFalse;
3534 }
3535 image->mask_trait=UpdatePixelTrait;
3536 image_view=DestroyCacheView(image_view);
3537 return(status);
3538}
3539␌
3540/*
3541%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3542% %
3543% %
3544% %
3545% S e t I m a g e V i r t u a l P i x e l M e t h o d %
3546% %
3547% %
3548% %
3549%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3550%
3551% SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3552% image and returns the previous setting. A virtual pixel is any pixel access
3553% that is outside the boundaries of the image cache.
3554%
3555% The format of the SetImageVirtualPixelMethod() method is:
3556%
3557% VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3558% const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3559%
3560% A description of each parameter follows:
3561%
3562% o image: the image.
3563%
3564% o virtual_pixel_method: choose the type of virtual pixel.
3565%
3566% o exception: return any errors or warnings in this structure.
3567%
3568*/
3569MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3570 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3571{
3572 assert(image != (const Image *) NULL);
3573 assert(image->signature == MagickCoreSignature);
3574 if (IsEventLogging() != MagickFalse)
3575 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3576 return(SetPixelCacheVirtualMethod(image,virtual_pixel_method,exception));
3577}
3578␌
3579/*
3580%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3581% %
3582% %
3583% %
3584% S m u s h I m a g e s %
3585% %
3586% %
3587% %
3588%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3589%
3590% SmushImages() takes all images from the current image pointer to the end
3591% of the image list and smushes them to each other top-to-bottom if the
3592% stack parameter is true, otherwise left-to-right.
3593%
3594% The current gravity setting now effects how the image is justified in the
3595% final image.
3596%
3597% The format of the SmushImages method is:
3598%
3599% Image *SmushImages(const Image *images,const MagickBooleanType stack,
3600% ExceptionInfo *exception)
3601%
3602% A description of each parameter follows:
3603%
3604% o images: the image sequence.
3605%
3606% o stack: A value other than 0 stacks the images top-to-bottom.
3607%
3608% o offset: minimum distance in pixels between images.
3609%
3610% o exception: return any errors or warnings in this structure.
3611%
3612*/
3613
3614static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3615 const ssize_t offset,ExceptionInfo *exception)
3616{
3617 CacheView
3618 *left_view,
3619 *right_view;
3620
3621 const Image
3622 *left_image,
3623 *right_image;
3624
3625 RectangleInfo
3626 left_geometry,
3627 right_geometry;
3628
3629 const Quantum
3630 *p;
3631
3632 ssize_t
3633 i,
3634 y;
3635
3636 size_t
3637 gap;
3638
3639 ssize_t
3640 x;
3641
3642 if (images->previous == (Image *) NULL)
3643 return(0);
3644 right_image=images;
3645 SetGeometry(smush_image,&right_geometry);
3646 GravityAdjustGeometry(right_image->columns,right_image->rows,
3647 right_image->gravity,&right_geometry);
3648 left_image=images->previous;
3649 SetGeometry(smush_image,&left_geometry);
3650 GravityAdjustGeometry(left_image->columns,left_image->rows,
3651 left_image->gravity,&left_geometry);
3652 gap=right_image->columns;
3653 left_view=AcquireVirtualCacheView(left_image,exception);
3654 right_view=AcquireVirtualCacheView(right_image,exception);
3655 for (y=0; y < (ssize_t) smush_image->rows; y++)
3656 {
3657 for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3658 {
3659 p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3660 if ((p == (const Quantum *) NULL) ||
3661 (GetPixelAlpha(left_image,p) != TransparentAlpha) ||
3662 (((ssize_t) left_image->columns-x-1) >= (ssize_t) gap))
3663 break;
3664 }
3665 i=(ssize_t) left_image->columns-x-1;
3666 for (x=0; x < (ssize_t) right_image->columns; x++)
3667 {
3668 p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3669 exception);
3670 if ((p == (const Quantum *) NULL) ||
3671 (GetPixelAlpha(right_image,p) != TransparentAlpha) ||
3672 ((x+i) >= (ssize_t) gap))
3673 break;
3674 }
3675 if ((x+i) < (ssize_t) gap)
3676 gap=(size_t) (x+i);
3677 }
3678 right_view=DestroyCacheView(right_view);
3679 left_view=DestroyCacheView(left_view);
3680 if (y < (ssize_t) smush_image->rows)
3681 return(offset);
3682 return((ssize_t) gap-offset);
3683}
3684
3685static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3686 const ssize_t offset,ExceptionInfo *exception)
3687{
3688 CacheView
3689 *bottom_view,
3690 *top_view;
3691
3692 const Image
3693 *bottom_image,
3694 *top_image;
3695
3696 RectangleInfo
3697 bottom_geometry,
3698 top_geometry;
3699
3700 const Quantum
3701 *p;
3702
3703 ssize_t
3704 i,
3705 x;
3706
3707 size_t
3708 gap;
3709
3710 ssize_t
3711 y;
3712
3713 if (images->previous == (Image *) NULL)
3714 return(0);
3715 bottom_image=images;
3716 SetGeometry(smush_image,&bottom_geometry);
3717 GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3718 bottom_image->gravity,&bottom_geometry);
3719 top_image=images->previous;
3720 SetGeometry(smush_image,&top_geometry);
3721 GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3722 &top_geometry);
3723 gap=bottom_image->rows;
3724 top_view=AcquireVirtualCacheView(top_image,exception);
3725 bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3726 for (x=0; x < (ssize_t) smush_image->columns; x++)
3727 {
3728 for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3729 {
3730 p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3731 if ((p == (const Quantum *) NULL) ||
3732 (GetPixelAlpha(top_image,p) != TransparentAlpha) ||
3733 (((ssize_t) top_image->rows-y-1) >= (ssize_t) gap))
3734 break;
3735 }
3736 i=(ssize_t) top_image->rows-y-1;
3737 for (y=0; y < (ssize_t) bottom_image->rows; y++)
3738 {
3739 p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3740 exception);
3741 if ((p == (const Quantum *) NULL) ||
3742 (GetPixelAlpha(bottom_image,p) != TransparentAlpha) ||
3743 ((y+i) >= (ssize_t) gap))
3744 break;
3745 }
3746 if ((y+i) < (ssize_t) gap)
3747 gap=(size_t) (y+i);
3748 }
3749 bottom_view=DestroyCacheView(bottom_view);
3750 top_view=DestroyCacheView(top_view);
3751 if (x < (ssize_t) smush_image->columns)
3752 return(offset);
3753 return((ssize_t) gap-offset);
3754}
3755
3756MagickExport Image *SmushImages(const Image *images,
3757 const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3758{
3759#define SmushImageTag "Smush/Image"
3760
3761 const Image
3762 *image;
3763
3764 Image
3765 *smush_image;
3766
3767 MagickBooleanType
3768 proceed,
3769 status;
3770
3771 MagickOffsetType
3772 n;
3773
3774 PixelTrait
3775 alpha_trait;
3776
3777 RectangleInfo
3778 geometry;
3779
3780 const Image
3781 *next;
3782
3783 size_t
3784 height,
3785 number_images,
3786 width;
3787
3788 ssize_t
3789 x_offset,
3790 y_offset;
3791
3792 /*
3793 Compute maximum area of smushed area.
3794 */
3795 assert(images != (Image *) NULL);
3796 assert(images->signature == MagickCoreSignature);
3797 assert(exception != (ExceptionInfo *) NULL);
3798 assert(exception->signature == MagickCoreSignature);
3799 if (IsEventLogging() != MagickFalse)
3800 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3801 image=images;
3802 alpha_trait=image->alpha_trait;
3803 number_images=1;
3804 width=image->columns;
3805 height=image->rows;
3806 next=GetNextImageInList(image);
3807 for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3808 {
3809 if (next->alpha_trait != UndefinedPixelTrait)
3810 alpha_trait=BlendPixelTrait;
3811 number_images++;
3812 if (stack != MagickFalse)
3813 {
3814 if (next->columns > width)
3815 width=next->columns;
3816 height+=next->rows;
3817 if (next->previous != (Image *) NULL)
3818 height=(size_t) MagickMax((ssize_t) height+offset,0U);
3819 continue;
3820 }
3821 width+=next->columns;
3822 if (next->previous != (Image *) NULL)
3823 width=(size_t) MagickMax((ssize_t) width+offset,0U);
3824 if (next->rows > height)
3825 height=next->rows;
3826 }
3827 /*
3828 Smush images.
3829 */
3830 smush_image=CloneImage(image,width,height,MagickTrue,exception);
3831 if (smush_image == (Image *) NULL)
3832 return((Image *) NULL);
3833 if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse)
3834 {
3835 smush_image=DestroyImage(smush_image);
3836 return((Image *) NULL);
3837 }
3838 smush_image->alpha_trait=alpha_trait;
3839 (void) SetImageBackgroundColor(smush_image,exception);
3840 status=MagickTrue;
3841 x_offset=0;
3842 y_offset=0;
3843 for (n=0; n < (MagickOffsetType) number_images; n++)
3844 {
3845 SetGeometry(smush_image,&geometry);
3846 GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3847 if (stack != MagickFalse)
3848 {
3849 x_offset-=geometry.x;
3850 y_offset-=SmushYGap(smush_image,image,offset,exception);
3851 }
3852 else
3853 {
3854 x_offset-=SmushXGap(smush_image,image,offset,exception);
3855 y_offset-=geometry.y;
3856 }
3857 status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset,
3858 y_offset,exception);
3859 proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3860 if (proceed == MagickFalse)
3861 break;
3862 if (stack == MagickFalse)
3863 {
3864 x_offset+=(ssize_t) image->columns;
3865 y_offset=0;
3866 }
3867 else
3868 {
3869 x_offset=0;
3870 y_offset+=(ssize_t) image->rows;
3871 }
3872 image=GetNextImageInList(image);
3873 }
3874 if (stack == MagickFalse)
3875 smush_image->columns=(size_t) x_offset;
3876 else
3877 smush_image->rows=(size_t) y_offset;
3878 if (status == MagickFalse)
3879 smush_image=DestroyImage(smush_image);
3880 return(smush_image);
3881}
3882␌
3883/*
3884%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3885% %
3886% %
3887% %
3888% S t r i p I m a g e %
3889% %
3890% %
3891% %
3892%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3893%
3894% StripImage() strips an image of all profiles and comments.
3895%
3896% The format of the StripImage method is:
3897%
3898% MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
3899%
3900% A description of each parameter follows:
3901%
3902% o image: the image.
3903%
3904% o exception: return any errors or warnings in this structure.
3905%
3906*/
3907MagickExport MagickBooleanType StripImage(Image *image,
3908 ExceptionInfo *magick_unused(exception))
3909{
3910 MagickBooleanType
3911 status;
3912
3913 magick_unreferenced(exception);
3914 assert(image != (Image *) NULL);
3915 if (IsEventLogging() != MagickFalse)
3916 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3917 DestroyImageProfiles(image);
3918 (void) DeleteImageProperty(image,"comment");
3919 (void) DeleteImageProperty(image,"date:create");
3920 (void) DeleteImageProperty(image,"date:modify");
3921 (void) DeleteImageProperty(image,"date:timestamp");
3922 status=SetImageArtifact(image,"png:exclude-chunk",
3923 "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3924 return(status);
3925}
3926␌
3927/*
3928%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3929% %
3930% %
3931% %
3932+ S y n c I m a g e %
3933% %
3934% %
3935% %
3936%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3937%
3938% SyncImage() initializes the red, green, and blue intensities of each pixel
3939% as defined by the colormap index.
3940%
3941% The format of the SyncImage method is:
3942%
3943% MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3944%
3945% A description of each parameter follows:
3946%
3947% o image: the image.
3948%
3949% o exception: return any errors or warnings in this structure.
3950%
3951*/
3952
3953static inline Quantum PushColormapIndex(Image *image,const Quantum index,
3954 MagickBooleanType *range_exception)
3955{
3956 if ((size_t) index < image->colors)
3957 return(index);
3958 *range_exception=MagickTrue;
3959 return((Quantum) 0);
3960}
3961
3962MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3963{
3964 CacheView
3965 *image_view;
3966
3967 MagickBooleanType
3968 range_exception,
3969 status,
3970 taint;
3971
3972 ssize_t
3973 y;
3974
3975 assert(image != (Image *) NULL);
3976 assert(image->signature == MagickCoreSignature);
3977 if (IsEventLogging() != MagickFalse)
3978 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3979 if (image->ping != MagickFalse)
3980 return(MagickTrue);
3981 if (image->storage_class != PseudoClass)
3982 return(MagickFalse);
3983 assert(image->colormap != (PixelInfo *) NULL);
3984 range_exception=MagickFalse;
3985 status=MagickTrue;
3986 taint=image->taint;
3987 image_view=AcquireAuthenticCacheView(image,exception);
3988#if defined(MAGICKCORE_OPENMP_SUPPORT)
3989 #pragma omp parallel for schedule(static) shared(range_exception,status) \
3990 magick_number_threads(image,image,image->rows,2)
3991#endif
3992 for (y=0; y < (ssize_t) image->rows; y++)
3993 {
3994 Quantum
3995 index;
3996
3997 Quantum
3998 *magick_restrict q;
3999
4000 ssize_t
4001 x;
4002
4003 if (status == MagickFalse)
4004 continue;
4005 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
4006 if (q == (Quantum *) NULL)
4007 {
4008 status=MagickFalse;
4009 continue;
4010 }
4011 for (x=0; x < (ssize_t) image->columns; x++)
4012 {
4013 index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
4014 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
4015 q+=(ptrdiff_t) GetPixelChannels(image);
4016 }
4017 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
4018 status=MagickFalse;
4019 }
4020 image_view=DestroyCacheView(image_view);
4021 image->taint=taint;
4022 if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
4023 (void) ThrowMagickException(exception,GetMagickModule(),
4024 CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
4025 return(status);
4026}
4027␌
4028/*
4029%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4030% %
4031% %
4032% %
4033% S y n c I m a g e S e t t i n g s %
4034% %
4035% %
4036% %
4037%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4038%
4039% SyncImageSettings() syncs any image_info global options into per-image
4040% attributes.
4041%
4042% Note: in IMv6 free form 'options' were always mapped into 'artifacts', so
4043% that operations and coders can find such settings. In IMv7 if a desired
4044% per-image artifact is not set, then it will directly look for a global
4045% option as a fallback, as such this copy is no longer needed, only the
4046% link set up.
4047%
4048% The format of the SyncImageSettings method is:
4049%
4050% MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4051% Image *image,ExceptionInfo *exception)
4052% MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
4053% Image *image,ExceptionInfo *exception)
4054%
4055% A description of each parameter follows:
4056%
4057% o image_info: the image info.
4058%
4059% o image: the image.
4060%
4061% o exception: return any errors or warnings in this structure.
4062%
4063*/
4064
4065MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
4066 Image *images,ExceptionInfo *exception)
4067{
4068 Image
4069 *image;
4070
4071 assert(image_info != (const ImageInfo *) NULL);
4072 assert(image_info->signature == MagickCoreSignature);
4073 assert(images != (Image *) NULL);
4074 assert(images->signature == MagickCoreSignature);
4075 if (IsEventLogging() != MagickFalse)
4076 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
4077 image=images;
4078 for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
4079 (void) SyncImageSettings(image_info,image,exception);
4080 (void) DeleteImageOption(image_info,"page");
4081 return(MagickTrue);
4082}
4083
4084MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4085 Image *image,ExceptionInfo *exception)
4086{
4087 const char
4088 *option;
4089
4090 GeometryInfo
4091 geometry_info;
4092
4093 MagickStatusType
4094 flags;
4095
4096 ResolutionType
4097 units;
4098
4099 /*
4100 Sync image options.
4101 */
4102 assert(image_info != (const ImageInfo *) NULL);
4103 assert(image_info->signature == MagickCoreSignature);
4104 assert(image != (Image *) NULL);
4105 assert(image->signature == MagickCoreSignature);
4106 if (IsEventLogging() != MagickFalse)
4107 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4108 option=GetImageOption(image_info,"background");
4109 if (option != (const char *) NULL)
4110 (void) QueryColorCompliance(option,AllCompliance,&image->background_color,
4111 exception);
4112 option=GetImageOption(image_info,"black-point-compensation");
4113 if (option != (const char *) NULL)
4114 image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
4115 MagickBooleanOptions,MagickFalse,option);
4116 option=GetImageOption(image_info,"blue-primary");
4117 if (option != (const char *) NULL)
4118 {
4119 flags=ParseGeometry(option,&geometry_info);
4120 if ((flags & RhoValue) != 0)
4121 image->chromaticity.blue_primary.x=geometry_info.rho;
4122 image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
4123 if ((flags & SigmaValue) != 0)
4124 image->chromaticity.blue_primary.y=geometry_info.sigma;
4125 }
4126 option=GetImageOption(image_info,"bordercolor");
4127 if (option != (const char *) NULL)
4128 (void) QueryColorCompliance(option,AllCompliance,&image->border_color,
4129 exception);
4130 /* FUTURE: do not sync compose to per-image compose setting here */
4131 option=GetImageOption(image_info,"compose");
4132 if (option != (const char *) NULL)
4133 image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
4134 MagickFalse,option);
4135 /* -- */
4136 option=GetImageOption(image_info,"compress");
4137 if (option != (const char *) NULL)
4138 image->compression=(CompressionType) ParseCommandOption(
4139 MagickCompressOptions,MagickFalse,option);
4140 option=GetImageOption(image_info,"debug");
4141 if (option != (const char *) NULL)
4142 image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4143 MagickFalse,option);
4144 option=GetImageOption(image_info,"density");
4145 if (option != (const char *) NULL)
4146 {
4147 flags=ParseGeometry(option,&geometry_info);
4148 if ((flags & RhoValue) != 0)
4149 image->resolution.x=geometry_info.rho;
4150 image->resolution.y=image->resolution.x;
4151 if ((flags & SigmaValue) != 0)
4152 image->resolution.y=geometry_info.sigma;
4153 }
4154 option=GetImageOption(image_info,"depth");
4155 if (option != (const char *) NULL)
4156 image->depth=StringToUnsignedLong(option);
4157 option=GetImageOption(image_info,"endian");
4158 if (option != (const char *) NULL)
4159 image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
4160 MagickFalse,option);
4161 option=GetImageOption(image_info,"filter");
4162 if (option != (const char *) NULL)
4163 image->filter=(FilterType) ParseCommandOption(MagickFilterOptions,
4164 MagickFalse,option);
4165 option=GetImageOption(image_info,"fuzz");
4166 if (option != (const char *) NULL)
4167 image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
4168 option=GetImageOption(image_info,"gravity");
4169 if (option != (const char *) NULL)
4170 image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
4171 MagickFalse,option);
4172 option=GetImageOption(image_info,"green-primary");
4173 if (option != (const char *) NULL)
4174 {
4175 flags=ParseGeometry(option,&geometry_info);
4176 if ((flags & RhoValue) != 0)
4177 image->chromaticity.green_primary.x=geometry_info.rho;
4178 image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
4179 if ((flags & SigmaValue) != 0)
4180 image->chromaticity.green_primary.y=geometry_info.sigma;
4181 }
4182 option=GetImageOption(image_info,"intent");
4183 if (option != (const char *) NULL)
4184 image->rendering_intent=(RenderingIntent) ParseCommandOption(
4185 MagickIntentOptions,MagickFalse,option);
4186 option=GetImageOption(image_info,"intensity");
4187 if (option != (const char *) NULL)
4188 image->intensity=(PixelIntensityMethod) ParseCommandOption(
4189 MagickPixelIntensityOptions,MagickFalse,option);
4190 option=GetImageOption(image_info,"interlace");
4191 if (option != (const char *) NULL)
4192 image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
4193 MagickFalse,option);
4194 option=GetImageOption(image_info,"interpolate");
4195 if (option != (const char *) NULL)
4196 image->interpolate=(PixelInterpolateMethod) ParseCommandOption(
4197 MagickInterpolateOptions,MagickFalse,option);
4198 option=GetImageOption(image_info,"loop");
4199 if (option != (const char *) NULL)
4200 image->iterations=StringToUnsignedLong(option);
4201 option=GetImageOption(image_info,"mattecolor");
4202 if (option != (const char *) NULL)
4203 (void) QueryColorCompliance(option,AllCompliance,&image->matte_color,
4204 exception);
4205 option=GetImageOption(image_info,"orient");
4206 if (option != (const char *) NULL)
4207 image->orientation=(OrientationType) ParseCommandOption(
4208 MagickOrientationOptions,MagickFalse,option);
4209 option=GetImageOption(image_info,"page");
4210 if (option != (const char *) NULL)
4211 {
4212 char
4213 *geometry;
4214
4215 geometry=GetPageGeometry(option);
4216 flags=ParseAbsoluteGeometry(geometry,&image->page);
4217 geometry=DestroyString(geometry);
4218 }
4219 option=GetImageOption(image_info,"quality");
4220 if (option != (const char *) NULL)
4221 image->quality=StringToUnsignedLong(option);
4222 option=GetImageOption(image_info,"red-primary");
4223 if (option != (const char *) NULL)
4224 {
4225 flags=ParseGeometry(option,&geometry_info);
4226 if ((flags & RhoValue) != 0)
4227 image->chromaticity.red_primary.x=geometry_info.rho;
4228 image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
4229 if ((flags & SigmaValue) != 0)
4230 image->chromaticity.red_primary.y=geometry_info.sigma;
4231 }
4232 if (image_info->quality != UndefinedCompressionQuality)
4233 image->quality=image_info->quality;
4234 option=GetImageOption(image_info,"scene");
4235 if (option != (const char *) NULL)
4236 image->scene=StringToUnsignedLong(option);
4237 option=GetImageOption(image_info,"taint");
4238 if (option != (const char *) NULL)
4239 image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4240 MagickFalse,option);
4241 option=GetImageOption(image_info,"tile-offset");
4242 if (option != (const char *) NULL)
4243 {
4244 char
4245 *geometry;
4246
4247 geometry=GetPageGeometry(option);
4248 flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4249 geometry=DestroyString(geometry);
4250 }
4251 option=GetImageOption(image_info,"transparent-color");
4252 if (option != (const char *) NULL)
4253 (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color,
4254 exception);
4255 option=GetImageOption(image_info,"type");
4256 if (option != (const char *) NULL)
4257 image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
4258 option);
4259 option=GetImageOption(image_info,"units");
4260 units=image_info->units;
4261 if (option != (const char *) NULL)
4262 units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
4263 MagickFalse,option);
4264 if (units != UndefinedResolution)
4265 {
4266 if (image->units != units)
4267 switch (image->units)
4268 {
4269 case PixelsPerInchResolution:
4270 {
4271 if (units == PixelsPerCentimeterResolution)
4272 {
4273 image->resolution.x/=2.54;
4274 image->resolution.y/=2.54;
4275 }
4276 break;
4277 }
4278 case PixelsPerCentimeterResolution:
4279 {
4280 if (units == PixelsPerInchResolution)
4281 {
4282 image->resolution.x=(double) ((size_t) (100.0*2.54*
4283 image->resolution.x+0.5))/100.0;
4284 image->resolution.y=(double) ((size_t) (100.0*2.54*
4285 image->resolution.y+0.5))/100.0;
4286 }
4287 break;
4288 }
4289 default:
4290 break;
4291 }
4292 image->units=units;
4293 option=GetImageOption(image_info,"density");
4294 if (option != (const char *) NULL)
4295 {
4296 flags=ParseGeometry(option,&geometry_info);
4297 if ((flags & RhoValue) != 0)
4298 image->resolution.x=geometry_info.rho;
4299 image->resolution.y=image->resolution.x;
4300 if ((flags & SigmaValue) != 0)
4301 image->resolution.y=geometry_info.sigma;
4302 }
4303 }
4304 option=GetImageOption(image_info,"virtual-pixel");
4305 if (option != (const char *) NULL)
4306 (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
4307 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option),
4308 exception);
4309 option=GetImageOption(image_info,"white-point");
4310 if (option != (const char *) NULL)
4311 {
4312 flags=ParseGeometry(option,&geometry_info);
4313 if ((flags & RhoValue) != 0)
4314 image->chromaticity.white_point.x=geometry_info.rho;
4315 image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4316 if ((flags & SigmaValue) != 0)
4317 image->chromaticity.white_point.y=geometry_info.sigma;
4318 }
4319 /*
4320 Pointer to allow the lookup of pre-image artifact will fallback to a global
4321 option setting/define. This saves a lot of duplication of global options
4322 into per-image artifacts, while ensuring only specifically set per-image
4323 artifacts are preserved when parenthesis ends.
4324 */
4325 if (image->image_info != (ImageInfo *) NULL)
4326 image->image_info=DestroyImageInfo(image->image_info);
4327 image->image_info=CloneImageInfo(image_info);
4328 return(MagickTrue);
4329}