MagickCore 7.1.2-19
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 image->mask_trait=UpdatePixelTrait;
3324 mask_view=AcquireVirtualCacheView(mask,exception);
3325 image_view=AcquireAuthenticCacheView(image,exception);
3326#if defined(MAGICKCORE_OPENMP_SUPPORT)
3327 #pragma omp parallel for schedule(static) shared(status) \
3328 magick_number_threads(mask,image,image->rows,2)
3329#endif
3330 for (y=0; y < (ssize_t) image->rows; y++)
3331 {
3332 const Quantum
3333 *magick_restrict p;
3334
3335 Quantum
3336 *magick_restrict q;
3337
3338 ssize_t
3339 x;
3340
3341 if (status == MagickFalse)
3342 continue;
3343 p=GetCacheViewVirtualPixels(mask_view,0,y,mask->columns,1,exception);
3344 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3345 if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
3346 {
3347 status=MagickFalse;
3348 continue;
3349 }
3350 for (x=0; x < (ssize_t) image->columns; x++)
3351 {
3352 MagickRealType
3353 intensity;
3354
3355 intensity=0.0;
3356 if ((x < (ssize_t) mask->columns) && (y < (ssize_t) mask->rows))
3357 intensity=GetPixelIntensity(mask,p);
3358 switch (type)
3359 {
3360 case ReadPixelMask:
3361 {
3362 SetPixelReadMask(image,ClampToQuantum(intensity),q);
3363 break;
3364 }
3365 case WritePixelMask:
3366 {
3367 SetPixelWriteMask(image,ClampToQuantum(intensity),q);
3368 break;
3369 }
3370 default:
3371 {
3372 SetPixelCompositeMask(image,ClampToQuantum(intensity),q);
3373 break;
3374 }
3375 }
3376 p+=(ptrdiff_t) GetPixelChannels(mask);
3377 q+=(ptrdiff_t) GetPixelChannels(image);
3378 }
3379 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3380 status=MagickFalse;
3381 }
3382 image->mask_trait=UndefinedPixelTrait;
3383 mask_view=DestroyCacheView(mask_view);
3384 image_view=DestroyCacheView(image_view);
3385 return(status);
3386}
3387␌
3388/*
3389%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3390% %
3391% %
3392% %
3393% S e t I m a g e R e g i o n M a s k %
3394% %
3395% %
3396% %
3397%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3398%
3399% SetImageRegionMask() associates a mask with the image as defined by the
3400% specified region.
3401%
3402% The format of the SetImageRegionMask method is:
3403%
3404% MagickBooleanType SetImageRegionMask(Image *image,const PixelMask type,
3405% const RectangleInfo *region,ExceptionInfo *exception)
3406%
3407% A description of each parameter follows:
3408%
3409% o image: the image.
3410%
3411% o type: the mask type, ReadPixelMask or WritePixelMask.
3412%
3413% o geometry: the mask region.
3414%
3415% o exception: return any errors or warnings in this structure.
3416%
3417*/
3418MagickExport MagickBooleanType SetImageRegionMask(Image *image,
3419 const PixelMask type,const RectangleInfo *region,ExceptionInfo *exception)
3420{
3421 CacheView
3422 *image_view;
3423
3424 MagickBooleanType
3425 status;
3426
3427 ssize_t
3428 y;
3429
3430 /*
3431 Set image mask as defined by the region.
3432 */
3433 assert(image != (Image *) NULL);
3434 assert(image->signature == MagickCoreSignature);
3435 if (IsEventLogging() != MagickFalse)
3436 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3437 if (region == (const RectangleInfo *) NULL)
3438 {
3439 switch (type)
3440 {
3441 case ReadPixelMask:
3442 {
3443 image->channels=(ChannelType) ((unsigned int) image->channels &
3444 (unsigned int) ~ReadMaskChannel);
3445 break;
3446 }
3447 case WritePixelMask:
3448 {
3449 image->channels=(ChannelType) ((unsigned int) image->channels &
3450 (unsigned int) ~WriteMaskChannel);
3451 break;
3452 }
3453 default:
3454 {
3455 image->channels=(ChannelType) ((unsigned int) image->channels &
3456 (unsigned int) ~CompositeMaskChannel);
3457 break;
3458 }
3459 }
3460 return(SyncImagePixelCache(image,exception));
3461 }
3462 switch (type)
3463 {
3464 case ReadPixelMask:
3465 {
3466 image->channels=(ChannelType) (image->channels | ReadMaskChannel);
3467 break;
3468 }
3469 case WritePixelMask:
3470 {
3471 image->channels=(ChannelType) (image->channels | WriteMaskChannel);
3472 break;
3473 }
3474 default:
3475 {
3476 image->channels=(ChannelType) (image->channels | CompositeMaskChannel);
3477 break;
3478 }
3479 }
3480 if (SyncImagePixelCache(image,exception) == MagickFalse)
3481 return(MagickFalse);
3482 status=MagickTrue;
3483 image->mask_trait=UpdatePixelTrait;
3484 image_view=AcquireAuthenticCacheView(image,exception);
3485#if defined(MAGICKCORE_OPENMP_SUPPORT)
3486 #pragma omp parallel for schedule(static) shared(status) \
3487 magick_number_threads(image,image,image->rows,2)
3488#endif
3489 for (y=0; y < (ssize_t) image->rows; y++)
3490 {
3491 Quantum
3492 *magick_restrict q;
3493
3494 ssize_t
3495 x;
3496
3497 if (status == MagickFalse)
3498 continue;
3499 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
3500 if (q == (Quantum *) NULL)
3501 {
3502 status=MagickFalse;
3503 continue;
3504 }
3505 for (x=0; x < (ssize_t) image->columns; x++)
3506 {
3507 Quantum
3508 pixel;
3509
3510 pixel=QuantumRange;
3511 if (((x >= region->x) && (x < (region->x+(ssize_t) region->width))) &&
3512 ((y >= region->y) && (y < (region->y+(ssize_t) region->height))))
3513 pixel=(Quantum) 0;
3514 switch (type)
3515 {
3516 case ReadPixelMask:
3517 {
3518 SetPixelReadMask(image,pixel,q);
3519 break;
3520 }
3521 case WritePixelMask:
3522 {
3523 SetPixelWriteMask(image,pixel,q);
3524 break;
3525 }
3526 default:
3527 {
3528 SetPixelCompositeMask(image,pixel,q);
3529 break;
3530 }
3531 }
3532 q+=(ptrdiff_t) GetPixelChannels(image);
3533 }
3534 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
3535 status=MagickFalse;
3536 }
3537 image->mask_trait=UndefinedPixelTrait;
3538 image_view=DestroyCacheView(image_view);
3539 return(status);
3540}
3541␌
3542/*
3543%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3544% %
3545% %
3546% %
3547% 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 %
3548% %
3549% %
3550% %
3551%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3552%
3553% SetImageVirtualPixelMethod() sets the "virtual pixels" method for the
3554% image and returns the previous setting. A virtual pixel is any pixel access
3555% that is outside the boundaries of the image cache.
3556%
3557% The format of the SetImageVirtualPixelMethod() method is:
3558%
3559% VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3560% const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3561%
3562% A description of each parameter follows:
3563%
3564% o image: the image.
3565%
3566% o virtual_pixel_method: choose the type of virtual pixel.
3567%
3568% o exception: return any errors or warnings in this structure.
3569%
3570*/
3571MagickExport VirtualPixelMethod SetImageVirtualPixelMethod(Image *image,
3572 const VirtualPixelMethod virtual_pixel_method,ExceptionInfo *exception)
3573{
3574 assert(image != (const Image *) NULL);
3575 assert(image->signature == MagickCoreSignature);
3576 if (IsEventLogging() != MagickFalse)
3577 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3578 return(SetPixelCacheVirtualMethod(image,virtual_pixel_method,exception));
3579}
3580␌
3581/*
3582%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3583% %
3584% %
3585% %
3586% S m u s h I m a g e s %
3587% %
3588% %
3589% %
3590%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3591%
3592% SmushImages() takes all images from the current image pointer to the end
3593% of the image list and smushes them to each other top-to-bottom if the
3594% stack parameter is true, otherwise left-to-right.
3595%
3596% The current gravity setting now effects how the image is justified in the
3597% final image.
3598%
3599% The format of the SmushImages method is:
3600%
3601% Image *SmushImages(const Image *images,const MagickBooleanType stack,
3602% ExceptionInfo *exception)
3603%
3604% A description of each parameter follows:
3605%
3606% o images: the image sequence.
3607%
3608% o stack: A value other than 0 stacks the images top-to-bottom.
3609%
3610% o offset: minimum distance in pixels between images.
3611%
3612% o exception: return any errors or warnings in this structure.
3613%
3614*/
3615
3616static ssize_t SmushXGap(const Image *smush_image,const Image *images,
3617 const ssize_t offset,ExceptionInfo *exception)
3618{
3619 CacheView
3620 *left_view,
3621 *right_view;
3622
3623 const Image
3624 *left_image,
3625 *right_image;
3626
3627 RectangleInfo
3628 left_geometry,
3629 right_geometry;
3630
3631 const Quantum
3632 *p;
3633
3634 ssize_t
3635 i,
3636 y;
3637
3638 size_t
3639 gap;
3640
3641 ssize_t
3642 x;
3643
3644 if (images->previous == (Image *) NULL)
3645 return(0);
3646 right_image=images;
3647 SetGeometry(smush_image,&right_geometry);
3648 GravityAdjustGeometry(right_image->columns,right_image->rows,
3649 right_image->gravity,&right_geometry);
3650 left_image=images->previous;
3651 SetGeometry(smush_image,&left_geometry);
3652 GravityAdjustGeometry(left_image->columns,left_image->rows,
3653 left_image->gravity,&left_geometry);
3654 gap=right_image->columns;
3655 left_view=AcquireVirtualCacheView(left_image,exception);
3656 right_view=AcquireVirtualCacheView(right_image,exception);
3657 for (y=0; y < (ssize_t) smush_image->rows; y++)
3658 {
3659 for (x=(ssize_t) left_image->columns-1; x > 0; x--)
3660 {
3661 p=GetCacheViewVirtualPixels(left_view,x,left_geometry.y+y,1,1,exception);
3662 if ((p == (const Quantum *) NULL) ||
3663 (GetPixelAlpha(left_image,p) != TransparentAlpha) ||
3664 (((ssize_t) left_image->columns-x-1) >= (ssize_t) gap))
3665 break;
3666 }
3667 i=(ssize_t) left_image->columns-x-1;
3668 for (x=0; x < (ssize_t) right_image->columns; x++)
3669 {
3670 p=GetCacheViewVirtualPixels(right_view,x,right_geometry.y+y,1,1,
3671 exception);
3672 if ((p == (const Quantum *) NULL) ||
3673 (GetPixelAlpha(right_image,p) != TransparentAlpha) ||
3674 ((x+i) >= (ssize_t) gap))
3675 break;
3676 }
3677 if ((x+i) < (ssize_t) gap)
3678 gap=(size_t) (x+i);
3679 }
3680 right_view=DestroyCacheView(right_view);
3681 left_view=DestroyCacheView(left_view);
3682 if (y < (ssize_t) smush_image->rows)
3683 return(offset);
3684 return((ssize_t) gap-offset);
3685}
3686
3687static ssize_t SmushYGap(const Image *smush_image,const Image *images,
3688 const ssize_t offset,ExceptionInfo *exception)
3689{
3690 CacheView
3691 *bottom_view,
3692 *top_view;
3693
3694 const Image
3695 *bottom_image,
3696 *top_image;
3697
3698 RectangleInfo
3699 bottom_geometry,
3700 top_geometry;
3701
3702 const Quantum
3703 *p;
3704
3705 ssize_t
3706 i,
3707 x;
3708
3709 size_t
3710 gap;
3711
3712 ssize_t
3713 y;
3714
3715 if (images->previous == (Image *) NULL)
3716 return(0);
3717 bottom_image=images;
3718 SetGeometry(smush_image,&bottom_geometry);
3719 GravityAdjustGeometry(bottom_image->columns,bottom_image->rows,
3720 bottom_image->gravity,&bottom_geometry);
3721 top_image=images->previous;
3722 SetGeometry(smush_image,&top_geometry);
3723 GravityAdjustGeometry(top_image->columns,top_image->rows,top_image->gravity,
3724 &top_geometry);
3725 gap=bottom_image->rows;
3726 top_view=AcquireVirtualCacheView(top_image,exception);
3727 bottom_view=AcquireVirtualCacheView(bottom_image,exception);
3728 for (x=0; x < (ssize_t) smush_image->columns; x++)
3729 {
3730 for (y=(ssize_t) top_image->rows-1; y > 0; y--)
3731 {
3732 p=GetCacheViewVirtualPixels(top_view,top_geometry.x+x,y,1,1,exception);
3733 if ((p == (const Quantum *) NULL) ||
3734 (GetPixelAlpha(top_image,p) != TransparentAlpha) ||
3735 (((ssize_t) top_image->rows-y-1) >= (ssize_t) gap))
3736 break;
3737 }
3738 i=(ssize_t) top_image->rows-y-1;
3739 for (y=0; y < (ssize_t) bottom_image->rows; y++)
3740 {
3741 p=GetCacheViewVirtualPixels(bottom_view,bottom_geometry.x+x,y,1,1,
3742 exception);
3743 if ((p == (const Quantum *) NULL) ||
3744 (GetPixelAlpha(bottom_image,p) != TransparentAlpha) ||
3745 ((y+i) >= (ssize_t) gap))
3746 break;
3747 }
3748 if ((y+i) < (ssize_t) gap)
3749 gap=(size_t) (y+i);
3750 }
3751 bottom_view=DestroyCacheView(bottom_view);
3752 top_view=DestroyCacheView(top_view);
3753 if (x < (ssize_t) smush_image->columns)
3754 return(offset);
3755 return((ssize_t) gap-offset);
3756}
3757
3758MagickExport Image *SmushImages(const Image *images,
3759 const MagickBooleanType stack,const ssize_t offset,ExceptionInfo *exception)
3760{
3761#define SmushImageTag "Smush/Image"
3762
3763 const Image
3764 *image;
3765
3766 Image
3767 *smush_image;
3768
3769 MagickBooleanType
3770 proceed,
3771 status;
3772
3773 MagickOffsetType
3774 n;
3775
3776 PixelTrait
3777 alpha_trait;
3778
3779 RectangleInfo
3780 geometry;
3781
3782 const Image
3783 *next;
3784
3785 size_t
3786 height,
3787 number_images,
3788 width;
3789
3790 ssize_t
3791 x_offset,
3792 y_offset;
3793
3794 /*
3795 Compute maximum area of smushed area.
3796 */
3797 assert(images != (Image *) NULL);
3798 assert(images->signature == MagickCoreSignature);
3799 assert(exception != (ExceptionInfo *) NULL);
3800 assert(exception->signature == MagickCoreSignature);
3801 if (IsEventLogging() != MagickFalse)
3802 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
3803 image=images;
3804 alpha_trait=image->alpha_trait;
3805 number_images=1;
3806 width=image->columns;
3807 height=image->rows;
3808 next=GetNextImageInList(image);
3809 for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
3810 {
3811 if (next->alpha_trait != UndefinedPixelTrait)
3812 alpha_trait=BlendPixelTrait;
3813 number_images++;
3814 if (stack != MagickFalse)
3815 {
3816 if (next->columns > width)
3817 width=next->columns;
3818 height+=next->rows;
3819 if (next->previous != (Image *) NULL)
3820 height=(size_t) MagickMax((ssize_t) height+offset,0U);
3821 continue;
3822 }
3823 width+=next->columns;
3824 if (next->previous != (Image *) NULL)
3825 width=(size_t) MagickMax((ssize_t) width+offset,0U);
3826 if (next->rows > height)
3827 height=next->rows;
3828 }
3829 /*
3830 Smush images.
3831 */
3832 smush_image=CloneImage(image,width,height,MagickTrue,exception);
3833 if (smush_image == (Image *) NULL)
3834 return((Image *) NULL);
3835 if (SetImageStorageClass(smush_image,DirectClass,exception) == MagickFalse)
3836 {
3837 smush_image=DestroyImage(smush_image);
3838 return((Image *) NULL);
3839 }
3840 smush_image->alpha_trait=alpha_trait;
3841 (void) SetImageBackgroundColor(smush_image,exception);
3842 status=MagickTrue;
3843 x_offset=0;
3844 y_offset=0;
3845 for (n=0; n < (MagickOffsetType) number_images; n++)
3846 {
3847 SetGeometry(smush_image,&geometry);
3848 GravityAdjustGeometry(image->columns,image->rows,image->gravity,&geometry);
3849 if (stack != MagickFalse)
3850 {
3851 x_offset-=geometry.x;
3852 y_offset-=SmushYGap(smush_image,image,offset,exception);
3853 }
3854 else
3855 {
3856 x_offset-=SmushXGap(smush_image,image,offset,exception);
3857 y_offset-=geometry.y;
3858 }
3859 status=CompositeImage(smush_image,image,OverCompositeOp,MagickTrue,x_offset,
3860 y_offset,exception);
3861 proceed=SetImageProgress(image,SmushImageTag,n,number_images);
3862 if (proceed == MagickFalse)
3863 break;
3864 if (stack == MagickFalse)
3865 {
3866 x_offset+=(ssize_t) image->columns;
3867 y_offset=0;
3868 }
3869 else
3870 {
3871 x_offset=0;
3872 y_offset+=(ssize_t) image->rows;
3873 }
3874 image=GetNextImageInList(image);
3875 }
3876 if (stack == MagickFalse)
3877 smush_image->columns=(size_t) x_offset;
3878 else
3879 smush_image->rows=(size_t) y_offset;
3880 if (status == MagickFalse)
3881 smush_image=DestroyImage(smush_image);
3882 return(smush_image);
3883}
3884␌
3885/*
3886%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3887% %
3888% %
3889% %
3890% S t r i p I m a g e %
3891% %
3892% %
3893% %
3894%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3895%
3896% StripImage() strips an image of all profiles and comments.
3897%
3898% The format of the StripImage method is:
3899%
3900% MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
3901%
3902% A description of each parameter follows:
3903%
3904% o image: the image.
3905%
3906% o exception: return any errors or warnings in this structure.
3907%
3908*/
3909MagickExport MagickBooleanType StripImage(Image *image,
3910 ExceptionInfo *magick_unused(exception))
3911{
3912 MagickBooleanType
3913 status;
3914
3915 magick_unreferenced(exception);
3916 assert(image != (Image *) NULL);
3917 if (IsEventLogging() != MagickFalse)
3918 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3919 DestroyImageProfiles(image);
3920 (void) DeleteImageProperty(image,"comment");
3921 (void) DeleteImageProperty(image,"date:create");
3922 (void) DeleteImageProperty(image,"date:modify");
3923 (void) DeleteImageProperty(image,"date:timestamp");
3924 status=SetImageArtifact(image,"png:exclude-chunk",
3925 "bKGD,caNv,cHRM,eXIf,gAMA,iCCP,iTXt,pHYs,sRGB,tEXt,zCCP,zTXt,date");
3926 return(status);
3927}
3928␌
3929/*
3930%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3931% %
3932% %
3933% %
3934+ S y n c I m a g e %
3935% %
3936% %
3937% %
3938%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3939%
3940% SyncImage() initializes the red, green, and blue intensities of each pixel
3941% as defined by the colormap index.
3942%
3943% The format of the SyncImage method is:
3944%
3945% MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3946%
3947% A description of each parameter follows:
3948%
3949% o image: the image.
3950%
3951% o exception: return any errors or warnings in this structure.
3952%
3953*/
3954
3955static inline Quantum PushColormapIndex(Image *image,const Quantum index,
3956 MagickBooleanType *range_exception)
3957{
3958 if ((size_t) index < image->colors)
3959 return(index);
3960 *range_exception=MagickTrue;
3961 return((Quantum) 0);
3962}
3963
3964MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
3965{
3966 CacheView
3967 *image_view;
3968
3969 MagickBooleanType
3970 range_exception,
3971 status,
3972 taint;
3973
3974 ssize_t
3975 y;
3976
3977 assert(image != (Image *) NULL);
3978 assert(image->signature == MagickCoreSignature);
3979 if (IsEventLogging() != MagickFalse)
3980 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
3981 if (image->ping != MagickFalse)
3982 return(MagickTrue);
3983 if (image->storage_class != PseudoClass)
3984 return(MagickFalse);
3985 assert(image->colormap != (PixelInfo *) NULL);
3986 range_exception=MagickFalse;
3987 status=MagickTrue;
3988 taint=image->taint;
3989 image_view=AcquireAuthenticCacheView(image,exception);
3990#if defined(MAGICKCORE_OPENMP_SUPPORT)
3991 #pragma omp parallel for schedule(static) shared(range_exception,status) \
3992 magick_number_threads(image,image,image->rows,2)
3993#endif
3994 for (y=0; y < (ssize_t) image->rows; y++)
3995 {
3996 Quantum
3997 index;
3998
3999 Quantum
4000 *magick_restrict q;
4001
4002 ssize_t
4003 x;
4004
4005 if (status == MagickFalse)
4006 continue;
4007 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
4008 if (q == (Quantum *) NULL)
4009 {
4010 status=MagickFalse;
4011 continue;
4012 }
4013 for (x=0; x < (ssize_t) image->columns; x++)
4014 {
4015 index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
4016 SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
4017 q+=(ptrdiff_t) GetPixelChannels(image);
4018 }
4019 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
4020 status=MagickFalse;
4021 }
4022 image_view=DestroyCacheView(image_view);
4023 image->taint=taint;
4024 if ((image->ping == MagickFalse) && (range_exception != MagickFalse))
4025 (void) ThrowMagickException(exception,GetMagickModule(),
4026 CorruptImageWarning,"InvalidColormapIndex","`%s'",image->filename);
4027 return(status);
4028}
4029␌
4030/*
4031%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4032% %
4033% %
4034% %
4035% S y n c I m a g e S e t t i n g s %
4036% %
4037% %
4038% %
4039%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4040%
4041% SyncImageSettings() syncs any image_info global options into per-image
4042% attributes.
4043%
4044% Note: in IMv6 free form 'options' were always mapped into 'artifacts', so
4045% that operations and coders can find such settings. In IMv7 if a desired
4046% per-image artifact is not set, then it will directly look for a global
4047% option as a fallback, as such this copy is no longer needed, only the
4048% link set up.
4049%
4050% The format of the SyncImageSettings method is:
4051%
4052% MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4053% Image *image,ExceptionInfo *exception)
4054% MagickBooleanType SyncImagesSettings(const ImageInfo *image_info,
4055% Image *image,ExceptionInfo *exception)
4056%
4057% A description of each parameter follows:
4058%
4059% o image_info: the image info.
4060%
4061% o image: the image.
4062%
4063% o exception: return any errors or warnings in this structure.
4064%
4065*/
4066
4067MagickExport MagickBooleanType SyncImagesSettings(ImageInfo *image_info,
4068 Image *images,ExceptionInfo *exception)
4069{
4070 Image
4071 *image;
4072
4073 assert(image_info != (const ImageInfo *) NULL);
4074 assert(image_info->signature == MagickCoreSignature);
4075 assert(images != (Image *) NULL);
4076 assert(images->signature == MagickCoreSignature);
4077 if (IsEventLogging() != MagickFalse)
4078 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
4079 image=images;
4080 for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
4081 (void) SyncImageSettings(image_info,image,exception);
4082 (void) DeleteImageOption(image_info,"page");
4083 return(MagickTrue);
4084}
4085
4086MagickExport MagickBooleanType SyncImageSettings(const ImageInfo *image_info,
4087 Image *image,ExceptionInfo *exception)
4088{
4089 const char
4090 *option;
4091
4092 GeometryInfo
4093 geometry_info;
4094
4095 MagickStatusType
4096 flags;
4097
4098 ResolutionType
4099 units;
4100
4101 /*
4102 Sync image options.
4103 */
4104 assert(image_info != (const ImageInfo *) NULL);
4105 assert(image_info->signature == MagickCoreSignature);
4106 assert(image != (Image *) NULL);
4107 assert(image->signature == MagickCoreSignature);
4108 if (IsEventLogging() != MagickFalse)
4109 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4110 option=GetImageOption(image_info,"background");
4111 if (option != (const char *) NULL)
4112 (void) QueryColorCompliance(option,AllCompliance,&image->background_color,
4113 exception);
4114 option=GetImageOption(image_info,"black-point-compensation");
4115 if (option != (const char *) NULL)
4116 image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
4117 MagickBooleanOptions,MagickFalse,option);
4118 option=GetImageOption(image_info,"blue-primary");
4119 if (option != (const char *) NULL)
4120 {
4121 flags=ParseGeometry(option,&geometry_info);
4122 if ((flags & RhoValue) != 0)
4123 image->chromaticity.blue_primary.x=geometry_info.rho;
4124 image->chromaticity.blue_primary.y=image->chromaticity.blue_primary.x;
4125 if ((flags & SigmaValue) != 0)
4126 image->chromaticity.blue_primary.y=geometry_info.sigma;
4127 }
4128 option=GetImageOption(image_info,"bordercolor");
4129 if (option != (const char *) NULL)
4130 (void) QueryColorCompliance(option,AllCompliance,&image->border_color,
4131 exception);
4132 /* FUTURE: do not sync compose to per-image compose setting here */
4133 option=GetImageOption(image_info,"compose");
4134 if (option != (const char *) NULL)
4135 image->compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
4136 MagickFalse,option);
4137 /* -- */
4138 option=GetImageOption(image_info,"compress");
4139 if (option != (const char *) NULL)
4140 image->compression=(CompressionType) ParseCommandOption(
4141 MagickCompressOptions,MagickFalse,option);
4142 option=GetImageOption(image_info,"debug");
4143 if (option != (const char *) NULL)
4144 image->debug=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4145 MagickFalse,option);
4146 option=GetImageOption(image_info,"density");
4147 if (option != (const char *) NULL)
4148 {
4149 flags=ParseGeometry(option,&geometry_info);
4150 if ((flags & RhoValue) != 0)
4151 image->resolution.x=geometry_info.rho;
4152 image->resolution.y=image->resolution.x;
4153 if ((flags & SigmaValue) != 0)
4154 image->resolution.y=geometry_info.sigma;
4155 }
4156 option=GetImageOption(image_info,"depth");
4157 if (option != (const char *) NULL)
4158 image->depth=StringToUnsignedLong(option);
4159 option=GetImageOption(image_info,"endian");
4160 if (option != (const char *) NULL)
4161 image->endian=(EndianType) ParseCommandOption(MagickEndianOptions,
4162 MagickFalse,option);
4163 option=GetImageOption(image_info,"filter");
4164 if (option != (const char *) NULL)
4165 image->filter=(FilterType) ParseCommandOption(MagickFilterOptions,
4166 MagickFalse,option);
4167 option=GetImageOption(image_info,"fuzz");
4168 if (option != (const char *) NULL)
4169 image->fuzz=StringToDoubleInterval(option,(double) QuantumRange+1.0);
4170 option=GetImageOption(image_info,"gravity");
4171 if (option != (const char *) NULL)
4172 image->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
4173 MagickFalse,option);
4174 option=GetImageOption(image_info,"green-primary");
4175 if (option != (const char *) NULL)
4176 {
4177 flags=ParseGeometry(option,&geometry_info);
4178 if ((flags & RhoValue) != 0)
4179 image->chromaticity.green_primary.x=geometry_info.rho;
4180 image->chromaticity.green_primary.y=image->chromaticity.green_primary.x;
4181 if ((flags & SigmaValue) != 0)
4182 image->chromaticity.green_primary.y=geometry_info.sigma;
4183 }
4184 option=GetImageOption(image_info,"intent");
4185 if (option != (const char *) NULL)
4186 image->rendering_intent=(RenderingIntent) ParseCommandOption(
4187 MagickIntentOptions,MagickFalse,option);
4188 option=GetImageOption(image_info,"intensity");
4189 if (option != (const char *) NULL)
4190 image->intensity=(PixelIntensityMethod) ParseCommandOption(
4191 MagickPixelIntensityOptions,MagickFalse,option);
4192 option=GetImageOption(image_info,"interlace");
4193 if (option != (const char *) NULL)
4194 image->interlace=(InterlaceType) ParseCommandOption(MagickInterlaceOptions,
4195 MagickFalse,option);
4196 option=GetImageOption(image_info,"interpolate");
4197 if (option != (const char *) NULL)
4198 image->interpolate=(PixelInterpolateMethod) ParseCommandOption(
4199 MagickInterpolateOptions,MagickFalse,option);
4200 option=GetImageOption(image_info,"loop");
4201 if (option != (const char *) NULL)
4202 image->iterations=StringToUnsignedLong(option);
4203 option=GetImageOption(image_info,"mattecolor");
4204 if (option != (const char *) NULL)
4205 (void) QueryColorCompliance(option,AllCompliance,&image->matte_color,
4206 exception);
4207 option=GetImageOption(image_info,"orient");
4208 if (option != (const char *) NULL)
4209 image->orientation=(OrientationType) ParseCommandOption(
4210 MagickOrientationOptions,MagickFalse,option);
4211 option=GetImageOption(image_info,"page");
4212 if (option != (const char *) NULL)
4213 {
4214 char
4215 *geometry;
4216
4217 geometry=GetPageGeometry(option);
4218 flags=ParseAbsoluteGeometry(geometry,&image->page);
4219 geometry=DestroyString(geometry);
4220 }
4221 option=GetImageOption(image_info,"quality");
4222 if (option != (const char *) NULL)
4223 image->quality=StringToUnsignedLong(option);
4224 option=GetImageOption(image_info,"red-primary");
4225 if (option != (const char *) NULL)
4226 {
4227 flags=ParseGeometry(option,&geometry_info);
4228 if ((flags & RhoValue) != 0)
4229 image->chromaticity.red_primary.x=geometry_info.rho;
4230 image->chromaticity.red_primary.y=image->chromaticity.red_primary.x;
4231 if ((flags & SigmaValue) != 0)
4232 image->chromaticity.red_primary.y=geometry_info.sigma;
4233 }
4234 if (image_info->quality != UndefinedCompressionQuality)
4235 image->quality=image_info->quality;
4236 option=GetImageOption(image_info,"scene");
4237 if (option != (const char *) NULL)
4238 image->scene=StringToUnsignedLong(option);
4239 option=GetImageOption(image_info,"taint");
4240 if (option != (const char *) NULL)
4241 image->taint=(MagickBooleanType) ParseCommandOption(MagickBooleanOptions,
4242 MagickFalse,option);
4243 option=GetImageOption(image_info,"tile-offset");
4244 if (option != (const char *) NULL)
4245 {
4246 char
4247 *geometry;
4248
4249 geometry=GetPageGeometry(option);
4250 flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4251 geometry=DestroyString(geometry);
4252 }
4253 option=GetImageOption(image_info,"transparent-color");
4254 if (option != (const char *) NULL)
4255 (void) QueryColorCompliance(option,AllCompliance,&image->transparent_color,
4256 exception);
4257 option=GetImageOption(image_info,"type");
4258 if (option != (const char *) NULL)
4259 image->type=(ImageType) ParseCommandOption(MagickTypeOptions,MagickFalse,
4260 option);
4261 option=GetImageOption(image_info,"units");
4262 units=image_info->units;
4263 if (option != (const char *) NULL)
4264 units=(ResolutionType) ParseCommandOption(MagickResolutionOptions,
4265 MagickFalse,option);
4266 if (units != UndefinedResolution)
4267 {
4268 if (image->units != units)
4269 switch (image->units)
4270 {
4271 case PixelsPerInchResolution:
4272 {
4273 if (units == PixelsPerCentimeterResolution)
4274 {
4275 image->resolution.x/=2.54;
4276 image->resolution.y/=2.54;
4277 }
4278 break;
4279 }
4280 case PixelsPerCentimeterResolution:
4281 {
4282 if (units == PixelsPerInchResolution)
4283 {
4284 image->resolution.x=(double) ((size_t) (100.0*2.54*
4285 image->resolution.x+0.5))/100.0;
4286 image->resolution.y=(double) ((size_t) (100.0*2.54*
4287 image->resolution.y+0.5))/100.0;
4288 }
4289 break;
4290 }
4291 default:
4292 break;
4293 }
4294 image->units=units;
4295 option=GetImageOption(image_info,"density");
4296 if (option != (const char *) NULL)
4297 {
4298 flags=ParseGeometry(option,&geometry_info);
4299 if ((flags & RhoValue) != 0)
4300 image->resolution.x=geometry_info.rho;
4301 image->resolution.y=image->resolution.x;
4302 if ((flags & SigmaValue) != 0)
4303 image->resolution.y=geometry_info.sigma;
4304 }
4305 }
4306 option=GetImageOption(image_info,"virtual-pixel");
4307 if (option != (const char *) NULL)
4308 (void) SetImageVirtualPixelMethod(image,(VirtualPixelMethod)
4309 ParseCommandOption(MagickVirtualPixelOptions,MagickFalse,option),
4310 exception);
4311 option=GetImageOption(image_info,"white-point");
4312 if (option != (const char *) NULL)
4313 {
4314 flags=ParseGeometry(option,&geometry_info);
4315 if ((flags & RhoValue) != 0)
4316 image->chromaticity.white_point.x=geometry_info.rho;
4317 image->chromaticity.white_point.y=image->chromaticity.white_point.x;
4318 if ((flags & SigmaValue) != 0)
4319 image->chromaticity.white_point.y=geometry_info.sigma;
4320 }
4321 /*
4322 Pointer to allow the lookup of pre-image artifact will fallback to a global
4323 option setting/define. This saves a lot of duplication of global options
4324 into per-image artifacts, while ensuring only specifically set per-image
4325 artifacts are preserved when parenthesis ends.
4326 */
4327 if (image->image_info != (ImageInfo *) NULL)
4328 image->image_info=DestroyImageInfo(image->image_info);
4329 image->image_info=CloneImageInfo(image_info);
4330 return(MagickTrue);
4331}
_Ascii85Info
Definition compress.c:70
_BlobInfo
Definition blob.c:136
_CacheView
Definition cache-view.c:66
_CustomStreamInfo
Definition blob.c:199
_DelegateInfo
Definition delegate.h:29
_ExceptionInfo
Definition exception.h:102
_GeometryInfo
Definition geometry.h:106
_ImageInfo
Definition image.h:359
_Image
Definition image.h:132
_MagicInfo
Definition magic.c:90
_MagickInfo
Definition magick.h:67
_OffsetInfo
Definition geometry.h:116
_PixelInfo
Definition pixel.h:182
_RectangleInfo
Definition geometry.h:130
_StringInfo
Definition string_.h:28