MagickCore  7.0.10
property.c
Go to the documentation of this file.
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % PPPP RRRR OOO PPPP EEEEE RRRR TTTTT Y Y %
7 % P P R R O O P P E R R T Y Y %
8 % PPPP RRRR O O PPPP EEE RRRR T Y %
9 % P R R O O P E R R T Y %
10 % P R R OOO P EEEEE R R T Y %
11 % %
12 % %
13 % MagickCore Property Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % March 2000 %
18 % %
19 % %
20 % Copyright 1999-2020 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/script/license.php %
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/artifact.h"
45 #include "MagickCore/attribute.h"
46 #include "MagickCore/cache.h"
47 #include "MagickCore/cache-private.h"
48 #include "MagickCore/color.h"
49 #include "MagickCore/color-private.h"
50 #include "MagickCore/colorspace-private.h"
51 #include "MagickCore/compare.h"
52 #include "MagickCore/constitute.h"
53 #include "MagickCore/draw.h"
54 #include "MagickCore/effect.h"
55 #include "MagickCore/exception.h"
56 #include "MagickCore/exception-private.h"
57 #include "MagickCore/fx.h"
58 #include "MagickCore/fx-private.h"
59 #include "MagickCore/gem.h"
60 #include "MagickCore/geometry.h"
61 #include "MagickCore/histogram.h"
62 #include "MagickCore/image.h"
63 #include "MagickCore/layer.h"
64 #include "MagickCore/locale-private.h"
65 #include "MagickCore/list.h"
66 #include "MagickCore/magick.h"
67 #include "MagickCore/memory_.h"
68 #include "MagickCore/monitor.h"
69 #include "MagickCore/montage.h"
70 #include "MagickCore/option.h"
71 #include "MagickCore/policy.h"
72 #include "MagickCore/profile.h"
73 #include "MagickCore/property.h"
74 #include "MagickCore/quantum.h"
75 #include "MagickCore/resource_.h"
76 #include "MagickCore/splay-tree.h"
77 #include "MagickCore/signature.h"
78 #include "MagickCore/statistic.h"
79 #include "MagickCore/string_.h"
80 #include "MagickCore/string-private.h"
81 #include "MagickCore/token.h"
82 #include "MagickCore/token-private.h"
83 #include "MagickCore/utility.h"
84 #include "MagickCore/utility-private.h"
85 #include "MagickCore/version.h"
86 #include "MagickCore/xml-tree.h"
87 #include "MagickCore/xml-tree-private.h"
88 #if defined(MAGICKCORE_LCMS_DELEGATE)
89 #if defined(MAGICKCORE_HAVE_LCMS2_LCMS2_H)
90 #include <lcms2/lcms2.h>
91 #elif defined(MAGICKCORE_HAVE_LCMS2_H)
92 #include "lcms2.h"
93 #elif defined(MAGICKCORE_HAVE_LCMS_LCMS_H)
94 #include <lcms/lcms.h>
95 #else
96 #include "lcms.h"
97 #endif
98 #endif
99 
100 /*
101  Define declarations.
102 */
103 #if defined(MAGICKCORE_LCMS_DELEGATE)
104 #if defined(LCMS_VERSION) && (LCMS_VERSION < 2000)
105 #define cmsUInt32Number DWORD
106 #endif
107 #endif
108 
109 /*
110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
111 % %
112 % %
113 % %
114 % C l o n e I m a g e P r o p e r t i e s %
115 % %
116 % %
117 % %
118 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
119 %
120 % CloneImageProperties() clones all the image properties to another image.
121 %
122 % The format of the CloneImageProperties method is:
123 %
124 % MagickBooleanType CloneImageProperties(Image *image,
125 % const Image *clone_image)
126 %
127 % A description of each parameter follows:
128 %
129 % o image: the image.
130 %
131 % o clone_image: the clone image.
132 %
133 */
134 MagickExport MagickBooleanType CloneImageProperties(Image *image,
135  const Image *clone_image)
136 {
137  assert(image != (Image *) NULL);
138  assert(image->signature == MagickCoreSignature);
139  if (image->debug != MagickFalse)
140  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
141  assert(clone_image != (const Image *) NULL);
142  assert(clone_image->signature == MagickCoreSignature);
143  if (clone_image->debug != MagickFalse)
144  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
145  clone_image->filename);
146  (void) CopyMagickString(image->filename,clone_image->filename,
147  MagickPathExtent);
148  (void) CopyMagickString(image->magick_filename,clone_image->magick_filename,
149  MagickPathExtent);
150  image->compression=clone_image->compression;
151  image->quality=clone_image->quality;
152  image->depth=clone_image->depth;
153  image->matte_color=clone_image->matte_color;
154  image->background_color=clone_image->background_color;
155  image->border_color=clone_image->border_color;
156  image->transparent_color=clone_image->transparent_color;
157  image->gamma=clone_image->gamma;
158  image->chromaticity=clone_image->chromaticity;
159  image->rendering_intent=clone_image->rendering_intent;
160  image->black_point_compensation=clone_image->black_point_compensation;
161  image->units=clone_image->units;
162  image->montage=(char *) NULL;
163  image->directory=(char *) NULL;
164  (void) CloneString(&image->geometry,clone_image->geometry);
165  image->offset=clone_image->offset;
166  image->resolution.x=clone_image->resolution.x;
167  image->resolution.y=clone_image->resolution.y;
168  image->page=clone_image->page;
169  image->tile_offset=clone_image->tile_offset;
170  image->extract_info=clone_image->extract_info;
171  image->filter=clone_image->filter;
172  image->fuzz=clone_image->fuzz;
173  image->intensity=clone_image->intensity;
174  image->interlace=clone_image->interlace;
175  image->interpolate=clone_image->interpolate;
176  image->endian=clone_image->endian;
177  image->gravity=clone_image->gravity;
178  image->compose=clone_image->compose;
179  image->orientation=clone_image->orientation;
180  image->scene=clone_image->scene;
181  image->dispose=clone_image->dispose;
182  image->delay=clone_image->delay;
183  image->ticks_per_second=clone_image->ticks_per_second;
184  image->iterations=clone_image->iterations;
185  image->total_colors=clone_image->total_colors;
186  image->taint=clone_image->taint;
187  image->progress_monitor=clone_image->progress_monitor;
188  image->client_data=clone_image->client_data;
189  image->start_loop=clone_image->start_loop;
190  image->error=clone_image->error;
191  image->signature=clone_image->signature;
192  if (clone_image->properties != (void *) NULL)
193  {
194  if (image->properties != (void *) NULL)
195  DestroyImageProperties(image);
196  image->properties=CloneSplayTree((SplayTreeInfo *)
197  clone_image->properties,(void *(*)(void *)) ConstantString,
198  (void *(*)(void *)) ConstantString);
199  }
200  return(MagickTrue);
201 }
202 
203 /*
204 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
205 % %
206 % %
207 % %
208 % D e f i n e I m a g e P r o p e r t y %
209 % %
210 % %
211 % %
212 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
213 %
214 % DefineImageProperty() associates an assignment string of the form
215 % "key=value" with an artifact or options. It is equivelent to
216 % SetImageProperty().
217 %
218 % The format of the DefineImageProperty method is:
219 %
220 % MagickBooleanType DefineImageProperty(Image *image,const char *property,
221 % ExceptionInfo *exception)
222 %
223 % A description of each parameter follows:
224 %
225 % o image: the image.
226 %
227 % o property: the image property.
228 %
229 % o exception: return any errors or warnings in this structure.
230 %
231 */
232 MagickExport MagickBooleanType DefineImageProperty(Image *image,
233  const char *property,ExceptionInfo *exception)
234 {
235  char
236  key[MagickPathExtent],
237  value[MagickPathExtent];
238 
239  register char
240  *p;
241 
242  assert(image != (Image *) NULL);
243  assert(property != (const char *) NULL);
244  (void) CopyMagickString(key,property,MagickPathExtent-1);
245  for (p=key; *p != '\0'; p++)
246  if (*p == '=')
247  break;
248  *value='\0';
249  if (*p == '=')
250  (void) CopyMagickString(value,p+1,MagickPathExtent);
251  *p='\0';
252  return(SetImageProperty(image,key,value,exception));
253 }
254 
255 /*
256 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
257 % %
258 % %
259 % %
260 % D e l e t e I m a g e P r o p e r t y %
261 % %
262 % %
263 % %
264 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
265 %
266 % DeleteImageProperty() deletes an image property.
267 %
268 % The format of the DeleteImageProperty method is:
269 %
270 % MagickBooleanType DeleteImageProperty(Image *image,const char *property)
271 %
272 % A description of each parameter follows:
273 %
274 % o image: the image.
275 %
276 % o property: the image property.
277 %
278 */
279 MagickExport MagickBooleanType DeleteImageProperty(Image *image,
280  const char *property)
281 {
282  assert(image != (Image *) NULL);
283  assert(image->signature == MagickCoreSignature);
284  if (image->debug != MagickFalse)
285  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
286  if (image->properties == (void *) NULL)
287  return(MagickFalse);
288  return(DeleteNodeFromSplayTree((SplayTreeInfo *) image->properties,property));
289 }
290 
291 /*
292 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
293 % %
294 % %
295 % %
296 % D e s t r o y I m a g e P r o p e r t i e s %
297 % %
298 % %
299 % %
300 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
301 %
302 % DestroyImageProperties() destroys all properties and associated memory
303 % attached to the given image.
304 %
305 % The format of the DestroyDefines method is:
306 %
307 % void DestroyImageProperties(Image *image)
308 %
309 % A description of each parameter follows:
310 %
311 % o image: the image.
312 %
313 */
314 MagickExport void DestroyImageProperties(Image *image)
315 {
316  assert(image != (Image *) NULL);
317  assert(image->signature == MagickCoreSignature);
318  if (image->debug != MagickFalse)
319  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
320  if (image->properties != (void *) NULL)
321  image->properties=(void *) DestroySplayTree((SplayTreeInfo *)
322  image->properties);
323 }
324 
325 /*
326 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
327 % %
328 % %
329 % %
330 % F o r m a t I m a g e P r o p e r t y %
331 % %
332 % %
333 % %
334 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
335 %
336 % FormatImageProperty() permits formatted property/value pairs to be saved as
337 % an image property.
338 %
339 % The format of the FormatImageProperty method is:
340 %
341 % MagickBooleanType FormatImageProperty(Image *image,const char *property,
342 % const char *format,...)
343 %
344 % A description of each parameter follows.
345 %
346 % o image: The image.
347 %
348 % o property: The attribute property.
349 %
350 % o format: A string describing the format to use to write the remaining
351 % arguments.
352 %
353 */
354 MagickExport MagickBooleanType FormatImageProperty(Image *image,
355  const char *property,const char *format,...)
356 {
357  char
358  value[MagickPathExtent];
359 
360  ExceptionInfo
361  *exception;
362 
363  MagickBooleanType
364  status;
365 
366  ssize_t
367  n;
368 
369  va_list
370  operands;
371 
372  va_start(operands,format);
373  n=FormatLocaleStringList(value,MagickPathExtent,format,operands);
374  (void) n;
375  va_end(operands);
376  exception=AcquireExceptionInfo();
377  status=SetImageProperty(image,property,value,exception);
378  exception=DestroyExceptionInfo(exception);
379  return(status);
380 }
381 
382 /*
383 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
384 % %
385 % %
386 % %
387 % G e t I m a g e P r o p e r t y %
388 % %
389 % %
390 % %
391 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
392 %
393 % GetImageProperty() gets a value associated with an image property.
394 %
395 % This includes, profile prefixes, such as "exif:", "iptc:" and "8bim:"
396 % It does not handle non-prifile prefixes, such as "fx:", "option:", or
397 % "artifact:".
398 %
399 % The returned string is stored as a properity of the same name for faster
400 % lookup later. It should NOT be freed by the caller.
401 %
402 % The format of the GetImageProperty method is:
403 %
404 % const char *GetImageProperty(const Image *image,const char *key,
405 % ExceptionInfo *exception)
406 %
407 % A description of each parameter follows:
408 %
409 % o image: the image.
410 %
411 % o key: the key.
412 %
413 % o exception: return any errors or warnings in this structure.
414 %
415 */
416 
417 static char
418  *TracePSClippath(const unsigned char *,size_t),
419  *TraceSVGClippath(const unsigned char *,size_t,const size_t,
420  const size_t);
421 
422 static MagickBooleanType GetIPTCProperty(const Image *image,const char *key,
423  ExceptionInfo *exception)
424 {
425  char
426  *attribute,
427  *message;
428 
429  const StringInfo
430  *profile;
431 
432  long
433  count,
434  dataset,
435  record;
436 
437  register ssize_t
438  i;
439 
440  size_t
441  length;
442 
443  profile=GetImageProfile(image,"iptc");
444  if (profile == (StringInfo *) NULL)
445  profile=GetImageProfile(image,"8bim");
446  if (profile == (StringInfo *) NULL)
447  return(MagickFalse);
448  count=sscanf(key,"IPTC:%ld:%ld",&dataset,&record);
449  if (count != 2)
450  return(MagickFalse);
451  attribute=(char *) NULL;
452  for (i=0; i < (ssize_t) GetStringInfoLength(profile); i+=(ssize_t) length)
453  {
454  length=1;
455  if ((ssize_t) GetStringInfoDatum(profile)[i] != 0x1c)
456  continue;
457  length=(size_t) (GetStringInfoDatum(profile)[i+3] << 8);
458  length|=GetStringInfoDatum(profile)[i+4];
459  if (((long) GetStringInfoDatum(profile)[i+1] == dataset) &&
460  ((long) GetStringInfoDatum(profile)[i+2] == record))
461  {
462  message=(char *) NULL;
463  if (~length >= 1)
464  message=(char *) AcquireQuantumMemory(length+1UL,sizeof(*message));
465  if (message != (char *) NULL)
466  {
467  (void) CopyMagickString(message,(char *) GetStringInfoDatum(
468  profile)+i+5,length+1);
469  (void) ConcatenateString(&attribute,message);
470  (void) ConcatenateString(&attribute,";");
471  message=DestroyString(message);
472  }
473  }
474  i+=5;
475  }
476  if ((attribute == (char *) NULL) || (*attribute == ';'))
477  {
478  if (attribute != (char *) NULL)
479  attribute=DestroyString(attribute);
480  return(MagickFalse);
481  }
482  attribute[strlen(attribute)-1]='\0';
483  (void) SetImageProperty((Image *) image,key,(const char *) attribute,
484  exception);
485  attribute=DestroyString(attribute);
486  return(MagickTrue);
487 }
488 
489 static inline int ReadPropertyByte(const unsigned char **p,size_t *length)
490 {
491  int
492  c;
493 
494  if (*length < 1)
495  return(EOF);
496  c=(int) (*(*p)++);
497  (*length)--;
498  return(c);
499 }
500 
501 static inline signed int ReadPropertyMSBLong(const unsigned char **p,
502  size_t *length)
503 {
504  union
505  {
506  unsigned int
507  unsigned_value;
508 
509  signed int
510  signed_value;
511  } quantum;
512 
513  int
514  c;
515 
516  register ssize_t
517  i;
518 
519  unsigned char
520  buffer[4];
521 
522  unsigned int
523  value;
524 
525  if (*length < 4)
526  return(-1);
527  for (i=0; i < 4; i++)
528  {
529  c=(int) (*(*p)++);
530  (*length)--;
531  buffer[i]=(unsigned char) c;
532  }
533  value=(unsigned int) buffer[0] << 24;
534  value|=(unsigned int) buffer[1] << 16;
535  value|=(unsigned int) buffer[2] << 8;
536  value|=(unsigned int) buffer[3];
537  quantum.unsigned_value=value & 0xffffffff;
538  return(quantum.signed_value);
539 }
540 
541 static inline signed short ReadPropertyMSBShort(const unsigned char **p,
542  size_t *length)
543 {
544  union
545  {
546  unsigned short
547  unsigned_value;
548 
549  signed short
550  signed_value;
551  } quantum;
552 
553  int
554  c;
555 
556  register ssize_t
557  i;
558 
559  unsigned char
560  buffer[2];
561 
562  unsigned short
563  value;
564 
565  if (*length < 2)
566  return((unsigned short) ~0);
567  for (i=0; i < 2; i++)
568  {
569  c=(int) (*(*p)++);
570  (*length)--;
571  buffer[i]=(unsigned char) c;
572  }
573  value=(unsigned short) buffer[0] << 8;
574  value|=(unsigned short) buffer[1];
575  quantum.unsigned_value=value & 0xffff;
576  return(quantum.signed_value);
577 }
578 
579 static MagickBooleanType Get8BIMProperty(const Image *image,const char *key,
580  ExceptionInfo *exception)
581 {
582  char
583  *attribute,
584  format[MagickPathExtent],
585  name[MagickPathExtent],
586  *resource;
587 
588  const StringInfo
589  *profile;
590 
591  const unsigned char
592  *info;
593 
594  long
595  start,
596  stop;
597 
598  MagickBooleanType
599  status;
600 
601  register ssize_t
602  i;
603 
604  size_t
605  length;
606 
607  ssize_t
608  count,
609  id,
610  sub_number;
611 
612  /*
613  There are no newlines in path names, so it's safe as terminator.
614  */
615  profile=GetImageProfile(image,"8bim");
616  if (profile == (StringInfo *) NULL)
617  return(MagickFalse);
618  count=(ssize_t) sscanf(key,"8BIM:%ld,%ld:%1024[^\n]\n%1024[^\n]",&start,&stop,
619  name,format);
620  if ((count != 2) && (count != 3) && (count != 4))
621  return(MagickFalse);
622  if (count < 4)
623  (void) CopyMagickString(format,"SVG",MagickPathExtent);
624  if (count < 3)
625  *name='\0';
626  sub_number=1;
627  if (*name == '#')
628  sub_number=(ssize_t) StringToLong(&name[1]);
629  sub_number=MagickMax(sub_number,1L);
630  resource=(char *) NULL;
631  status=MagickFalse;
632  length=GetStringInfoLength(profile);
633  info=GetStringInfoDatum(profile);
634  while ((length > 0) && (status == MagickFalse))
635  {
636  if (ReadPropertyByte(&info,&length) != (unsigned char) '8')
637  continue;
638  if (ReadPropertyByte(&info,&length) != (unsigned char) 'B')
639  continue;
640  if (ReadPropertyByte(&info,&length) != (unsigned char) 'I')
641  continue;
642  if (ReadPropertyByte(&info,&length) != (unsigned char) 'M')
643  continue;
644  id=(ssize_t) ReadPropertyMSBShort(&info,&length);
645  if (id < (ssize_t) start)
646  continue;
647  if (id > (ssize_t) stop)
648  continue;
649  if (resource != (char *) NULL)
650  resource=DestroyString(resource);
651  count=(ssize_t) ReadPropertyByte(&info,&length);
652  if ((count != 0) && ((size_t) count <= length))
653  {
654  resource=(char *) NULL;
655  if (~((size_t) count) >= (MagickPathExtent-1))
656  resource=(char *) AcquireQuantumMemory((size_t) count+
657  MagickPathExtent,sizeof(*resource));
658  if (resource != (char *) NULL)
659  {
660  for (i=0; i < (ssize_t) count; i++)
661  resource[i]=(char) ReadPropertyByte(&info,&length);
662  resource[count]='\0';
663  }
664  }
665  if ((count & 0x01) == 0)
666  (void) ReadPropertyByte(&info,&length);
667  count=(ssize_t) ReadPropertyMSBLong(&info,&length);
668  if ((count < 0) || ((size_t) count > length))
669  {
670  length=0;
671  continue;
672  }
673  if ((*name != '\0') && (*name != '#'))
674  if ((resource == (char *) NULL) || (LocaleCompare(name,resource) != 0))
675  {
676  /*
677  No name match, scroll forward and try next.
678  */
679  info+=count;
680  length-=MagickMin(count,(ssize_t) length);
681  continue;
682  }
683  if ((*name == '#') && (sub_number != 1))
684  {
685  /*
686  No numbered match, scroll forward and try next.
687  */
688  sub_number--;
689  info+=count;
690  length-=MagickMin(count,(ssize_t) length);
691  continue;
692  }
693  /*
694  We have the resource of interest.
695  */
696  attribute=(char *) NULL;
697  if (~((size_t) count) >= (MagickPathExtent-1))
698  attribute=(char *) AcquireQuantumMemory((size_t) count+MagickPathExtent,
699  sizeof(*attribute));
700  if (attribute != (char *) NULL)
701  {
702  (void) memcpy(attribute,(char *) info,(size_t) count);
703  attribute[count]='\0';
704  info+=count;
705  length-=MagickMin(count,(ssize_t) length);
706  if ((id <= 1999) || (id >= 2999))
707  (void) SetImageProperty((Image *) image,key,(const char *) attribute,
708  exception);
709  else
710  {
711  char
712  *path;
713 
714  if (LocaleCompare(format,"svg") == 0)
715  path=TraceSVGClippath((unsigned char *) attribute,(size_t) count,
716  image->columns,image->rows);
717  else
718  path=TracePSClippath((unsigned char *) attribute,(size_t) count);
719  (void) SetImageProperty((Image *) image,key,(const char *) path,
720  exception);
721  path=DestroyString(path);
722  }
723  attribute=DestroyString(attribute);
724  status=MagickTrue;
725  }
726  }
727  if (resource != (char *) NULL)
728  resource=DestroyString(resource);
729  return(status);
730 }
731 
732 static inline signed int ReadPropertySignedLong(const EndianType endian,
733  const unsigned char *buffer)
734 {
735  union
736  {
737  unsigned int
738  unsigned_value;
739 
740  signed int
741  signed_value;
742  } quantum;
743 
744  unsigned int
745  value;
746 
747  if (endian == LSBEndian)
748  {
749  value=(unsigned int) buffer[3] << 24;
750  value|=(unsigned int) buffer[2] << 16;
751  value|=(unsigned int) buffer[1] << 8;
752  value|=(unsigned int) buffer[0];
753  quantum.unsigned_value=value & 0xffffffff;
754  return(quantum.signed_value);
755  }
756  value=(unsigned int) buffer[0] << 24;
757  value|=(unsigned int) buffer[1] << 16;
758  value|=(unsigned int) buffer[2] << 8;
759  value|=(unsigned int) buffer[3];
760  quantum.unsigned_value=value & 0xffffffff;
761  return(quantum.signed_value);
762 }
763 
764 static inline unsigned int ReadPropertyUnsignedLong(const EndianType endian,
765  const unsigned char *buffer)
766 {
767  unsigned int
768  value;
769 
770  if (endian == LSBEndian)
771  {
772  value=(unsigned int) buffer[3] << 24;
773  value|=(unsigned int) buffer[2] << 16;
774  value|=(unsigned int) buffer[1] << 8;
775  value|=(unsigned int) buffer[0];
776  return(value & 0xffffffff);
777  }
778  value=(unsigned int) buffer[0] << 24;
779  value|=(unsigned int) buffer[1] << 16;
780  value|=(unsigned int) buffer[2] << 8;
781  value|=(unsigned int) buffer[3];
782  return(value & 0xffffffff);
783 }
784 
785 static inline signed short ReadPropertySignedShort(const EndianType endian,
786  const unsigned char *buffer)
787 {
788  union
789  {
790  unsigned short
791  unsigned_value;
792 
793  signed short
794  signed_value;
795  } quantum;
796 
797  unsigned short
798  value;
799 
800  if (endian == LSBEndian)
801  {
802  value=(unsigned short) buffer[1] << 8;
803  value|=(unsigned short) buffer[0];
804  quantum.unsigned_value=value & 0xffff;
805  return(quantum.signed_value);
806  }
807  value=(unsigned short) buffer[0] << 8;
808  value|=(unsigned short) buffer[1];
809  quantum.unsigned_value=value & 0xffff;
810  return(quantum.signed_value);
811 }
812 
813 static inline unsigned short ReadPropertyUnsignedShort(const EndianType endian,
814  const unsigned char *buffer)
815 {
816  unsigned short
817  value;
818 
819  if (endian == LSBEndian)
820  {
821  value=(unsigned short) buffer[1] << 8;
822  value|=(unsigned short) buffer[0];
823  return(value & 0xffff);
824  }
825  value=(unsigned short) buffer[0] << 8;
826  value|=(unsigned short) buffer[1];
827  return(value & 0xffff);
828 }
829 
830 static MagickBooleanType GetEXIFProperty(const Image *image,
831  const char *property,ExceptionInfo *exception)
832 {
833 #define MaxDirectoryStack 16
834 #define EXIF_DELIMITER "\n"
835 #define EXIF_NUM_FORMATS 12
836 #define EXIF_FMT_BYTE 1
837 #define EXIF_FMT_STRING 2
838 #define EXIF_FMT_USHORT 3
839 #define EXIF_FMT_ULONG 4
840 #define EXIF_FMT_URATIONAL 5
841 #define EXIF_FMT_SBYTE 6
842 #define EXIF_FMT_UNDEFINED 7
843 #define EXIF_FMT_SSHORT 8
844 #define EXIF_FMT_SLONG 9
845 #define EXIF_FMT_SRATIONAL 10
846 #define EXIF_FMT_SINGLE 11
847 #define EXIF_FMT_DOUBLE 12
848 #define TAG_EXIF_OFFSET 0x8769
849 #define TAG_GPS_OFFSET 0x8825
850 #define TAG_INTEROP_OFFSET 0xa005
851 
852 #define EXIFMultipleValues(size,format,arg) \
853 { \
854  ssize_t \
855  component; \
856  \
857  size_t \
858  len; \
859  \
860  unsigned char \
861  *p1; \
862  \
863  len=0; \
864  p1=p; \
865  for (component=0; component < components; component++) \
866  { \
867  len+=FormatLocaleString(buffer+len,MagickPathExtent-len,format", ",arg); \
868  if (len >= (MagickPathExtent-1)) \
869  len=MagickPathExtent-1; \
870  p1+=size; \
871  } \
872  if (len > 1) \
873  buffer[len-2]='\0'; \
874  value=AcquireString(buffer); \
875 }
876 
877 #define EXIFMultipleFractions(size,format,arg1,arg2) \
878 { \
879  ssize_t \
880  component; \
881  \
882  size_t \
883  len; \
884  \
885  unsigned char \
886  *p1; \
887  \
888  len=0; \
889  p1=p; \
890  for (component=0; component < components; component++) \
891  { \
892  len+=FormatLocaleString(buffer+len,MagickPathExtent-len,format", ", \
893  (arg1),(arg2)); \
894  if (len >= (MagickPathExtent-1)) \
895  len=MagickPathExtent-1; \
896  p1+=size; \
897  } \
898  if (len > 1) \
899  buffer[len-2]='\0'; \
900  value=AcquireString(buffer); \
901 }
902 
903  typedef struct _DirectoryInfo
904  {
905  const unsigned char
906  *directory;
907 
908  size_t
909  entry;
910 
911  ssize_t
912  offset;
913  } DirectoryInfo;
914 
915  typedef struct _TagInfo
916  {
917  size_t
918  tag;
919 
920  const char
921  description[36];
922  } TagInfo;
923 
924  static const TagInfo
925  EXIFTag[] =
926  {
927  { 0x001, "exif:InteroperabilityIndex" },
928  { 0x002, "exif:InteroperabilityVersion" },
929  { 0x100, "exif:ImageWidth" },
930  { 0x101, "exif:ImageLength" },
931  { 0x102, "exif:BitsPerSample" },
932  { 0x103, "exif:Compression" },
933  { 0x106, "exif:PhotometricInterpretation" },
934  { 0x10a, "exif:FillOrder" },
935  { 0x10d, "exif:DocumentName" },
936  { 0x10e, "exif:ImageDescription" },
937  { 0x10f, "exif:Make" },
938  { 0x110, "exif:Model" },
939  { 0x111, "exif:StripOffsets" },
940  { 0x112, "exif:Orientation" },
941  { 0x115, "exif:SamplesPerPixel" },
942  { 0x116, "exif:RowsPerStrip" },
943  { 0x117, "exif:StripByteCounts" },
944  { 0x11a, "exif:XResolution" },
945  { 0x11b, "exif:YResolution" },
946  { 0x11c, "exif:PlanarConfiguration" },
947  { 0x11d, "exif:PageName" },
948  { 0x11e, "exif:XPosition" },
949  { 0x11f, "exif:YPosition" },
950  { 0x118, "exif:MinSampleValue" },
951  { 0x119, "exif:MaxSampleValue" },
952  { 0x120, "exif:FreeOffsets" },
953  { 0x121, "exif:FreeByteCounts" },
954  { 0x122, "exif:GrayResponseUnit" },
955  { 0x123, "exif:GrayResponseCurve" },
956  { 0x124, "exif:T4Options" },
957  { 0x125, "exif:T6Options" },
958  { 0x128, "exif:ResolutionUnit" },
959  { 0x12d, "exif:TransferFunction" },
960  { 0x131, "exif:Software" },
961  { 0x132, "exif:DateTime" },
962  { 0x13b, "exif:Artist" },
963  { 0x13e, "exif:WhitePoint" },
964  { 0x13f, "exif:PrimaryChromaticities" },
965  { 0x140, "exif:ColorMap" },
966  { 0x141, "exif:HalfToneHints" },
967  { 0x142, "exif:TileWidth" },
968  { 0x143, "exif:TileLength" },
969  { 0x144, "exif:TileOffsets" },
970  { 0x145, "exif:TileByteCounts" },
971  { 0x14a, "exif:SubIFD" },
972  { 0x14c, "exif:InkSet" },
973  { 0x14d, "exif:InkNames" },
974  { 0x14e, "exif:NumberOfInks" },
975  { 0x150, "exif:DotRange" },
976  { 0x151, "exif:TargetPrinter" },
977  { 0x152, "exif:ExtraSample" },
978  { 0x153, "exif:SampleFormat" },
979  { 0x154, "exif:SMinSampleValue" },
980  { 0x155, "exif:SMaxSampleValue" },
981  { 0x156, "exif:TransferRange" },
982  { 0x157, "exif:ClipPath" },
983  { 0x158, "exif:XClipPathUnits" },
984  { 0x159, "exif:YClipPathUnits" },
985  { 0x15a, "exif:Indexed" },
986  { 0x15b, "exif:JPEGTables" },
987  { 0x15f, "exif:OPIProxy" },
988  { 0x200, "exif:JPEGProc" },
989  { 0x201, "exif:JPEGInterchangeFormat" },
990  { 0x202, "exif:JPEGInterchangeFormatLength" },
991  { 0x203, "exif:JPEGRestartInterval" },
992  { 0x205, "exif:JPEGLosslessPredictors" },
993  { 0x206, "exif:JPEGPointTransforms" },
994  { 0x207, "exif:JPEGQTables" },
995  { 0x208, "exif:JPEGDCTables" },
996  { 0x209, "exif:JPEGACTables" },
997  { 0x211, "exif:YCbCrCoefficients" },
998  { 0x212, "exif:YCbCrSubSampling" },
999  { 0x213, "exif:YCbCrPositioning" },
1000  { 0x214, "exif:ReferenceBlackWhite" },
1001  { 0x2bc, "exif:ExtensibleMetadataPlatform" },
1002  { 0x301, "exif:Gamma" },
1003  { 0x302, "exif:ICCProfileDescriptor" },
1004  { 0x303, "exif:SRGBRenderingIntent" },
1005  { 0x320, "exif:ImageTitle" },
1006  { 0x5001, "exif:ResolutionXUnit" },
1007  { 0x5002, "exif:ResolutionYUnit" },
1008  { 0x5003, "exif:ResolutionXLengthUnit" },
1009  { 0x5004, "exif:ResolutionYLengthUnit" },
1010  { 0x5005, "exif:PrintFlags" },
1011  { 0x5006, "exif:PrintFlagsVersion" },
1012  { 0x5007, "exif:PrintFlagsCrop" },
1013  { 0x5008, "exif:PrintFlagsBleedWidth" },
1014  { 0x5009, "exif:PrintFlagsBleedWidthScale" },
1015  { 0x500A, "exif:HalftoneLPI" },
1016  { 0x500B, "exif:HalftoneLPIUnit" },
1017  { 0x500C, "exif:HalftoneDegree" },
1018  { 0x500D, "exif:HalftoneShape" },
1019  { 0x500E, "exif:HalftoneMisc" },
1020  { 0x500F, "exif:HalftoneScreen" },
1021  { 0x5010, "exif:JPEGQuality" },
1022  { 0x5011, "exif:GridSize" },
1023  { 0x5012, "exif:ThumbnailFormat" },
1024  { 0x5013, "exif:ThumbnailWidth" },
1025  { 0x5014, "exif:ThumbnailHeight" },
1026  { 0x5015, "exif:ThumbnailColorDepth" },
1027  { 0x5016, "exif:ThumbnailPlanes" },
1028  { 0x5017, "exif:ThumbnailRawBytes" },
1029  { 0x5018, "exif:ThumbnailSize" },
1030  { 0x5019, "exif:ThumbnailCompressedSize" },
1031  { 0x501a, "exif:ColorTransferFunction" },
1032  { 0x501b, "exif:ThumbnailData" },
1033  { 0x5020, "exif:ThumbnailImageWidth" },
1034  { 0x5021, "exif:ThumbnailImageHeight" },
1035  { 0x5022, "exif:ThumbnailBitsPerSample" },
1036  { 0x5023, "exif:ThumbnailCompression" },
1037  { 0x5024, "exif:ThumbnailPhotometricInterp" },
1038  { 0x5025, "exif:ThumbnailImageDescription" },
1039  { 0x5026, "exif:ThumbnailEquipMake" },
1040  { 0x5027, "exif:ThumbnailEquipModel" },
1041  { 0x5028, "exif:ThumbnailStripOffsets" },
1042  { 0x5029, "exif:ThumbnailOrientation" },
1043  { 0x502a, "exif:ThumbnailSamplesPerPixel" },
1044  { 0x502b, "exif:ThumbnailRowsPerStrip" },
1045  { 0x502c, "exif:ThumbnailStripBytesCount" },
1046  { 0x502d, "exif:ThumbnailResolutionX" },
1047  { 0x502e, "exif:ThumbnailResolutionY" },
1048  { 0x502f, "exif:ThumbnailPlanarConfig" },
1049  { 0x5030, "exif:ThumbnailResolutionUnit" },
1050  { 0x5031, "exif:ThumbnailTransferFunction" },
1051  { 0x5032, "exif:ThumbnailSoftwareUsed" },
1052  { 0x5033, "exif:ThumbnailDateTime" },
1053  { 0x5034, "exif:ThumbnailArtist" },
1054  { 0x5035, "exif:ThumbnailWhitePoint" },
1055  { 0x5036, "exif:ThumbnailPrimaryChromaticities" },
1056  { 0x5037, "exif:ThumbnailYCbCrCoefficients" },
1057  { 0x5038, "exif:ThumbnailYCbCrSubsampling" },
1058  { 0x5039, "exif:ThumbnailYCbCrPositioning" },
1059  { 0x503A, "exif:ThumbnailRefBlackWhite" },
1060  { 0x503B, "exif:ThumbnailCopyRight" },
1061  { 0x5090, "exif:LuminanceTable" },
1062  { 0x5091, "exif:ChrominanceTable" },
1063  { 0x5100, "exif:FrameDelay" },
1064  { 0x5101, "exif:LoopCount" },
1065  { 0x5110, "exif:PixelUnit" },
1066  { 0x5111, "exif:PixelPerUnitX" },
1067  { 0x5112, "exif:PixelPerUnitY" },
1068  { 0x5113, "exif:PaletteHistogram" },
1069  { 0x1000, "exif:RelatedImageFileFormat" },
1070  { 0x1001, "exif:RelatedImageLength" },
1071  { 0x1002, "exif:RelatedImageWidth" },
1072  { 0x800d, "exif:ImageID" },
1073  { 0x80e3, "exif:Matteing" },
1074  { 0x80e4, "exif:DataType" },
1075  { 0x80e5, "exif:ImageDepth" },
1076  { 0x80e6, "exif:TileDepth" },
1077  { 0x828d, "exif:CFARepeatPatternDim" },
1078  { 0x828e, "exif:CFAPattern2" },
1079  { 0x828f, "exif:BatteryLevel" },
1080  { 0x8298, "exif:Copyright" },
1081  { 0x829a, "exif:ExposureTime" },
1082  { 0x829d, "exif:FNumber" },
1083  { 0x83bb, "exif:IPTC/NAA" },
1084  { 0x84e3, "exif:IT8RasterPadding" },
1085  { 0x84e5, "exif:IT8ColorTable" },
1086  { 0x8649, "exif:ImageResourceInformation" },
1087  { 0x8769, "exif:ExifOffset" }, /* specs as "Exif IFD Pointer"? */
1088  { 0x8773, "exif:InterColorProfile" },
1089  { 0x8822, "exif:ExposureProgram" },
1090  { 0x8824, "exif:SpectralSensitivity" },
1091  { 0x8825, "exif:GPSInfo" }, /* specs as "GPSInfo IFD Pointer"? */
1092  { 0x8827, "exif:PhotographicSensitivity" },
1093  { 0x8828, "exif:OECF" },
1094  { 0x8829, "exif:Interlace" },
1095  { 0x882a, "exif:TimeZoneOffset" },
1096  { 0x882b, "exif:SelfTimerMode" },
1097  { 0x8830, "exif:SensitivityType" },
1098  { 0x8831, "exif:StandardOutputSensitivity" },
1099  { 0x8832, "exif:RecommendedExposureIndex" },
1100  { 0x8833, "exif:ISOSpeed" },
1101  { 0x8834, "exif:ISOSpeedLatitudeyyy" },
1102  { 0x8835, "exif:ISOSpeedLatitudezzz" },
1103  { 0x9000, "exif:ExifVersion" },
1104  { 0x9003, "exif:DateTimeOriginal" },
1105  { 0x9004, "exif:DateTimeDigitized" },
1106  { 0x9010, "exif:OffsetTime" },
1107  { 0x9011, "exif:OffsetTimeOriginal" },
1108  { 0x9012, "exif:OffsetTimeDigitized" },
1109  { 0x9101, "exif:ComponentsConfiguration" },
1110  { 0x9102, "exif:CompressedBitsPerPixel" },
1111  { 0x9201, "exif:ShutterSpeedValue" },
1112  { 0x9202, "exif:ApertureValue" },
1113  { 0x9203, "exif:BrightnessValue" },
1114  { 0x9204, "exif:ExposureBiasValue" },
1115  { 0x9205, "exif:MaxApertureValue" },
1116  { 0x9206, "exif:SubjectDistance" },
1117  { 0x9207, "exif:MeteringMode" },
1118  { 0x9208, "exif:LightSource" },
1119  { 0x9209, "exif:Flash" },
1120  { 0x920a, "exif:FocalLength" },
1121  { 0x920b, "exif:FlashEnergy" },
1122  { 0x920c, "exif:SpatialFrequencyResponse" },
1123  { 0x920d, "exif:Noise" },
1124  { 0x9214, "exif:SubjectArea" },
1125  { 0x9290, "exif:SubSecTime" },
1126  { 0x9291, "exif:SubSecTimeOriginal" },
1127  { 0x9292, "exif:SubSecTimeDigitized" },
1128  { 0x9211, "exif:ImageNumber" },
1129  { 0x9212, "exif:SecurityClassification" },
1130  { 0x9213, "exif:ImageHistory" },
1131  { 0x9214, "exif:SubjectArea" },
1132  { 0x9215, "exif:ExposureIndex" },
1133  { 0x9216, "exif:TIFF-EPStandardID" },
1134  { 0x927c, "exif:MakerNote" },
1135  { 0x9286, "exif:UserComment" },
1136  { 0x9290, "exif:SubSecTime" },
1137  { 0x9291, "exif:SubSecTimeOriginal" },
1138  { 0x9292, "exif:SubSecTimeDigitized" },
1139  { 0x9400, "exif:Temperature" },
1140  { 0x9401, "exif:Humidity" },
1141  { 0x9402, "exif:Pressure" },
1142  { 0x9403, "exif:WaterDepth" },
1143  { 0x9404, "exif:Acceleration" },
1144  { 0x9405, "exif:CameraElevationAngle" },
1145  { 0x9C9b, "exif:WinXP-Title" },
1146  { 0x9C9c, "exif:WinXP-Comments" },
1147  { 0x9C9d, "exif:WinXP-Author" },
1148  { 0x9C9e, "exif:WinXP-Keywords" },
1149  { 0x9C9f, "exif:WinXP-Subject" },
1150  { 0xa000, "exif:FlashPixVersion" },
1151  { 0xa001, "exif:ColorSpace" },
1152  { 0xa002, "exif:PixelXDimension" },
1153  { 0xa003, "exif:PixelYDimension" },
1154  { 0xa004, "exif:RelatedSoundFile" },
1155  { 0xa005, "exif:InteroperabilityOffset" },
1156  { 0xa20b, "exif:FlashEnergy" },
1157  { 0xa20c, "exif:SpatialFrequencyResponse" },
1158  { 0xa20d, "exif:Noise" },
1159  { 0xa20e, "exif:FocalPlaneXResolution" },
1160  { 0xa20f, "exif:FocalPlaneYResolution" },
1161  { 0xa210, "exif:FocalPlaneResolutionUnit" },
1162  { 0xa214, "exif:SubjectLocation" },
1163  { 0xa215, "exif:ExposureIndex" },
1164  { 0xa216, "exif:TIFF/EPStandardID" },
1165  { 0xa217, "exif:SensingMethod" },
1166  { 0xa300, "exif:FileSource" },
1167  { 0xa301, "exif:SceneType" },
1168  { 0xa302, "exif:CFAPattern" },
1169  { 0xa401, "exif:CustomRendered" },
1170  { 0xa402, "exif:ExposureMode" },
1171  { 0xa403, "exif:WhiteBalance" },
1172  { 0xa404, "exif:DigitalZoomRatio" },
1173  { 0xa405, "exif:FocalLengthIn35mmFilm" },
1174  { 0xa406, "exif:SceneCaptureType" },
1175  { 0xa407, "exif:GainControl" },
1176  { 0xa408, "exif:Contrast" },
1177  { 0xa409, "exif:Saturation" },
1178  { 0xa40a, "exif:Sharpness" },
1179  { 0xa40b, "exif:DeviceSettingDescription" },
1180  { 0xa40c, "exif:SubjectDistanceRange" },
1181  { 0xa420, "exif:ImageUniqueID" },
1182  { 0xa430, "exif:CameraOwnerName" },
1183  { 0xa431, "exif:BodySerialNumber" },
1184  { 0xa432, "exif:LensSpecification" },
1185  { 0xa433, "exif:LensMake" },
1186  { 0xa434, "exif:LensModel" },
1187  { 0xa435, "exif:LensSerialNumber" },
1188  { 0xc4a5, "exif:PrintImageMatching" },
1189  { 0xa500, "exif:Gamma" },
1190  { 0xc640, "exif:CR2Slice" },
1191  { 0x10000, "exif:GPSVersionID" },
1192  { 0x10001, "exif:GPSLatitudeRef" },
1193  { 0x10002, "exif:GPSLatitude" },
1194  { 0x10003, "exif:GPSLongitudeRef" },
1195  { 0x10004, "exif:GPSLongitude" },
1196  { 0x10005, "exif:GPSAltitudeRef" },
1197  { 0x10006, "exif:GPSAltitude" },
1198  { 0x10007, "exif:GPSTimeStamp" },
1199  { 0x10008, "exif:GPSSatellites" },
1200  { 0x10009, "exif:GPSStatus" },
1201  { 0x1000a, "exif:GPSMeasureMode" },
1202  { 0x1000b, "exif:GPSDop" },
1203  { 0x1000c, "exif:GPSSpeedRef" },
1204  { 0x1000d, "exif:GPSSpeed" },
1205  { 0x1000e, "exif:GPSTrackRef" },
1206  { 0x1000f, "exif:GPSTrack" },
1207  { 0x10010, "exif:GPSImgDirectionRef" },
1208  { 0x10011, "exif:GPSImgDirection" },
1209  { 0x10012, "exif:GPSMapDatum" },
1210  { 0x10013, "exif:GPSDestLatitudeRef" },
1211  { 0x10014, "exif:GPSDestLatitude" },
1212  { 0x10015, "exif:GPSDestLongitudeRef" },
1213  { 0x10016, "exif:GPSDestLongitude" },
1214  { 0x10017, "exif:GPSDestBearingRef" },
1215  { 0x10018, "exif:GPSDestBearing" },
1216  { 0x10019, "exif:GPSDestDistanceRef" },
1217  { 0x1001a, "exif:GPSDestDistance" },
1218  { 0x1001b, "exif:GPSProcessingMethod" },
1219  { 0x1001c, "exif:GPSAreaInformation" },
1220  { 0x1001d, "exif:GPSDateStamp" },
1221  { 0x1001e, "exif:GPSDifferential" },
1222  { 0x1001f, "exif:GPSHPositioningError" },
1223  { 0x00000, "" }
1224  }; /* http://www.cipa.jp/std/documents/e/DC-008-Translation-2016-E.pdf */
1225 
1226  const StringInfo
1227  *profile;
1228 
1229  const unsigned char
1230  *directory,
1231  *exif;
1232 
1233  DirectoryInfo
1234  directory_stack[MaxDirectoryStack];
1235 
1236  EndianType
1237  endian;
1238 
1239  MagickBooleanType
1240  status;
1241 
1242  register ssize_t
1243  i;
1244 
1245  size_t
1246  entry,
1247  length,
1248  number_entries,
1249  tag,
1250  tag_value;
1251 
1252  SplayTreeInfo
1253  *exif_resources;
1254 
1255  ssize_t
1256  all,
1257  id,
1258  level,
1259  offset,
1260  tag_offset;
1261 
1262  static int
1263  tag_bytes[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
1264 
1265  /*
1266  If EXIF data exists, then try to parse the request for a tag.
1267  */
1268  profile=GetImageProfile(image,"exif");
1269  if (profile == (const StringInfo *) NULL)
1270  return(MagickFalse);
1271  if ((property == (const char *) NULL) || (*property == '\0'))
1272  return(MagickFalse);
1273  while (isspace((int) ((unsigned char) *property)) != 0)
1274  property++;
1275  if (strlen(property) <= 5)
1276  return(MagickFalse);
1277  all=0;
1278  tag=(~0UL);
1279  switch (*(property+5))
1280  {
1281  case '*':
1282  {
1283  /*
1284  Caller has asked for all the tags in the EXIF data.
1285  */
1286  tag=0;
1287  all=1; /* return the data in description=value format */
1288  break;
1289  }
1290  case '!':
1291  {
1292  tag=0;
1293  all=2; /* return the data in tagid=value format */
1294  break;
1295  }
1296  case '#':
1297  case '@':
1298  {
1299  int
1300  c;
1301 
1302  size_t
1303  n;
1304 
1305  /*
1306  Check for a hex based tag specification first.
1307  */
1308  tag=(*(property+5) == '@') ? 1UL : 0UL;
1309  property+=6;
1310  n=strlen(property);
1311  if (n != 4)
1312  return(MagickFalse);
1313  /*
1314  Parse tag specification as a hex number.
1315  */
1316  n/=4;
1317  do
1318  {
1319  for (i=(ssize_t) n-1L; i >= 0; i--)
1320  {
1321  c=(*property++);
1322  tag<<=4;
1323  if ((c >= '0') && (c <= '9'))
1324  tag|=(c-'0');
1325  else
1326  if ((c >= 'A') && (c <= 'F'))
1327  tag|=(c-('A'-10));
1328  else
1329  if ((c >= 'a') && (c <= 'f'))
1330  tag|=(c-('a'-10));
1331  else
1332  return(MagickFalse);
1333  }
1334  } while (*property != '\0');
1335  break;
1336  }
1337  default:
1338  {
1339  /*
1340  Try to match the text with a tag name instead.
1341  */
1342  for (i=0; ; i++)
1343  {
1344  if (EXIFTag[i].tag == 0)
1345  break;
1346  if (LocaleCompare(EXIFTag[i].description,property) == 0)
1347  {
1348  tag=(size_t) EXIFTag[i].tag;
1349  break;
1350  }
1351  }
1352  break;
1353  }
1354  }
1355  if (tag == (~0UL))
1356  return(MagickFalse);
1357  length=GetStringInfoLength(profile);
1358  if (length < 6)
1359  return(MagickFalse);
1360  exif=GetStringInfoDatum(profile);
1361  while (length != 0)
1362  {
1363  if (ReadPropertyByte(&exif,&length) != 0x45)
1364  continue;
1365  if (ReadPropertyByte(&exif,&length) != 0x78)
1366  continue;
1367  if (ReadPropertyByte(&exif,&length) != 0x69)
1368  continue;
1369  if (ReadPropertyByte(&exif,&length) != 0x66)
1370  continue;
1371  if (ReadPropertyByte(&exif,&length) != 0x00)
1372  continue;
1373  if (ReadPropertyByte(&exif,&length) != 0x00)
1374  continue;
1375  break;
1376  }
1377  if (length < 16)
1378  return(MagickFalse);
1379  id=(ssize_t) ReadPropertySignedShort(LSBEndian,exif);
1380  endian=LSBEndian;
1381  if (id == 0x4949)
1382  endian=LSBEndian;
1383  else
1384  if (id == 0x4D4D)
1385  endian=MSBEndian;
1386  else
1387  return(MagickFalse);
1388  if (ReadPropertyUnsignedShort(endian,exif+2) != 0x002a)
1389  return(MagickFalse);
1390  /*
1391  This the offset to the first IFD.
1392  */
1393  offset=(ssize_t) ReadPropertySignedLong(endian,exif+4);
1394  if ((offset < 0) || (size_t) offset >= length)
1395  return(MagickFalse);
1396  /*
1397  Set the pointer to the first IFD and follow it were it leads.
1398  */
1399  status=MagickFalse;
1400  directory=exif+offset;
1401  level=0;
1402  entry=0;
1403  tag_offset=0;
1404  exif_resources=NewSplayTree((int (*)(const void *,const void *)) NULL,
1405  (void *(*)(void *)) NULL,(void *(*)(void *)) NULL);
1406  do
1407  {
1408  /*
1409  If there is anything on the stack then pop it off.
1410  */
1411  if (level > 0)
1412  {
1413  level--;
1414  directory=directory_stack[level].directory;
1415  entry=directory_stack[level].entry;
1416  tag_offset=directory_stack[level].offset;
1417  }
1418  if ((directory < exif) || (directory > (exif+length-2)))
1419  break;
1420  /*
1421  Determine how many entries there are in the current IFD.
1422  */
1423  number_entries=(size_t) ReadPropertyUnsignedShort(endian,directory);
1424  for ( ; entry < number_entries; entry++)
1425  {
1426  register unsigned char
1427  *p,
1428  *q;
1429 
1430  size_t
1431  format;
1432 
1433  ssize_t
1434  components,
1435  number_bytes;
1436 
1437  q=(unsigned char *) (directory+(12*entry)+2);
1438  if (q > (exif+length-12))
1439  break; /* corrupt EXIF */
1440  if (GetValueFromSplayTree(exif_resources,q) == q)
1441  break;
1442  (void) AddValueToSplayTree(exif_resources,q,q);
1443  tag_value=(size_t) ReadPropertyUnsignedShort(endian,q)+tag_offset;
1444  format=(size_t) ReadPropertyUnsignedShort(endian,q+2);
1445  if (format >= (sizeof(tag_bytes)/sizeof(*tag_bytes)))
1446  break;
1447  if (format == 0)
1448  break; /* corrupt EXIF */
1449  components=(ssize_t) ReadPropertySignedLong(endian,q+4);
1450  if (components < 0)
1451  break; /* corrupt EXIF */
1452  number_bytes=(size_t) components*tag_bytes[format];
1453  if (number_bytes < components)
1454  break; /* prevent overflow */
1455  if (number_bytes <= 4)
1456  p=q+8;
1457  else
1458  {
1459  ssize_t
1460  dir_offset;
1461 
1462  /*
1463  The directory entry contains an offset.
1464  */
1465  dir_offset=(ssize_t) ReadPropertySignedLong(endian,q+8);
1466  if ((dir_offset < 0) || (size_t) dir_offset >= length)
1467  continue;
1468  if (((size_t) dir_offset+number_bytes) < (size_t) dir_offset)
1469  continue; /* prevent overflow */
1470  if (((size_t) dir_offset+number_bytes) > length)
1471  continue;
1472  p=(unsigned char *) (exif+dir_offset);
1473  }
1474  if ((all != 0) || (tag == (size_t) tag_value))
1475  {
1476  char
1477  buffer[MagickPathExtent],
1478  *value;
1479 
1480  if ((p < exif) || (p > (exif+length-tag_bytes[format])))
1481  break;
1482  value=(char *) NULL;
1483  *buffer='\0';
1484  switch (format)
1485  {
1486  case EXIF_FMT_BYTE:
1487  case EXIF_FMT_UNDEFINED:
1488  {
1489  EXIFMultipleValues(1,"%.20g",(double) (*(unsigned char *) p1));
1490  break;
1491  }
1492  case EXIF_FMT_SBYTE:
1493  {
1494  EXIFMultipleValues(1,"%.20g",(double) (*(signed char *) p1));
1495  break;
1496  }
1497  case EXIF_FMT_SSHORT:
1498  {
1499  EXIFMultipleValues(2,"%hd",ReadPropertySignedShort(endian,p1));
1500  break;
1501  }
1502  case EXIF_FMT_USHORT:
1503  {
1504  EXIFMultipleValues(2,"%hu",ReadPropertyUnsignedShort(endian,p1));
1505  break;
1506  }
1507  case EXIF_FMT_ULONG:
1508  {
1509  EXIFMultipleValues(4,"%.20g",(double)
1510  ReadPropertyUnsignedLong(endian,p1));
1511  break;
1512  }
1513  case EXIF_FMT_SLONG:
1514  {
1515  EXIFMultipleValues(4,"%.20g",(double)
1516  ReadPropertySignedLong(endian,p1));
1517  break;
1518  }
1519  case EXIF_FMT_URATIONAL:
1520  {
1521  EXIFMultipleFractions(8,"%.20g/%.20g",(double)
1522  ReadPropertyUnsignedLong(endian,p1),(double)
1523  ReadPropertyUnsignedLong(endian,p1+4));
1524  break;
1525  }
1526  case EXIF_FMT_SRATIONAL:
1527  {
1528  EXIFMultipleFractions(8,"%.20g/%.20g",(double)
1529  ReadPropertySignedLong(endian,p1),(double)
1530  ReadPropertySignedLong(endian,p1+4));
1531  break;
1532  }
1533  case EXIF_FMT_SINGLE:
1534  {
1535  EXIFMultipleValues(4,"%f",(double) *(float *) p1);
1536  break;
1537  }
1538  case EXIF_FMT_DOUBLE:
1539  {
1540  EXIFMultipleValues(8,"%f",*(double *) p1);
1541  break;
1542  }
1543  case EXIF_FMT_STRING:
1544  default:
1545  {
1546  if ((p < exif) || (p > (exif+length-number_bytes)))
1547  break;
1548  value=(char *) NULL;
1549  if (~((size_t) number_bytes) >= 1)
1550  value=(char *) AcquireQuantumMemory((size_t) number_bytes+1UL,
1551  sizeof(*value));
1552  if (value != (char *) NULL)
1553  {
1554  for (i=0; i < (ssize_t) number_bytes; i++)
1555  {
1556  value[i]='.';
1557  if ((isprint((int) p[i]) != 0) || (p[i] == '\0'))
1558  value[i]=(char) p[i];
1559  }
1560  value[i]='\0';
1561  }
1562  break;
1563  }
1564  }
1565  if (value != (char *) NULL)
1566  {
1567  char
1568  *key;
1569 
1570  key=AcquireString(property);
1571  switch (all)
1572  {
1573  case 1:
1574  {
1575  const char
1576  *description;
1577 
1578  description="unknown";
1579  for (i=0; ; i++)
1580  {
1581  if (EXIFTag[i].tag == 0)
1582  break;
1583  if (EXIFTag[i].tag == tag_value)
1584  {
1585  description=EXIFTag[i].description;
1586  break;
1587  }
1588  }
1589  (void) FormatLocaleString(key,MagickPathExtent,"%s",
1590  description);
1591  if (level == 2)
1592  (void) SubstituteString(&key,"exif:","exif:thumbnail:");
1593  break;
1594  }
1595  case 2:
1596  {
1597  if (tag_value < 0x10000)
1598  (void) FormatLocaleString(key,MagickPathExtent,"#%04lx",
1599  (unsigned long) tag_value);
1600  else
1601  if (tag_value < 0x20000)
1602  (void) FormatLocaleString(key,MagickPathExtent,"@%04lx",
1603  (unsigned long) (tag_value & 0xffff));
1604  else
1605  (void) FormatLocaleString(key,MagickPathExtent,"unknown");
1606  break;
1607  }
1608  default:
1609  {
1610  if (level == 2)
1611  (void) SubstituteString(&key,"exif:","exif:thumbnail:");
1612  }
1613  }
1614  if ((image->properties == (void *) NULL) ||
1615  (GetValueFromSplayTree((SplayTreeInfo *) image->properties,
1616  key) == (const void *) NULL))
1617  (void) SetImageProperty((Image *) image,key,value,exception);
1618  value=DestroyString(value);
1619  key=DestroyString(key);
1620  status=MagickTrue;
1621  }
1622  }
1623  if ((tag_value == TAG_EXIF_OFFSET) ||
1624  (tag_value == TAG_INTEROP_OFFSET) || (tag_value == TAG_GPS_OFFSET))
1625  {
1626  ssize_t
1627  tag_offset1;
1628 
1629  tag_offset1=(ssize_t) ReadPropertySignedLong(endian,p);
1630  if (((size_t) tag_offset1 < length) &&
1631  (level < (MaxDirectoryStack-2)))
1632  {
1633  ssize_t
1634  tag_offset2;
1635 
1636  tag_offset2=(ssize_t) ((tag_value == TAG_GPS_OFFSET) ? 0x10000 :
1637  0);
1638  directory_stack[level].directory=directory;
1639  entry++;
1640  directory_stack[level].entry=entry;
1641  directory_stack[level].offset=tag_offset;
1642  level++;
1643  /*
1644  Check for duplicate tag.
1645  */
1646  for (i=0; i < level; i++)
1647  if (directory_stack[i].directory == (exif+tag_offset1))
1648  break;
1649  if (i < level)
1650  break; /* duplicate tag */
1651  directory_stack[level].directory=exif+tag_offset1;
1652  directory_stack[level].offset=tag_offset2;
1653  directory_stack[level].entry=0;
1654  level++;
1655  if ((directory+2+(12*number_entries)+4) > (exif+length))
1656  break;
1657  tag_offset1=(ssize_t) ReadPropertySignedLong(endian,directory+
1658  2+(12*number_entries));
1659  if ((tag_offset1 != 0) && ((size_t) tag_offset1 < length) &&
1660  (level < (MaxDirectoryStack-2)))
1661  {
1662  directory_stack[level].directory=exif+tag_offset1;
1663  directory_stack[level].entry=0;
1664  directory_stack[level].offset=tag_offset2;
1665  level++;
1666  }
1667  }
1668  break;
1669  }
1670  }
1671  } while (level > 0);
1672  exif_resources=DestroySplayTree(exif_resources);
1673  return(status);
1674 }
1675 
1676 static MagickBooleanType GetICCProperty(const Image *image,const char *property,
1677  ExceptionInfo *exception)
1678 {
1679  const StringInfo
1680  *profile;
1681 
1682  magick_unreferenced(property);
1683 
1684  profile=GetImageProfile(image,"icc");
1685  if (profile == (StringInfo *) NULL)
1686  profile=GetImageProfile(image,"icm");
1687  if (profile == (StringInfo *) NULL)
1688  return(MagickFalse);
1689  if (GetStringInfoLength(profile) < 128)
1690  return(MagickFalse); /* minimum ICC profile length */
1691 #if defined(MAGICKCORE_LCMS_DELEGATE)
1692  {
1693  cmsHPROFILE
1694  icc_profile;
1695 
1696  icc_profile=cmsOpenProfileFromMem(GetStringInfoDatum(profile),
1697  (cmsUInt32Number) GetStringInfoLength(profile));
1698  if (icc_profile != (cmsHPROFILE *) NULL)
1699  {
1700 #if defined(LCMS_VERSION) && (LCMS_VERSION < 2000)
1701  const char
1702  *name;
1703 
1704  name=cmsTakeProductName(icc_profile);
1705  if (name != (const char *) NULL)
1706  (void) SetImageProperty((Image *) image,"icc:name",name,exception);
1707 #else
1708  char
1709  info[MagickPathExtent];
1710 
1711  unsigned int
1712  extent;
1713 
1714  (void) memset(info,0,sizeof(info));
1715  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoDescription,"en","US",
1716  NULL,0);
1717  if (extent != 0)
1718  {
1719  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoDescription,"en",
1720  "US",info,MagickMin(MagickPathExtent-1,extent));
1721  (void) SetImageProperty((Image *) image,"icc:description",info,
1722  exception);
1723  }
1724  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoManufacturer,"en","US",
1725  NULL,0);
1726  if (extent != 0)
1727  {
1728  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoManufacturer,"en",
1729  "US",info,MagickMin(MagickPathExtent-1,extent));
1730  (void) SetImageProperty((Image *) image,"icc:manufacturer",info,
1731  exception);
1732  }
1733  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoModel,"en","US",
1734  NULL,0);
1735  if (extent != 0)
1736  {
1737  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoModel,"en","US",
1738  info,MagickMin(MagickPathExtent-1,extent));
1739  (void) SetImageProperty((Image *) image,"icc:model",info,exception);
1740  }
1741  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoCopyright,"en","US",
1742  NULL,0);
1743  if (extent != 0)
1744  {
1745  extent=cmsGetProfileInfoASCII(icc_profile,cmsInfoCopyright,"en",
1746  "US",info,MagickMin(MagickPathExtent-1,extent));
1747  (void) SetImageProperty((Image *) image,"icc:copyright",info,
1748  exception);
1749  }
1750 #endif
1751  (void) cmsCloseProfile(icc_profile);
1752  }
1753  }
1754 #endif
1755  return(MagickTrue);
1756 }
1757 
1758 static MagickBooleanType SkipXMPValue(const char *value)
1759 {
1760  if (value == (const char*) NULL)
1761  return(MagickTrue);
1762  while (*value != '\0')
1763  {
1764  if (isspace((int) ((unsigned char) *value)) == 0)
1765  return(MagickFalse);
1766  value++;
1767  }
1768  return(MagickTrue);
1769 }
1770 
1771 static MagickBooleanType GetXMPProperty(const Image *image,const char *property)
1772 {
1773  char
1774  *xmp_profile;
1775 
1776  const char
1777  *content;
1778 
1779  const StringInfo
1780  *profile;
1781 
1782  ExceptionInfo
1783  *exception;
1784 
1785  MagickBooleanType
1786  status;
1787 
1788  register const char
1789  *p;
1790 
1791  XMLTreeInfo
1792  *child,
1793  *description,
1794  *node,
1795  *rdf,
1796  *xmp;
1797 
1798  profile=GetImageProfile(image,"xmp");
1799  if (profile == (StringInfo *) NULL)
1800  return(MagickFalse);
1801  if (GetStringInfoLength(profile) < 17)
1802  return(MagickFalse);
1803  if ((property == (const char *) NULL) || (*property == '\0'))
1804  return(MagickFalse);
1805  xmp_profile=StringInfoToString(profile);
1806  if (xmp_profile == (char *) NULL)
1807  return(MagickFalse);
1808  for (p=xmp_profile; *p != '\0'; p++)
1809  if ((*p == '<') && (*(p+1) == 'x'))
1810  break;
1811  exception=AcquireExceptionInfo();
1812  xmp=NewXMLTree((char *) p,exception);
1813  xmp_profile=DestroyString(xmp_profile);
1814  exception=DestroyExceptionInfo(exception);
1815  if (xmp == (XMLTreeInfo *) NULL)
1816  return(MagickFalse);
1817  status=MagickFalse;
1818  rdf=GetXMLTreeChild(xmp,"rdf:RDF");
1819  if (rdf != (XMLTreeInfo *) NULL)
1820  {
1821  if (image->properties == (void *) NULL)
1822  ((Image *) image)->properties=NewSplayTree(CompareSplayTreeString,
1823  RelinquishMagickMemory,RelinquishMagickMemory);
1824  description=GetXMLTreeChild(rdf,"rdf:Description");
1825  while (description != (XMLTreeInfo *) NULL)
1826  {
1827  char
1828  *xmp_namespace;
1829 
1830  node=GetXMLTreeChild(description,(const char *) NULL);
1831  while (node != (XMLTreeInfo *) NULL)
1832  {
1833  child=GetXMLTreeChild(node,(const char *) NULL);
1834  content=GetXMLTreeContent(node);
1835  if ((child == (XMLTreeInfo *) NULL) &&
1836  (SkipXMPValue(content) == MagickFalse))
1837  {
1838  xmp_namespace=ConstantString(GetXMLTreeTag(node));
1839  (void) SubstituteString(&xmp_namespace,"exif:","xmp:");
1840  (void) AddValueToSplayTree((SplayTreeInfo *) image->properties,
1841  xmp_namespace,ConstantString(content));
1842  }
1843  while (child != (XMLTreeInfo *) NULL)
1844  {
1845  content=GetXMLTreeContent(child);
1846  if (SkipXMPValue(content) == MagickFalse)
1847  {
1848  xmp_namespace=ConstantString(GetXMLTreeTag(node));
1849  (void) SubstituteString(&xmp_namespace,"exif:","xmp:");
1850  (void) AddValueToSplayTree((SplayTreeInfo *) image->properties,
1851  xmp_namespace,ConstantString(content));
1852  }
1853  child=GetXMLTreeSibling(child);
1854  }
1855  node=GetXMLTreeSibling(node);
1856  }
1857  description=GetNextXMLTreeTag(description);
1858  }
1859  }
1860  xmp=DestroyXMLTree(xmp);
1861  return(status);
1862 }
1863 
1864 static char *TracePSClippath(const unsigned char *blob,size_t length)
1865 {
1866  char
1867  *path,
1868  *message;
1869 
1870  MagickBooleanType
1871  in_subpath;
1872 
1873  PointInfo
1874  first[3],
1875  last[3],
1876  point[3];
1877 
1878  register ssize_t
1879  i,
1880  x;
1881 
1882  ssize_t
1883  knot_count,
1884  selector,
1885  y;
1886 
1887  path=AcquireString((char *) NULL);
1888  if (path == (char *) NULL)
1889  return((char *) NULL);
1890  message=AcquireString((char *) NULL);
1891  (void) FormatLocaleString(message,MagickPathExtent,"/ClipImage\n");
1892  (void) ConcatenateString(&path,message);
1893  (void) FormatLocaleString(message,MagickPathExtent,"{\n");
1894  (void) ConcatenateString(&path,message);
1895  (void) FormatLocaleString(message,MagickPathExtent,
1896  " /c {curveto} bind def\n");
1897  (void) ConcatenateString(&path,message);
1898  (void) FormatLocaleString(message,MagickPathExtent,
1899  " /l {lineto} bind def\n");
1900  (void) ConcatenateString(&path,message);
1901  (void) FormatLocaleString(message,MagickPathExtent,
1902  " /m {moveto} bind def\n");
1903  (void) ConcatenateString(&path,message);
1904  (void) FormatLocaleString(message,MagickPathExtent,
1905  " /v {currentpoint 6 2 roll curveto} bind def\n");
1906  (void) ConcatenateString(&path,message);
1907  (void) FormatLocaleString(message,MagickPathExtent,
1908  " /y {2 copy curveto} bind def\n");
1909  (void) ConcatenateString(&path,message);
1910  (void) FormatLocaleString(message,MagickPathExtent,
1911  " /z {closepath} bind def\n");
1912  (void) ConcatenateString(&path,message);
1913  (void) FormatLocaleString(message,MagickPathExtent," newpath\n");
1914  (void) ConcatenateString(&path,message);
1915  /*
1916  The clipping path format is defined in "Adobe Photoshop File Formats
1917  Specification" version 6.0 downloadable from adobe.com.
1918  */
1919  (void) memset(point,0,sizeof(point));
1920  (void) memset(first,0,sizeof(first));
1921  (void) memset(last,0,sizeof(last));
1922  knot_count=0;
1923  in_subpath=MagickFalse;
1924  while (length > 0)
1925  {
1926  selector=(ssize_t) ReadPropertyMSBShort(&blob,&length);
1927  switch (selector)
1928  {
1929  case 0:
1930  case 3:
1931  {
1932  if (knot_count != 0)
1933  {
1934  blob+=24;
1935  length-=MagickMin(24,(ssize_t) length);
1936  break;
1937  }
1938  /*
1939  Expected subpath length record.
1940  */
1941  knot_count=(ssize_t) ReadPropertyMSBShort(&blob,&length);
1942  blob+=22;
1943  length-=MagickMin(22,(ssize_t) length);
1944  break;
1945  }
1946  case 1:
1947  case 2:
1948  case 4:
1949  case 5:
1950  {
1951  if (knot_count == 0)
1952  {
1953  /*
1954  Unexpected subpath knot
1955  */
1956  blob+=24;
1957  length-=MagickMin(24,(ssize_t) length);
1958  break;
1959  }
1960  /*
1961  Add sub-path knot
1962  */
1963  for (i=0; i < 3; i++)
1964  {
1965  size_t
1966  xx,
1967  yy;
1968 
1969  yy=(size_t) ReadPropertyMSBLong(&blob,&length);
1970  xx=(size_t) ReadPropertyMSBLong(&blob,&length);
1971  x=(ssize_t) xx;
1972  if (xx > 2147483647)
1973  x=(ssize_t) xx-4294967295U-1;
1974  y=(ssize_t) yy;
1975  if (yy > 2147483647)
1976  y=(ssize_t) yy-4294967295U-1;
1977  point[i].x=(double) x/4096/4096;
1978  point[i].y=1.0-(double) y/4096/4096;
1979  }
1980  if (in_subpath == MagickFalse)
1981  {
1982  (void) FormatLocaleString(message,MagickPathExtent," %g %g m\n",
1983  point[1].x,point[1].y);
1984  for (i=0; i < 3; i++)
1985  {
1986  first[i]=point[i];
1987  last[i]=point[i];
1988  }
1989  }
1990  else
1991  {
1992  /*
1993  Handle special cases when Bezier curves are used to describe
1994  corners and straight lines.
1995  */
1996  if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
1997  (point[0].x == point[1].x) && (point[0].y == point[1].y))
1998  (void) FormatLocaleString(message,MagickPathExtent,
1999  " %g %g l\n",point[1].x,point[1].y);
2000  else
2001  if ((last[1].x == last[2].x) && (last[1].y == last[2].y))
2002  (void) FormatLocaleString(message,MagickPathExtent,
2003  " %g %g %g %g v\n",point[0].x,point[0].y,
2004  point[1].x,point[1].y);
2005  else
2006  if ((point[0].x == point[1].x) && (point[0].y == point[1].y))
2007  (void) FormatLocaleString(message,MagickPathExtent,
2008  " %g %g %g %g y\n",last[2].x,last[2].y,
2009  point[1].x,point[1].y);
2010  else
2011  (void) FormatLocaleString(message,MagickPathExtent,
2012  " %g %g %g %g %g %g c\n",last[2].x,
2013  last[2].y,point[0].x,point[0].y,point[1].x,point[1].y);
2014  for (i=0; i < 3; i++)
2015  last[i]=point[i];
2016  }
2017  (void) ConcatenateString(&path,message);
2018  in_subpath=MagickTrue;
2019  knot_count--;
2020  /*
2021  Close the subpath if there are no more knots.
2022  */
2023  if (knot_count == 0)
2024  {
2025  /*
2026  Same special handling as above except we compare to the
2027  first point in the path and close the path.
2028  */
2029  if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
2030  (first[0].x == first[1].x) && (first[0].y == first[1].y))
2031  (void) FormatLocaleString(message,MagickPathExtent,
2032  " %g %g l z\n",first[1].x,first[1].y);
2033  else
2034  if ((last[1].x == last[2].x) && (last[1].y == last[2].y))
2035  (void) FormatLocaleString(message,MagickPathExtent,
2036  " %g %g %g %g v z\n",first[0].x,first[0].y,
2037  first[1].x,first[1].y);
2038  else
2039  if ((first[0].x == first[1].x) && (first[0].y == first[1].y))
2040  (void) FormatLocaleString(message,MagickPathExtent,
2041  " %g %g %g %g y z\n",last[2].x,last[2].y,
2042  first[1].x,first[1].y);
2043  else
2044  (void) FormatLocaleString(message,MagickPathExtent,
2045  " %g %g %g %g %g %g c z\n",last[2].x,
2046  last[2].y,first[0].x,first[0].y,first[1].x,first[1].y);
2047  (void) ConcatenateString(&path,message);
2048  in_subpath=MagickFalse;
2049  }
2050  break;
2051  }
2052  case 6:
2053  case 7:
2054  case 8:
2055  default:
2056  {
2057  blob+=24;
2058  length-=MagickMin(24,(ssize_t) length);
2059  break;
2060  }
2061  }
2062  }
2063  /*
2064  Returns an empty PS path if the path has no knots.
2065  */
2066  (void) FormatLocaleString(message,MagickPathExtent," eoclip\n");
2067  (void) ConcatenateString(&path,message);
2068  (void) FormatLocaleString(message,MagickPathExtent,"} bind def");
2069  (void) ConcatenateString(&path,message);
2070  message=DestroyString(message);
2071  return(path);
2072 }
2073 
2074 static inline void TraceBezierCurve(char *message,PointInfo *last,
2075  PointInfo *point)
2076 {
2077  /*
2078  Handle special cases when Bezier curves are used to describe
2079  corners and straight lines.
2080  */
2081  if (((last+1)->x == (last+2)->x) && ((last+1)->y == (last+2)->y) &&
2082  (point->x == (point+1)->x) && (point->y == (point+1)->y))
2083  (void) FormatLocaleString(message,MagickPathExtent,
2084  "L %g %g\n",point[1].x,point[1].y);
2085  else
2086  (void) FormatLocaleString(message,MagickPathExtent,"C %g %g %g %g %g %g\n",
2087  (last+2)->x,(last+2)->y,point->x,point->y,(point+1)->x,(point+1)->y);
2088 }
2089 
2090 static char *TraceSVGClippath(const unsigned char *blob,size_t length,
2091  const size_t columns,const size_t rows)
2092 {
2093  char
2094  *path,
2095  *message;
2096 
2097  MagickBooleanType
2098  in_subpath;
2099 
2100  PointInfo
2101  first[3],
2102  last[3],
2103  point[3];
2104 
2105  register ssize_t
2106  i;
2107 
2108  ssize_t
2109  knot_count,
2110  selector,
2111  x,
2112  y;
2113 
2114  path=AcquireString((char *) NULL);
2115  if (path == (char *) NULL)
2116  return((char *) NULL);
2117  message=AcquireString((char *) NULL);
2118  (void) FormatLocaleString(message,MagickPathExtent,(
2119  "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"
2120  "<svg xmlns=\"http://www.w3.org/2000/svg\""
2121  " width=\"%.20g\" height=\"%.20g\">\n"
2122  "<g>\n"
2123  "<path fill-rule=\"evenodd\" style=\"fill:#000000;stroke:#000000;"
2124  "stroke-width:0;stroke-antialiasing:false\" d=\"\n"),(double) columns,
2125  (double) rows);
2126  (void) ConcatenateString(&path,message);
2127  (void) memset(point,0,sizeof(point));
2128  (void) memset(first,0,sizeof(first));
2129  (void) memset(last,0,sizeof(last));
2130  knot_count=0;
2131  in_subpath=MagickFalse;
2132  while (length != 0)
2133  {
2134  selector=(ssize_t) ReadPropertyMSBShort(&blob,&length);
2135  switch (selector)
2136  {
2137  case 0:
2138  case 3:
2139  {
2140  if (knot_count != 0)
2141  {
2142  blob+=24;
2143  length-=MagickMin(24,(ssize_t) length);
2144  break;
2145  }
2146  /*
2147  Expected subpath length record.
2148  */
2149  knot_count=(ssize_t) ReadPropertyMSBShort(&blob,&length);
2150  blob+=22;
2151  length-=MagickMin(22,(ssize_t) length);
2152  break;
2153  }
2154  case 1:
2155  case 2:
2156  case 4:
2157  case 5:
2158  {
2159  if (knot_count == 0)
2160  {
2161  /*
2162  Unexpected subpath knot.
2163  */
2164  blob+=24;
2165  length-=MagickMin(24,(ssize_t) length);
2166  break;
2167  }
2168  /*
2169  Add sub-path knot
2170  */
2171  for (i=0; i < 3; i++)
2172  {
2173  unsigned int
2174  xx,
2175  yy;
2176 
2177  yy=(unsigned int) ReadPropertyMSBLong(&blob,&length);
2178  xx=(unsigned int) ReadPropertyMSBLong(&blob,&length);
2179  x=(ssize_t) xx;
2180  if (xx > 2147483647)
2181  x=(ssize_t) xx-4294967295U-1;
2182  y=(ssize_t) yy;
2183  if (yy > 2147483647)
2184  y=(ssize_t) yy-4294967295U-1;
2185  point[i].x=(double) x*columns/4096/4096;
2186  point[i].y=(double) y*rows/4096/4096;
2187  }
2188  if (in_subpath == MagickFalse)
2189  {
2190  (void) FormatLocaleString(message,MagickPathExtent,"M %g %g\n",
2191  point[1].x,point[1].y);
2192  for (i=0; i < 3; i++)
2193  {
2194  first[i]=point[i];
2195  last[i]=point[i];
2196  }
2197  }
2198  else
2199  {
2200  TraceBezierCurve(message,last,point);
2201  for (i=0; i < 3; i++)
2202  last[i]=point[i];
2203  }
2204  (void) ConcatenateString(&path,message);
2205  in_subpath=MagickTrue;
2206  knot_count--;
2207  /*
2208  Close the subpath if there are no more knots.
2209  */
2210  if (knot_count == 0)
2211  {
2212  TraceBezierCurve(message,last,first);
2213  (void) ConcatenateString(&path,message);
2214  in_subpath=MagickFalse;
2215  }
2216  break;
2217  }
2218  case 6:
2219  case 7:
2220  case 8:
2221  default:
2222  {
2223  blob+=24;
2224  length-=MagickMin(24,(ssize_t) length);
2225  break;
2226  }
2227  }
2228  }
2229  /*
2230  Return an empty SVG image if the path does not have knots.
2231  */
2232  (void) ConcatenateString(&path,"\"/>\n</g>\n</svg>\n");
2233  message=DestroyString(message);
2234  return(path);
2235 }
2236 
2237 MagickExport const char *GetImageProperty(const Image *image,
2238  const char *property,ExceptionInfo *exception)
2239 {
2240  MagickBooleanType
2241  read_from_properties;
2242 
2243  register const char
2244  *p;
2245 
2246  size_t
2247  property_length;
2248 
2249  assert(image != (Image *) NULL);
2250  assert(image->signature == MagickCoreSignature);
2251  if (image->debug != MagickFalse)
2252  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2253  if ((property == (const char *) NULL) || (*property == '\0'))
2254  return((const char *) NULL);
2255  read_from_properties=MagickTrue;
2256  property_length=strlen(property);
2257  if (property_length > 2 && (*(property+(property_length-2)) == ':') &&
2258  (*(property+(property_length-1)) == '*'))
2259  read_from_properties=MagickFalse;
2260  if (read_from_properties != MagickFalse)
2261  {
2262  p=(const char *) NULL;
2263  if (image->properties != (void *) NULL)
2264  {
2265  if (property == (const char *) NULL)
2266  return((const char *) GetRootValueFromSplayTree((SplayTreeInfo *)
2267  image->properties));
2268  p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2269  image->properties,property);
2270  if (p != (const char *) NULL)
2271  return(p);
2272  }
2273  if ((property == (const char *) NULL) ||
2274  (strchr(property,':') == (char *) NULL))
2275  return(p);
2276  }
2277  switch (*property)
2278  {
2279  case '8':
2280  {
2281  if (LocaleNCompare("8bim:",property,5) == 0)
2282  {
2283  (void) Get8BIMProperty(image,property,exception);
2284  break;
2285  }
2286  break;
2287  }
2288  case 'E':
2289  case 'e':
2290  {
2291  if (LocaleNCompare("exif:",property,5) == 0)
2292  {
2293  (void) GetEXIFProperty(image,property,exception);
2294  break;
2295  }
2296  break;
2297  }
2298  case 'I':
2299  case 'i':
2300  {
2301  if ((LocaleNCompare("icc:",property,4) == 0) ||
2302  (LocaleNCompare("icm:",property,4) == 0))
2303  {
2304  (void) GetICCProperty(image,property,exception);
2305  break;
2306  }
2307  if (LocaleNCompare("iptc:",property,5) == 0)
2308  {
2309  (void) GetIPTCProperty(image,property,exception);
2310  break;
2311  }
2312  break;
2313  }
2314  case 'X':
2315  case 'x':
2316  {
2317  if (LocaleNCompare("xmp:",property,4) == 0)
2318  {
2319  (void) GetXMPProperty(image,property);
2320  break;
2321  }
2322  break;
2323  }
2324  default:
2325  break;
2326  }
2327  if ((image->properties != (void *) NULL) &&
2328  (read_from_properties != MagickFalse))
2329  {
2330  p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2331  image->properties,property);
2332  return(p);
2333  }
2334  return((const char *) NULL);
2335 }
2336 
2337 /*
2338 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2339 % %
2340 % %
2341 % %
2342 + G e t M a g i c k P r o p e r t y %
2343 % %
2344 % %
2345 % %
2346 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2347 %
2348 % GetMagickProperty() gets attributes or calculated values that is associated
2349 % with a fixed known property name, or single letter property. It may be
2350 % called if no image is defined (IMv7), in which case only global image_info
2351 % values are available:
2352 %
2353 % \n newline
2354 % \r carriage return
2355 % < less-than character.
2356 % > greater-than character.
2357 % & ampersand character.
2358 % %% a percent sign
2359 % %b file size of image read in
2360 % %c comment meta-data property
2361 % %d directory component of path
2362 % %e filename extension or suffix
2363 % %f filename (including suffix)
2364 % %g layer canvas page geometry (equivalent to "%Wx%H%X%Y")
2365 % %h current image height in pixels
2366 % %i image filename (note: becomes output filename for "info:")
2367 % %k CALCULATED: number of unique colors
2368 % %l label meta-data property
2369 % %m image file format (file magic)
2370 % %n number of images in current image sequence
2371 % %o output filename (used for delegates)
2372 % %p index of image in current image list
2373 % %q quantum depth (compile-time constant)
2374 % %r image class and colorspace
2375 % %s scene number (from input unless re-assigned)
2376 % %t filename without directory or extension (suffix)
2377 % %u unique temporary filename (used for delegates)
2378 % %w current width in pixels
2379 % %x x resolution (density)
2380 % %y y resolution (density)
2381 % %z image depth (as read in unless modified, image save depth)
2382 % %A image transparency channel enabled (true/false)
2383 % %B file size of image in bytes
2384 % %C image compression type
2385 % %D image GIF dispose method
2386 % %G original image size (%wx%h; before any resizes)
2387 % %H page (canvas) height
2388 % %M Magick filename (original file exactly as given, including read mods)
2389 % %O page (canvas) offset ( = %X%Y )
2390 % %P page (canvas) size ( = %Wx%H )
2391 % %Q image compression quality ( 0 = default )
2392 % %S ?? scenes ??
2393 % %T image time delay (in centi-seconds)
2394 % %U image resolution units
2395 % %W page (canvas) width
2396 % %X page (canvas) x offset (including sign)
2397 % %Y page (canvas) y offset (including sign)
2398 % %Z unique filename (used for delegates)
2399 % %@ CALCULATED: trim bounding box (without actually trimming)
2400 % %# CALCULATED: 'signature' hash of image values
2401 %
2402 % This routine only handles specifically known properties. It does not
2403 % handle special prefixed properties, profiles, or expressions. Nor does
2404 % it return any free-form property strings.
2405 %
2406 % The returned string is stored in a structure somewhere, and should not be
2407 % directly freed. If the string was generated (common) the string will be
2408 % stored as as either as artifact or option 'magick-property'. These may be
2409 % deleted (cleaned up) when no longer required, but neither artifact or
2410 % option is guranteed to exist.
2411 %
2412 % The format of the GetMagickProperty method is:
2413 %
2414 % const char *GetMagickProperty(ImageInfo *image_info,Image *image,
2415 % const char *property,ExceptionInfo *exception)
2416 %
2417 % A description of each parameter follows:
2418 %
2419 % o image_info: the image info (optional)
2420 %
2421 % o image: the image (optional)
2422 %
2423 % o key: the key.
2424 %
2425 % o exception: return any errors or warnings in this structure.
2426 %
2427 */
2428 static const char *GetMagickPropertyLetter(ImageInfo *image_info,
2429  Image *image,const char letter,ExceptionInfo *exception)
2430 {
2431 #define WarnNoImageReturn(format,arg) \
2432  if (image == (Image *) NULL ) { \
2433  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning, \
2434  "NoImageForProperty",format,arg); \
2435  return((const char *) NULL); \
2436  }
2437 #define WarnNoImageInfoReturn(format,arg) \
2438  if (image_info == (ImageInfo *) NULL ) { \
2439  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning, \
2440  "NoImageInfoForProperty",format,arg); \
2441  return((const char *) NULL); \
2442  }
2443 
2444  char
2445  value[MagickPathExtent]; /* formatted string to store as an artifact */
2446 
2447  const char
2448  *string; /* return a string already stored somewher */
2449 
2450  if ((image != (Image *) NULL) && (image->debug != MagickFalse))
2451  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2452  else
2453  if ((image_info != (ImageInfo *) NULL) &&
2454  (image_info->debug != MagickFalse))
2455  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s","no-images");
2456  *value='\0'; /* formatted string */
2457  string=(char *) NULL; /* constant string reference */
2458  /*
2459  Get properities that are directly defined by images.
2460  */
2461  switch (letter)
2462  {
2463  case 'b': /* image size read in - in bytes */
2464  {
2465  WarnNoImageReturn("\"%%%c\"",letter);
2466  (void) FormatMagickSize(image->extent,MagickFalse,"B",MagickPathExtent,
2467  value);
2468  if (image->extent == 0)
2469  (void) FormatMagickSize(GetBlobSize(image),MagickFalse,"B",
2470  MagickPathExtent,value);
2471  break;
2472  }
2473  case 'c': /* image comment property - empty string by default */
2474  {
2475  WarnNoImageReturn("\"%%%c\"",letter);
2476  string=GetImageProperty(image,"comment",exception);
2477  if ( string == (const char *) NULL )
2478  string="";
2479  break;
2480  }
2481  case 'd': /* Directory component of filename */
2482  {
2483  WarnNoImageReturn("\"%%%c\"",letter);
2484  GetPathComponent(image->magick_filename,HeadPath,value);
2485  if (*value == '\0')
2486  string="";
2487  break;
2488  }
2489  case 'e': /* Filename extension (suffix) of image file */
2490  {
2491  WarnNoImageReturn("\"%%%c\"",letter);
2492  GetPathComponent(image->magick_filename,ExtensionPath,value);
2493  if (*value == '\0')
2494  string="";
2495  break;
2496  }
2497  case 'f': /* Filename without directory component */
2498  {
2499  WarnNoImageReturn("\"%%%c\"",letter);
2500  GetPathComponent(image->magick_filename,TailPath,value);
2501  if (*value == '\0')
2502  string="";
2503  break;
2504  }
2505  case 'g': /* Image geometry, canvas and offset %Wx%H+%X+%Y */
2506  {
2507  WarnNoImageReturn("\"%%%c\"",letter);
2508  (void) FormatLocaleString(value,MagickPathExtent,
2509  "%.20gx%.20g%+.20g%+.20g",(double) image->page.width,(double)
2510  image->page.height,(double) image->page.x,(double) image->page.y);
2511  break;
2512  }
2513  case 'h': /* Image height (current) */
2514  {
2515  WarnNoImageReturn("\"%%%c\"",letter);
2516  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2517  (image->rows != 0 ? image->rows : image->magick_rows));
2518  break;
2519  }
2520  case 'i': /* Filename last used for an image (read or write) */
2521  {
2522  WarnNoImageReturn("\"%%%c\"",letter);
2523  string=image->filename;
2524  break;
2525  }
2526  case 'k': /* Number of unique colors */
2527  {
2528  /*
2529  FUTURE: ensure this does not generate the formatted comment!
2530  */
2531  WarnNoImageReturn("\"%%%c\"",letter);
2532  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2533  GetNumberColors(image,(FILE *) NULL,exception));
2534  break;
2535  }
2536  case 'l': /* Image label property - empty string by default */
2537  {
2538  WarnNoImageReturn("\"%%%c\"",letter);
2539  string=GetImageProperty(image,"label",exception);
2540  if (string == (const char *) NULL)
2541  string="";
2542  break;
2543  }
2544  case 'm': /* Image format (file magick) */
2545  {
2546  WarnNoImageReturn("\"%%%c\"",letter);
2547  string=image->magick;
2548  break;
2549  }
2550  case 'n': /* Number of images in the list. */
2551  {
2552  if ( image != (Image *) NULL )
2553  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2554  GetImageListLength(image));
2555  else
2556  string="0"; /* no images or scenes */
2557  break;
2558  }
2559  case 'o': /* Output Filename - for delegate use only */
2560  {
2561  WarnNoImageInfoReturn("\"%%%c\"",letter);
2562  string=image_info->filename;
2563  break;
2564  }
2565  case 'p': /* Image index in current image list */
2566  {
2567  WarnNoImageReturn("\"%%%c\"",letter);
2568  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2569  GetImageIndexInList(image));
2570  break;
2571  }
2572  case 'q': /* Quantum depth of image in memory */
2573  {
2574  WarnNoImageReturn("\"%%%c\"",letter);
2575  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2576  MAGICKCORE_QUANTUM_DEPTH);
2577  break;
2578  }
2579  case 'r': /* Image storage class, colorspace, and alpha enabled. */
2580  {
2581  ColorspaceType
2582  colorspace;
2583 
2584  WarnNoImageReturn("\"%%%c\"",letter);
2585  colorspace=image->colorspace;
2586  if ((image->columns != 0) && (image->rows != 0) &&
2587  (SetImageGray(image,exception) != MagickFalse))
2588  colorspace=GRAYColorspace; /* FUTURE: this is IMv6 not IMv7 */
2589  (void) FormatLocaleString(value,MagickPathExtent,"%s %s %s",
2590  CommandOptionToMnemonic(MagickClassOptions,(ssize_t)
2591  image->storage_class),CommandOptionToMnemonic(MagickColorspaceOptions,
2592  (ssize_t) colorspace),image->alpha_trait != UndefinedPixelTrait ?
2593  "Alpha" : "");
2594  break;
2595  }
2596  case 's': /* Image scene number */
2597  {
2598 #if 0 /* this seems non-sensical -- simplifing */
2599  if (image_info->number_scenes != 0)
2600  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2601  image_info->scene);
2602  else if (image != (Image *) NULL)
2603  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2604  image->scene);
2605  else
2606  string="0";
2607 #else
2608  WarnNoImageReturn("\"%%%c\"",letter);
2609  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2610  image->scene);
2611 #endif
2612  break;
2613  }
2614  case 't': /* Base filename without directory or extention */
2615  {
2616  WarnNoImageReturn("\"%%%c\"",letter);
2617  GetPathComponent(image->magick_filename,BasePath,value);
2618  if (*value == '\0')
2619  string="";
2620  break;
2621  }
2622  case 'u': /* Unique filename */
2623  {
2624  WarnNoImageInfoReturn("\"%%%c\"",letter);
2625  string=image_info->unique;
2626  break;
2627  }
2628  case 'w': /* Image width (current) */
2629  {
2630  WarnNoImageReturn("\"%%%c\"",letter);
2631  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2632  (image->columns != 0 ? image->columns : image->magick_columns));
2633  break;
2634  }
2635  case 'x': /* Image horizontal resolution (with units) */
2636  {
2637  WarnNoImageReturn("\"%%%c\"",letter);
2638  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",
2639  fabs(image->resolution.x) > MagickEpsilon ? image->resolution.x : 72.0);
2640  break;
2641  }
2642  case 'y': /* Image vertical resolution (with units) */
2643  {
2644  WarnNoImageReturn("\"%%%c\"",letter);
2645  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",
2646  fabs(image->resolution.y) > MagickEpsilon ? image->resolution.y : 72.0);
2647  break;
2648  }
2649  case 'z': /* Image depth as read in */
2650  {
2651  WarnNoImageReturn("\"%%%c\"",letter);
2652  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2653  image->depth);
2654  break;
2655  }
2656  case 'A': /* Image alpha channel */
2657  {
2658  WarnNoImageReturn("\"%%%c\"",letter);
2659  string=CommandOptionToMnemonic(MagickPixelTraitOptions,(ssize_t)
2660  image->alpha_trait);
2661  break;
2662  }
2663  case 'B': /* image size read in - in bytes */
2664  {
2665  WarnNoImageReturn("\"%%%c\"",letter);
2666  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2667  image->extent);
2668  if (image->extent == 0)
2669  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2670  GetBlobSize(image));
2671  break;
2672  }
2673  case 'C': /* Image compression method. */
2674  {
2675  WarnNoImageReturn("\"%%%c\"",letter);
2676  string=CommandOptionToMnemonic(MagickCompressOptions,(ssize_t)
2677  image->compression);
2678  break;
2679  }
2680  case 'D': /* Image dispose method. */
2681  {
2682  WarnNoImageReturn("\"%%%c\"",letter);
2683  string=CommandOptionToMnemonic(MagickDisposeOptions,(ssize_t)
2684  image->dispose);
2685  break;
2686  }
2687  case 'G': /* Image size as geometry = "%wx%h" */
2688  {
2689  WarnNoImageReturn("\"%%%c\"",letter);
2690  (void) FormatLocaleString(value,MagickPathExtent,"%.20gx%.20g",(double)
2691  image->magick_columns,(double) image->magick_rows);
2692  break;
2693  }
2694  case 'H': /* layer canvas height */
2695  {
2696  WarnNoImageReturn("\"%%%c\"",letter);
2697  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2698  image->page.height);
2699  break;
2700  }
2701  case 'M': /* Magick filename - filename given incl. coder & read mods */
2702  {
2703  WarnNoImageReturn("\"%%%c\"",letter);
2704  string=image->magick_filename;
2705  break;
2706  }
2707  case 'N': /* Number of images in the list. */
2708  {
2709  if ((image != (Image *) NULL) && (image->next == (Image *) NULL))
2710  (void) FormatLocaleString(value,MagickPathExtent,"%.20g\n",(double)
2711  GetImageListLength(image));
2712  else
2713  string="";
2714  break;
2715  }
2716  case 'O': /* layer canvas offset with sign = "+%X+%Y" */
2717  {
2718  WarnNoImageReturn("\"%%%c\"",letter);
2719  (void) FormatLocaleString(value,MagickPathExtent,"%+ld%+ld",(long)
2720  image->page.x,(long) image->page.y);
2721  break;
2722  }
2723  case 'P': /* layer canvas page size = "%Wx%H" */
2724  {
2725  WarnNoImageReturn("\"%%%c\"",letter);
2726  (void) FormatLocaleString(value,MagickPathExtent,"%.20gx%.20g",(double)
2727  image->page.width,(double) image->page.height);
2728  break;
2729  }
2730  case 'Q': /* image compression quality */
2731  {
2732  WarnNoImageReturn("\"%%%c\"",letter);
2733  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2734  (image->quality == 0 ? 92 : image->quality));
2735  break;
2736  }
2737  case 'S': /* Number of scenes in image list. */
2738  {
2739  WarnNoImageInfoReturn("\"%%%c\"",letter);
2740 #if 0 /* What is this number? -- it makes no sense - simplifing */
2741  if (image_info->number_scenes == 0)
2742  string="2147483647";
2743  else if ( image != (Image *) NULL )
2744  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2745  image_info->scene+image_info->number_scenes);
2746  else
2747  string="0";
2748 #else
2749  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2750  (image_info->number_scenes == 0 ? 2147483647 :
2751  image_info->number_scenes));
2752 #endif
2753  break;
2754  }
2755  case 'T': /* image time delay for animations */
2756  {
2757  WarnNoImageReturn("\"%%%c\"",letter);
2758  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2759  image->delay);
2760  break;
2761  }
2762  case 'U': /* Image resolution units. */
2763  {
2764  WarnNoImageReturn("\"%%%c\"",letter);
2765  string=CommandOptionToMnemonic(MagickResolutionOptions,(ssize_t)
2766  image->units);
2767  break;
2768  }
2769  case 'W': /* layer canvas width */
2770  {
2771  WarnNoImageReturn("\"%%%c\"",letter);
2772  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2773  image->page.width);
2774  break;
2775  }
2776  case 'X': /* layer canvas X offset */
2777  {
2778  WarnNoImageReturn("\"%%%c\"",letter);
2779  (void) FormatLocaleString(value,MagickPathExtent,"%+.20g",(double)
2780  image->page.x);
2781  break;
2782  }
2783  case 'Y': /* layer canvas Y offset */
2784  {
2785  WarnNoImageReturn("\"%%%c\"",letter);
2786  (void) FormatLocaleString(value,MagickPathExtent,"%+.20g",(double)
2787  image->page.y);
2788  break;
2789  }
2790  case '%': /* percent escaped */
2791  {
2792  string="%";
2793  break;
2794  }
2795  case '@': /* Trim bounding box, without actually Trimming! */
2796  {
2797  RectangleInfo
2798  page;
2799 
2800  WarnNoImageReturn("\"%%%c\"",letter);
2801  page=GetImageBoundingBox(image,exception);
2802  (void) FormatLocaleString(value,MagickPathExtent,
2803  "%.20gx%.20g%+.20g%+.20g",(double) page.width,(double) page.height,
2804  (double) page.x,(double)page.y);
2805  break;
2806  }
2807  case '#':
2808  {
2809  /*
2810  Image signature.
2811  */
2812  WarnNoImageReturn("\"%%%c\"",letter);
2813  if ((image->columns != 0) && (image->rows != 0))
2814  (void) SignatureImage(image,exception);
2815  string=GetImageProperty(image,"signature",exception);
2816  break;
2817  }
2818  }
2819  if (string != (char *) NULL)
2820  return(string);
2821  if (*value != '\0')
2822  {
2823  /*
2824  Create a cloned copy of result.
2825  */
2826  if (image != (Image *) NULL)
2827  {
2828  (void) SetImageArtifact(image,"magick-property",value);
2829  return(GetImageArtifact(image,"magick-property"));
2830  }
2831  else
2832  {
2833  (void) SetImageOption(image_info,"magick-property",value);
2834  return(GetImageOption(image_info,"magick-property"));
2835  }
2836  }
2837  return((char *) NULL);
2838 }
2839 
2840 MagickExport const char *GetMagickProperty(ImageInfo *image_info,
2841  Image *image,const char *property,ExceptionInfo *exception)
2842 {
2843  char
2844  value[MagickPathExtent];
2845 
2846  const char
2847  *string;
2848 
2849  assert(property[0] != '\0');
2850  assert(image != (Image *) NULL || image_info != (ImageInfo *) NULL );
2851  if (property[1] == '\0') /* single letter property request */
2852  return(GetMagickPropertyLetter(image_info,image,*property,exception));
2853  if ((image != (Image *) NULL) && (image->debug != MagickFalse))
2854  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2855  else
2856  if ((image_info != (ImageInfo *) NULL) &&
2857  (image_info->debug != MagickFalse))
2858  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s","no-images");
2859  *value='\0'; /* formated string */
2860  string=(char *) NULL; /* constant string reference */
2861  switch (*property)
2862  {
2863  case 'b':
2864  {
2865  if (LocaleCompare("basename",property) == 0)
2866  {
2867  WarnNoImageReturn("\"%%[%s]\"",property);
2868  GetPathComponent(image->magick_filename,BasePath,value);
2869  if (*value == '\0')
2870  string="";
2871  break;
2872  }
2873  if (LocaleCompare("bit-depth",property) == 0)
2874  {
2875  WarnNoImageReturn("\"%%[%s]\"",property);
2876  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2877  GetImageDepth(image,exception));
2878  break;
2879  }
2880  if (LocaleCompare("bounding-box",property) == 0)
2881  {
2882  RectangleInfo
2883  geometry;
2884 
2885  WarnNoImageReturn("\"%%[%s]\"",property);
2886  geometry=GetImageBoundingBox(image,exception);
2887  (void) FormatLocaleString(value,MagickPathExtent,"%g,%g %g,%g",
2888  (double) geometry.x,(double) geometry.y,
2889  (double) geometry.x+geometry.width,
2890  (double) geometry.y+geometry.height);
2891  break;
2892  }
2893  break;
2894  }
2895  case 'c':
2896  {
2897  if (LocaleCompare("channels",property) == 0)
2898  {
2899  WarnNoImageReturn("\"%%[%s]\"",property);
2900  /* FUTURE: return actual image channels */
2901  (void) FormatLocaleString(value,MagickPathExtent,"%s",
2902  CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
2903  image->colorspace));
2904  LocaleLower(value);
2905  if( image->alpha_trait != UndefinedPixelTrait )
2906  (void) ConcatenateMagickString(value,"a",MagickPathExtent);
2907  break;
2908  }
2909  if (LocaleCompare("colors",property) == 0)
2910  {
2911  WarnNoImageReturn("\"%%[%s]\"",property);
2912  image->colors=GetNumberColors(image,(FILE *) NULL,exception);
2913  (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2914  image->colors);
2915  break;
2916  }
2917  if (LocaleCompare("colorspace",property) == 0)
2918  {
2919  WarnNoImageReturn("\"%%[%s]\"",property);
2920  string=CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
2921  image->colorspace);
2922  break;
2923  }
2924  if (LocaleCompare("compose",property) == 0)
2925  {
2926  WarnNoImageReturn("\"%%[%s]\"",property);
2927  string=CommandOptionToMnemonic(MagickComposeOptions,(ssize_t)
2928  image->compose);
2929  break;
2930  }
2931  if (LocaleCompare("compression",property) == 0)
2932  {
2933  WarnNoImageReturn("\"%%[%s]\"",property);
2934  string=CommandOptionToMnemonic(MagickCompressOptions,(ssize_t)
2935  image->compression);
2936  break;
2937  }
2938  if (LocaleCompare("convex-hull",property) == 0)
2939  {
2940  char
2941  *points;
2942 
2943  PointInfo
2944  *convex_hull;
2945 
2946  register ssize_t
2947  n;
2948 
2949  size_t
2950  number_points;
2951 
2952  WarnNoImageReturn("\"%%[%s]\"",property);
2953  convex_hull=GetImageConvexHull(image,&number_points,exception);
2954  if (convex_hull == (PointInfo *) NULL)
2955  break;
2956  points=AcquireString("");
2957  for (n=0; n < (ssize_t) number_points; n++)
2958  {
2959  (void) FormatLocaleString(value,MagickPathExtent,"%g,%g ",
2960  convex_hull[n].x,convex_hull[n].y);
2961  (void) ConcatenateString(&points,value);
2962  }
2963  convex_hull=(PointInfo *) RelinquishMagickMemory(convex_hull);
2964  (void) SetImageProperty(image,"convex-hull",points,exception);
2965  points=DestroyString(points);
2966  string=GetImageProperty(image,"convex-hull",exception);
2967  break;
2968  }
2969  if (LocaleCompare("copyright",property) == 0)
2970  {
2971  (void) CopyMagickString(value,GetMagickCopyright(),MagickPathExtent);
2972  break;
2973  }
2974  break;
2975  }
2976  case 'd':
2977  {
2978  if (LocaleCompare("depth",property) == 0)
2979  {
2980  WarnNoImageReturn("\"%%[%s]\"",property);
2981  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
2982  image->depth);
2983  break;
2984  }
2985  if (LocaleCompare("directory",property) == 0)
2986  {
2987  WarnNoImageReturn("\"%%[%s]\"",property);
2988  GetPathComponent(image->magick_filename,HeadPath,value);
2989  if (*value == '\0')
2990  string="";
2991  break;
2992  }
2993  break;
2994  }
2995  case 'e':
2996  {
2997  if (LocaleCompare("entropy",property) == 0)
2998  {
2999  double
3000  entropy;
3001 
3002  WarnNoImageReturn("\"%%[%s]\"",property);
3003  (void) GetImageEntropy(image,&entropy,exception);
3004  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3005  GetMagickPrecision(),entropy);
3006  break;
3007  }
3008  if (LocaleCompare("extension",property) == 0)
3009  {
3010  WarnNoImageReturn("\"%%[%s]\"",property);
3011  GetPathComponent(image->magick_filename,ExtensionPath,value);
3012  if (*value == '\0')
3013  string="";
3014  break;
3015  }
3016  break;
3017  }
3018  case 'g':
3019  {
3020  if (LocaleCompare("gamma",property) == 0)
3021  {
3022  WarnNoImageReturn("\"%%[%s]\"",property);
3023  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3024  GetMagickPrecision(),image->gamma);
3025  break;
3026  }
3027  break;
3028  }
3029  case 'h':
3030  {
3031  if (LocaleCompare("height",property) == 0)
3032  {
3033  WarnNoImageReturn("\"%%[%s]\"",property);
3034  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",
3035  image->magick_rows != 0 ? (double) image->magick_rows : 256.0);
3036  break;
3037  }
3038  break;
3039  }
3040  case 'i':
3041  {
3042  if (LocaleCompare("input",property) == 0)
3043  {
3044  WarnNoImageReturn("\"%%[%s]\"",property);
3045  string=image->filename;
3046  break;
3047  }
3048  if (LocaleCompare("interlace",property) == 0)
3049  {
3050  WarnNoImageReturn("\"%%[%s]\"",property);
3051  string=CommandOptionToMnemonic(MagickInterlaceOptions,(ssize_t)
3052  image->interlace);
3053  break;
3054  }
3055  break;
3056  }
3057  case 'k':
3058  {
3059  if (LocaleCompare("kurtosis",property) == 0)
3060  {
3061  double
3062  kurtosis,
3063  skewness;
3064 
3065  WarnNoImageReturn("\"%%[%s]\"",property);
3066  (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
3067  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3068  GetMagickPrecision(),kurtosis);
3069  break;
3070  }
3071  break;
3072  }
3073  case 'm':
3074  {
3075  if (LocaleCompare("magick",property) == 0)
3076  {
3077  WarnNoImageReturn("\"%%[%s]\"",property);
3078  string=image->magick;
3079  break;
3080  }
3081  if ((LocaleCompare("maxima",property) == 0) ||
3082  (LocaleCompare("max",property) == 0))
3083  {
3084  double
3085  maximum,
3086  minimum;
3087 
3088  WarnNoImageReturn("\"%%[%s]\"",property);
3089  (void) GetImageRange(image,&minimum,&maximum,exception);
3090  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3091  GetMagickPrecision(),maximum);
3092  break;
3093  }
3094  if (LocaleCompare("mean",property) == 0)
3095  {
3096  double
3097  mean,
3098  standard_deviation;
3099 
3100  WarnNoImageReturn("\"%%[%s]\"",property);
3101  (void) GetImageMean(image,&mean,&standard_deviation,exception);
3102  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3103  GetMagickPrecision(),mean);
3104  break;
3105  }
3106  if ((LocaleCompare("minima",property) == 0) ||
3107  (LocaleCompare("min",property) == 0))
3108  {
3109  double
3110  maximum,
3111  minimum;
3112 
3113  WarnNoImageReturn("\"%%[%s]\"",property);
3114  (void) GetImageRange(image,&minimum,&maximum,exception);
3115  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3116  GetMagickPrecision(),minimum);
3117  break;
3118  }
3119  if (LocaleNCompare("minimum-bounding-box",property,20) == 0)
3120  {
3121  char
3122  *points;
3123 
3124  PointInfo
3125  *bounding_box;
3126 
3127  register ssize_t
3128  n;
3129 
3130  size_t
3131  number_points;
3132 
3133  WarnNoImageReturn("\"%%[%s]\"",property);
3134  bounding_box=GetImageMinimumBoundingBox(image,&number_points,
3135  exception);
3136  if (bounding_box == (PointInfo *) NULL)
3137  break;
3138  points=AcquireString("");
3139  for (n=0; n < (ssize_t) number_points; n++)
3140  {
3141  (void) FormatLocaleString(value,MagickPathExtent,"%g,%g ",
3142  bounding_box[n].x,bounding_box[n].y);
3143  (void) ConcatenateString(&points,value);
3144  }
3145  bounding_box=(PointInfo *) RelinquishMagickMemory(bounding_box);
3146  (void) SetImageProperty(image,"minimum-bounding-box",points,
3147  exception);
3148  points=DestroyString(points);
3149  string=GetImageProperty(image,property,exception);
3150  break;
3151  }
3152  break;
3153  }
3154  case 'o':
3155  {
3156  if (LocaleCompare("opaque",property) == 0)
3157  {
3158  WarnNoImageReturn("\"%%[%s]\"",property);
3159  string=CommandOptionToMnemonic(MagickBooleanOptions,(ssize_t)
3160  IsImageOpaque(image,exception));
3161  break;
3162  }
3163  if (LocaleCompare("orientation",property) == 0)
3164  {
3165  WarnNoImageReturn("\"%%[%s]\"",property);
3166  string=CommandOptionToMnemonic(MagickOrientationOptions,(ssize_t)
3167  image->orientation);
3168  break;
3169  }
3170  if (LocaleCompare("output",property) == 0)
3171  {
3172  WarnNoImageInfoReturn("\"%%[%s]\"",property);
3173  (void) CopyMagickString(value,image_info->filename,MagickPathExtent);
3174  break;
3175  }
3176  break;
3177  }
3178  case 'p':
3179  {
3180  if (LocaleCompare("page",property) == 0)
3181  {
3182  WarnNoImageReturn("\"%%[%s]\"",property);
3183  (void) FormatLocaleString(value,MagickPathExtent,"%.20gx%.20g",
3184  (double) image->page.width,(double) image->page.height);
3185  break;
3186  }
3187 #if defined(MAGICKCORE_LCMS_DELEGATE)
3188  if (LocaleCompare("profile:icc",property) == 0 ||
3189  LocaleCompare("profile:icm",property) == 0)
3190  {
3191 #if !defined(LCMS_VERSION) || (LCMS_VERSION < 2000)
3192 #define cmsUInt32Number DWORD
3193 #endif
3194 
3195  const StringInfo
3196  *profile;
3197 
3198  cmsHPROFILE
3199  icc_profile;
3200 
3201  WarnNoImageReturn("\"%%[%s]\"",property);
3202  profile=GetImageProfile(image,property+8);
3203  if (profile == (StringInfo *) NULL)
3204  break;
3205  icc_profile=cmsOpenProfileFromMem(GetStringInfoDatum(profile),
3206  (cmsUInt32Number) GetStringInfoLength(profile));
3207  if (icc_profile != (cmsHPROFILE *) NULL)
3208  {
3209 #if defined(LCMS_VERSION) && (LCMS_VERSION < 2000)
3210  string=cmsTakeProductName(icc_profile);
3211 #else
3212  (void) cmsGetProfileInfoASCII(icc_profile,cmsInfoDescription,
3213  "en","US",value,MagickPathExtent);
3214 #endif
3215  (void) cmsCloseProfile(icc_profile);
3216  }
3217  }
3218 #endif
3219  if (LocaleCompare("printsize.x",property) == 0)
3220  {
3221  WarnNoImageReturn("\"%%[%s]\"",property);
3222  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3223  GetMagickPrecision(),PerceptibleReciprocal(image->resolution.x)*
3224  image->columns);
3225  break;
3226  }
3227  if (LocaleCompare("printsize.y",property) == 0)
3228  {
3229  WarnNoImageReturn("\"%%[%s]\"",property);
3230  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3231  GetMagickPrecision(),PerceptibleReciprocal(image->resolution.y)*
3232  image->rows);
3233  break;
3234  }
3235  if (LocaleCompare("profiles",property) == 0)
3236  {
3237  const char
3238  *name;
3239 
3240  WarnNoImageReturn("\"%%[%s]\"",property);
3241  ResetImageProfileIterator(image);
3242  name=GetNextImageProfile(image);
3243  if (name != (char *) NULL)
3244  {
3245  (void) CopyMagickString(value,name,MagickPathExtent);
3246  name=GetNextImageProfile(image);
3247  while (name != (char *) NULL)
3248  {
3249  ConcatenateMagickString(value,",",MagickPathExtent);
3250  ConcatenateMagickString(value,name,MagickPathExtent);
3251  name=GetNextImageProfile(image);
3252  }
3253  }
3254  break;
3255  }
3256  break;
3257  }
3258  case 'q':
3259  {
3260  if (LocaleCompare("quality",property) == 0)
3261  {
3262  WarnNoImageReturn("\"%%[%s]\"",property);
3263  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
3264  image->quality);
3265  break;
3266  }
3267  break;
3268  }
3269  case 'r':
3270  {
3271  if (LocaleCompare("resolution.x",property) == 0)
3272  {
3273  WarnNoImageReturn("\"%%[%s]\"",property);
3274  (void) FormatLocaleString(value,MagickPathExtent,"%g",
3275  image->resolution.x);
3276  break;
3277  }
3278  if (LocaleCompare("resolution.y",property) == 0)
3279  {
3280  WarnNoImageReturn("\"%%[%s]\"",property);
3281  (void) FormatLocaleString(value,MagickPathExtent,"%g",
3282  image->resolution.y);
3283  break;
3284  }
3285  break;
3286  }
3287  case 's':
3288  {
3289  if (LocaleCompare("scene",property) == 0)
3290  {
3291  WarnNoImageInfoReturn("\"%%[%s]\"",property);
3292  if (image_info->number_scenes != 0)
3293  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
3294  image_info->scene);
3295  else {
3296  WarnNoImageReturn("\"%%[%s]\"",property);
3297  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
3298  image->scene);
3299  }
3300  break;
3301  }
3302  if (LocaleCompare("scenes",property) == 0)
3303  {
3304  /* FUTURE: equivelent to %n? */
3305  WarnNoImageReturn("\"%%[%s]\"",property);
3306  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
3307  GetImageListLength(image));
3308  break;
3309  }
3310  if (LocaleCompare("size",property) == 0)
3311  {
3312  WarnNoImageReturn("\"%%[%s]\"",property);
3313  (void) FormatMagickSize(GetBlobSize(image),MagickFalse,"B",
3314  MagickPathExtent,value);
3315  break;
3316  }
3317  if (LocaleCompare("skewness",property) == 0)
3318  {
3319  double
3320  kurtosis,
3321  skewness;
3322 
3323  WarnNoImageReturn("\"%%[%s]\"",property);
3324  (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
3325  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3326  GetMagickPrecision(),skewness);
3327  break;
3328  }
3329  if (LocaleCompare("standard-deviation",property) == 0)
3330  {
3331  double
3332  mean,
3333  standard_deviation;
3334 
3335  WarnNoImageReturn("\"%%[%s]\"",property);
3336  (void) GetImageMean(image,&mean,&standard_deviation,exception);
3337  (void) FormatLocaleString(value,MagickPathExtent,"%.*g",
3338  GetMagickPrecision(),standard_deviation);
3339  break;
3340  }
3341  break;
3342  }
3343  case 't':
3344  {
3345  if (LocaleCompare("type",property) == 0)
3346  {
3347  WarnNoImageReturn("\"%%[%s]\"",property);
3348  string=CommandOptionToMnemonic(MagickTypeOptions,(ssize_t)
3349  IdentifyImageType(image,exception));
3350  break;
3351  }
3352  break;
3353  }
3354  case 'u':
3355  {
3356  if (LocaleCompare("unique",property) == 0)
3357  {
3358  WarnNoImageInfoReturn("\"%%[%s]\"",property);
3359  string=image_info->unique;
3360  break;
3361  }
3362  if (LocaleCompare("units",property) == 0)
3363  {
3364  WarnNoImageReturn("\"%%[%s]\"",property);
3365  string=CommandOptionToMnemonic(MagickResolutionOptions,(ssize_t)
3366  image->units);
3367  break;
3368  }
3369  break;
3370  }
3371  case 'v':
3372  {
3373  if (LocaleCompare("version",property) == 0)
3374  {
3375  string=GetMagickVersion((size_t *) NULL);
3376  break;
3377  }
3378  break;
3379  }
3380  case 'w':
3381  {
3382  if (LocaleCompare("width",property) == 0)
3383  {
3384  WarnNoImageReturn("\"%%[%s]\"",property);
3385  (void) FormatLocaleString(value,MagickPathExtent,"%.20g",(double)
3386  (image->magick_columns != 0 ? image->magick_columns : 256));
3387  break;
3388  }
3389  break;
3390  }
3391  }
3392  if (string != (char *) NULL)
3393  return(string);
3394  if (*value != '\0')
3395  {
3396  /*
3397  Create a cloned copy of result, that will get cleaned up, eventually.
3398  */
3399  if (image != (Image *) NULL)
3400  {
3401  (void) SetImageArtifact(image,"magick-property",value);
3402  return(GetImageArtifact(image,"magick-property"));
3403  }
3404  else
3405  {
3406  (void) SetImageOption(image_info,"magick-property",value);
3407  return(GetImageOption(image_info,"magick-property"));
3408  }
3409  }
3410  return((char *) NULL);
3411 }
3412 #undef WarnNoImageReturn
3413 
3414 /*
3415 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3416 % %
3417 % %
3418 % %
3419 % G e t N e x t I m a g e P r o p e r t y %
3420 % %
3421 % %
3422 % %
3423 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3424 %
3425 % GetNextImageProperty() gets the next free-form string property name.
3426 %
3427 % The format of the GetNextImageProperty method is:
3428 %
3429 % char *GetNextImageProperty(const Image *image)
3430 %
3431 % A description of each parameter follows:
3432 %
3433 % o image: the image.
3434 %
3435 */
3436 MagickExport const char *GetNextImageProperty(const Image *image)
3437 {
3438  assert(image != (Image *) NULL);
3439  assert(image->signature == MagickCoreSignature);
3440  if (image->debug != MagickFalse)
3441  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3442  image->filename);
3443  if (image->properties == (void *) NULL)
3444  return((const char *) NULL);
3445  return((const char *) GetNextKeyInSplayTree((SplayTreeInfo *) image->properties));
3446 }
3447 
3448 /*
3449 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3450 % %
3451 % %
3452 % %
3453 % I n t e r p r e t I m a g e P r o p e r t i e s %
3454 % %
3455 % %
3456 % %
3457 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3458 %
3459 % InterpretImageProperties() replaces any embedded formatting characters with
3460 % the appropriate image property and returns the interpreted text.
3461 %
3462 % This searches for and replaces
3463 % \n \r \% replaced by newline, return, and percent resp.
3464 % &lt; &gt; &amp; replaced by '<', '>', '&' resp.
3465 % %% replaced by percent
3466 %
3467 % %x %[x] where 'x' is a single letter properity, case sensitive).
3468 % %[type:name] where 'type' a is special and known prefix.
3469 % %[name] where 'name' is a specifically known attribute, calculated
3470 % value, or a per-image property string name, or a per-image
3471 % 'artifact' (as generated from a global option).
3472 % It may contain ':' as long as the prefix is not special.
3473 %
3474 % Single letter % substitutions will only happen if the character before the
3475 % percent is NOT a number. But braced substitutions will always be performed.
3476 % This prevents the typical usage of percent in a interpreted geometry
3477 % argument from being substituted when the percent is a geometry flag.
3478 %
3479 % If 'glob-expresions' ('*' or '?' characters) is used for 'name' it may be
3480 % used as a search pattern to print multiple lines of "name=value\n" pairs of
3481 % the associacted set of properties.
3482 %
3483 % The returned string must be freed using DestoryString() by the caller.
3484 %
3485 % The format of the InterpretImageProperties method is:
3486 %
3487 % char *InterpretImageProperties(ImageInfo *image_info,
3488 % Image *image,const char *embed_text,ExceptionInfo *exception)
3489 %
3490 % A description of each parameter follows:
3491 %
3492 % o image_info: the image info. (required)
3493 %
3494 % o image: the image. (optional)
3495 %
3496 % o embed_text: the address of a character string containing the embedded
3497 % formatting characters.
3498 %
3499 % o exception: return any errors or warnings in this structure.
3500 %
3501 */
3502 MagickExport char *InterpretImageProperties(ImageInfo *image_info,Image *image,
3503  const char *embed_text,ExceptionInfo *exception)
3504 {
3505 #define ExtendInterpretText(string_length) \
3506 DisableMSCWarning(4127) \
3507 { \
3508  size_t length=(string_length); \
3509  if ((size_t) (q-interpret_text+length+1) >= extent) \
3510  { \
3511  extent+=length; \
3512  interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+ \
3513  MaxTextExtent,sizeof(*interpret_text)); \
3514  if (interpret_text == (char *) NULL) \
3515  { \
3516  if (property_image != image) \
3517  property_image=DestroyImage(property_image); \
3518  if (property_info != image_info) \
3519  property_info=DestroyImageInfo(property_info); \
3520  return((char *) NULL); \
3521  } \
3522  q=interpret_text+strlen(interpret_text); \
3523  } \
3524 } \
3525 RestoreMSCWarning
3526 
3527 #define AppendKeyValue2Text(key,value)\
3528 DisableMSCWarning(4127) \
3529 { \
3530  size_t length=strlen(key)+strlen(value)+2; \
3531  if ((size_t) (q-interpret_text+length+1) >= extent) \
3532  { \
3533  extent+=length; \
3534  interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+ \
3535  MaxTextExtent,sizeof(*interpret_text)); \
3536  if (interpret_text == (char *) NULL) \
3537  { \
3538  if (property_image != image) \
3539  property_image=DestroyImage(property_image); \
3540  if (property_info != image_info) \
3541  property_info=DestroyImageInfo(property_info); \
3542  return((char *) NULL); \
3543  } \
3544  q=interpret_text+strlen(interpret_text); \
3545  } \
3546  q+=FormatLocaleString(q,extent,"%s=%s\n",(key),(value)); \
3547 } \
3548 RestoreMSCWarning
3549 
3550 #define AppendString2Text(string) \
3551 DisableMSCWarning(4127) \
3552 { \
3553  size_t length=strlen((string)); \
3554  if ((size_t) (q-interpret_text+length+1) >= extent) \
3555  { \
3556  extent+=length; \
3557  interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+ \
3558  MaxTextExtent,sizeof(*interpret_text)); \
3559  if (interpret_text == (char *) NULL) \
3560  { \
3561  if (property_image != image) \
3562  property_image=DestroyImage(property_image); \
3563  if (property_info != image_info) \
3564  property_info=DestroyImageInfo(property_info); \
3565  return((char *) NULL); \
3566  } \
3567  q=interpret_text+strlen(interpret_text); \
3568  } \
3569  (void) CopyMagickString(q,(string),extent); \
3570  q+=length; \
3571 } \
3572 RestoreMSCWarning
3573 
3574  char
3575  *interpret_text;
3576 
3577  Image
3578  *property_image;
3579 
3580  ImageInfo
3581  *property_info;
3582 
3583  MagickBooleanType
3584  number;
3585 
3586  register char
3587  *q; /* current position in interpret_text */
3588 
3589  register const char
3590  *p; /* position in embed_text string being expanded */
3591 
3592  size_t
3593  extent; /* allocated length of interpret_text */
3594 
3595  if ((image != (Image *) NULL) && (image->debug != MagickFalse))
3596  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3597  else
3598  if ((image_info != (ImageInfo *) NULL) && (image_info->debug != MagickFalse))
3599  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3600  image_info->filename);
3601  else
3602  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s","no image");
3603  if (embed_text == (const char *) NULL)
3604  return(ConstantString(""));
3605  p=embed_text;
3606  while ((isspace((int) ((unsigned char) *p)) != 0) && (*p != '\0'))
3607  p++;
3608  if (*p == '\0')
3609  return(ConstantString(""));
3610  if ((*p == '@') && (IsPathAccessible(p+1) != MagickFalse))
3611  {
3612  /*
3613  Handle a '@' replace string from file.
3614  */
3615  if (IsRightsAuthorized(PathPolicyDomain,ReadPolicyRights,p) == MagickFalse)
3616  {
3617  errno=EPERM;
3618  (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
3619  "NotAuthorized","`%s'",p);
3620  return(ConstantString(""));
3621  }
3622  interpret_text=FileToString(p+1,~0UL,exception);
3623  if (interpret_text != (char *) NULL)
3624  return(interpret_text);
3625  }
3626  /*
3627  Translate any embedded format characters.
3628  */
3629  if (image_info != (ImageInfo *) NULL)
3630  property_info=image_info;
3631  else
3632  property_info=CloneImageInfo(image_info);
3633  if ((image != (Image *) NULL) && (image->columns != 0) && (image->rows != 0))
3634  property_image=image;
3635  else
3636  {
3637  property_image=AcquireImage(image_info,exception);
3638  (void) SetImageExtent(property_image,1,1,exception);
3639  (void) SetImageBackgroundColor(property_image,exception);
3640  }
3641  interpret_text=AcquireString(embed_text); /* new string with extra space */
3642  extent=MagickPathExtent; /* allocated space in string */
3643  number=MagickFalse; /* is last char a number? */
3644  for (q=interpret_text; *p!='\0'; number=isdigit((int) ((unsigned char) *p)) ? MagickTrue : MagickFalse,p++)
3645  {
3646  /*
3647  Look for the various escapes, (and handle other specials)
3648  */
3649  *q='\0';
3650  ExtendInterpretText(MagickPathExtent);
3651  switch (*p)
3652  {
3653  case '\\':
3654  {
3655  switch (*(p+1))
3656  {
3657  case '\0':
3658  continue;
3659  case 'r': /* convert to RETURN */
3660  {
3661  *q++='\r';
3662  p++;
3663  continue;
3664  }
3665  case 'n': /* convert to NEWLINE */
3666  {
3667  *q++='\n';
3668  p++;
3669  continue;
3670  }
3671  case '\n': /* EOL removal UNIX,MacOSX */
3672  {
3673  p++;
3674  continue;
3675  }
3676  case '\r': /* EOL removal DOS,Windows */
3677  {
3678  p++;
3679  if (*p == '\n') /* return-newline EOL */
3680  p++;
3681  continue;
3682  }
3683  default:
3684  {
3685  p++;
3686  *q++=(*p);
3687  }
3688  }
3689  continue;
3690  }
3691  case '&':
3692  {
3693  if (LocaleNCompare("&lt;",p,4) == 0)
3694  {
3695  *q++='<';
3696  p+=3;
3697  }
3698  else
3699  if (LocaleNCompare("&gt;",p,4) == 0)
3700  {
3701  *q++='>';
3702  p+=3;
3703  }
3704  else
3705  if (LocaleNCompare("&amp;",p,5) == 0)
3706  {
3707  *q++='&';
3708  p+=4;
3709  }
3710  else
3711  *q++=(*p);
3712  continue;
3713  }
3714  case '%':
3715  break; /* continue to next set of handlers */
3716  default:
3717  {
3718  *q++=(*p); /* any thing else is 'as normal' */
3719  continue;
3720  }
3721  }
3722  p++; /* advance beyond the percent */
3723  /*
3724  Doubled Percent - or percent at end of string.
3725  */
3726  if ((*p == '\0') || (*p == '\'') || (*p == '"'))
3727  p--;
3728  if (*p == '%')
3729  {
3730  *q++='%';
3731  continue;
3732  }
3733  /*
3734  Single letter escapes %c.
3735  */
3736  if (*p != '[')
3737  {
3738  const char
3739  *string;
3740 
3741  if (number != MagickFalse)
3742  {
3743  /*
3744  But only if not preceeded by a number!
3745  */
3746  *q++='%'; /* do NOT substitute the percent */
3747  p--; /* back up one */
3748  continue;
3749  }
3750  string=GetMagickPropertyLetter(property_info,image,*p,exception);
3751  if (string != (char *) NULL)
3752  {
3753  AppendString2Text(string);
3754  (void) DeleteImageArtifact(property_image,"magick-property");
3755  (void) DeleteImageOption(property_info,"magick-property");
3756  continue;
3757  }
3758  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
3759  "UnknownImageProperty","\"%%%c\"",*p);
3760  continue;
3761  }
3762  {
3763  char
3764  pattern[2*MagickPathExtent];
3765 
3766  const char
3767  *key,
3768  *string;
3769 
3770  register ssize_t
3771  len;
3772 
3773  ssize_t
3774  depth;
3775 
3776  /*
3777  Braced Percent Escape %[...].
3778  */
3779  p++; /* advance p to just inside the opening brace */
3780  depth=1;
3781  if (*p == ']')
3782  {
3783  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
3784  "UnknownImageProperty","\"%%[]\"");
3785  break;
3786  }
3787  for (len=0; len < (MagickPathExtent-1L) && (*p != '\0'); )
3788  {
3789  if ((*p == '\\') && (*(p+1) != '\0'))
3790  {
3791  /*
3792  Skip escaped braces within braced pattern.
3793  */
3794  pattern[len++]=(*p++);
3795  pattern[len++]=(*p++);
3796  continue;
3797  }
3798  if (*p == '[')
3799  depth++;
3800  if (*p == ']')
3801  depth--;
3802  if (depth <= 0)
3803  break;
3804  pattern[len++]=(*p++);
3805  }
3806  pattern[len]='\0';
3807  if (depth != 0)
3808  {
3809  /*
3810  Check for unmatched final ']' for "%[...]".
3811  */
3812  if (len >= 64)
3813  {
3814  pattern[61] = '.'; /* truncate string for error message */
3815  pattern[62] = '.';
3816  pattern[63] = '.';
3817  pattern[64] = '\0';
3818  }
3819  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
3820  "UnbalancedBraces","\"%%[%s\"",pattern);
3821  interpret_text=DestroyString(interpret_text);
3822  if (property_image != image)
3823  property_image=DestroyImage(property_image);
3824  if (property_info != image_info)
3825  property_info=DestroyImageInfo(property_info);
3826  return((char *) NULL);
3827  }
3828  /*
3829  Special Lookup Prefixes %[prefix:...].
3830  */
3831  if (LocaleNCompare("fx:",pattern,3) == 0)
3832  {
3833  double
3834  value;
3835 
3836  FxInfo
3837  *fx_info;
3838 
3839  MagickBooleanType
3840  status;
3841 
3842  /*
3843  FX - value calculator.
3844  */
3845  fx_info=AcquireFxInfo(property_image,pattern+3,exception);
3846  status=FxEvaluateChannelExpression(fx_info,CompositePixelChannel,0,0,
3847  &value,exception);
3848  fx_info=DestroyFxInfo(fx_info);
3849  if (status != MagickFalse)
3850  {
3851  char
3852  result[MagickPathExtent];
3853 
3854  (void) FormatLocaleString(result,MagickPathExtent,"%.*g",
3855  GetMagickPrecision(),(double) value);
3856  AppendString2Text(result);
3857  }
3858  continue;
3859  }
3860  if (LocaleNCompare("hex:",pattern,4) == 0)
3861  {
3862  double
3863  value;
3864 
3865  FxInfo
3866  *fx_info;
3867 
3868  MagickStatusType
3869  status;
3870 
3871  PixelInfo
3872  pixel;
3873 
3874  /*
3875  Pixel - color value calculator.
3876  */
3877  GetPixelInfo(property_image,&pixel);
3878  fx_info=AcquireFxInfo(property_image,pattern+4,exception);
3879  status=FxEvaluateChannelExpression(fx_info,RedPixelChannel,0,0,
3880  &value,exception);
3881  pixel.red=(double) QuantumRange*value;
3882  status&=FxEvaluateChannelExpression(fx_info,GreenPixelChannel,0,0,
3883  &value,exception);
3884  pixel.green=(double) QuantumRange*value;
3885  status&=FxEvaluateChannelExpression(fx_info,BluePixelChannel,0,0,
3886  &value,exception);
3887  pixel.blue=(double) QuantumRange*value;
3888  if (property_image->colorspace == CMYKColorspace)
3889  {
3890  status&=FxEvaluateChannelExpression(fx_info,BlackPixelChannel,0,0,
3891  &value,exception);
3892  pixel.black=(double) QuantumRange*value;
3893  }
3894  status&=FxEvaluateChannelExpression(fx_info,AlphaPixelChannel,0,0,
3895  &value,exception);
3896  pixel.alpha=(double) QuantumRange*value;
3897  fx_info=DestroyFxInfo(fx_info);
3898  if (status != MagickFalse)
3899  {
3900  char
3901  hex[MagickPathExtent];
3902 
3903  GetColorTuple(&pixel,MagickTrue,hex);
3904  AppendString2Text(hex+1);
3905  }
3906  continue;
3907  }
3908  if (LocaleNCompare("pixel:",pattern,6) == 0)
3909  {
3910  double
3911  value;
3912 
3913  FxInfo
3914  *fx_info;
3915 
3916  MagickStatusType
3917  status;
3918 
3919  PixelInfo
3920  pixel;
3921 
3922  /*
3923  Pixel - color value calculator.
3924  */
3925  GetPixelInfo(property_image,&pixel);
3926  fx_info=AcquireFxInfo(property_image,pattern+6,exception);
3927  status=FxEvaluateChannelExpression(fx_info,RedPixelChannel,0,0,
3928  &value,exception);
3929  pixel.red=(double) QuantumRange*value;
3930  status&=FxEvaluateChannelExpression(fx_info,GreenPixelChannel,0,0,
3931  &value,exception);
3932  pixel.green=(double) QuantumRange*value;
3933  status&=FxEvaluateChannelExpression(fx_info,BluePixelChannel,0,0,
3934  &value,exception);
3935  pixel.blue=(double) QuantumRange*value;
3936  if (property_image->colorspace == CMYKColorspace)
3937  {
3938  status&=FxEvaluateChannelExpression(fx_info,BlackPixelChannel,0,0,
3939  &value,exception);
3940  pixel.black=(double) QuantumRange*value;
3941  }
3942  status&=FxEvaluateChannelExpression(fx_info,AlphaPixelChannel,0,0,
3943  &value,exception);
3944  pixel.alpha=(double) QuantumRange*value;
3945  fx_info=DestroyFxInfo(fx_info);
3946  if (status != MagickFalse)
3947  {
3948  char
3949  name[MagickPathExtent];
3950 
3951  const char
3952  *value;
3953 
3954  GetColorTuple(&pixel,MagickFalse,name);
3955  value=GetImageArtifact(property_image,"pixel:compliance");
3956  if (value != (char *) NULL)
3957  {
3958  ComplianceType compliance=(ComplianceType) ParseCommandOption(
3959  MagickComplianceOptions,MagickFalse,value);
3960  (void) QueryColorname(property_image,&pixel,compliance,name,
3961  exception);
3962  }
3963  AppendString2Text(name);
3964  }
3965  continue;
3966  }
3967  if (LocaleNCompare("option:",pattern,7) == 0)
3968  {
3969  /*
3970  Option - direct global option lookup (with globbing).
3971  */
3972  if (IsGlob(pattern+7) != MagickFalse)
3973  {
3974  ResetImageOptionIterator(property_info);
3975  while ((key=GetNextImageOption(property_info)) != (const char *) NULL)
3976  if (GlobExpression(key,pattern+7,MagickTrue) != MagickFalse)
3977  {
3978  string=GetImageOption(property_info,key);
3979  if (string != (const char *) NULL)
3980  AppendKeyValue2Text(key,string);
3981  /* else - assertion failure? key found but no string value! */
3982  }
3983  continue;
3984  }
3985  string=GetImageOption(property_info,pattern+7);
3986  if (string == (char *) NULL)
3987  goto PropertyLookupFailure; /* no artifact of this specifc name */
3988  AppendString2Text(string);
3989  continue;
3990  }
3991  if (LocaleNCompare("artifact:",pattern,9) == 0)
3992  {
3993  /*
3994  Artifact - direct image artifact lookup (with glob).
3995  */
3996  if (IsGlob(pattern+9) != MagickFalse)
3997  {
3998  ResetImageArtifactIterator(property_image);
3999  while ((key=GetNextImageArtifact(property_image)) != (const char *) NULL)
4000  if (GlobExpression(key,pattern+9,MagickTrue) != MagickFalse)
4001  {
4002  string=GetImageArtifact(property_image,key);
4003  if (string != (const char *) NULL)
4004  AppendKeyValue2Text(key,string);
4005  /* else - assertion failure? key found but no string value! */
4006  }
4007  continue;
4008  }
4009  string=GetImageArtifact(property_image,pattern+9);
4010  if (string == (char *) NULL)
4011  goto PropertyLookupFailure; /* no artifact of this specifc name */
4012  AppendString2Text(string);
4013  continue;
4014  }
4015  if (LocaleNCompare("property:",pattern,9) == 0)
4016  {
4017  /*
4018  Property - direct image property lookup (with glob).
4019  */
4020  if (IsGlob(pattern+9) != MagickFalse)
4021  {
4022  ResetImagePropertyIterator(property_image);
4023  while ((key=GetNextImageProperty(property_image)) != (const char *) NULL)
4024  if (GlobExpression(key,pattern,MagickTrue) != MagickFalse)
4025  {
4026  string=GetImageProperty(property_image,key,exception);
4027  if (string != (const char *) NULL)
4028  AppendKeyValue2Text(key,string);
4029  /* else - assertion failure? */
4030  }
4031  continue;
4032  }
4033  string=GetImageProperty(property_image,pattern+9,exception);
4034  if (string == (char *) NULL)
4035  goto PropertyLookupFailure; /* no artifact of this specifc name */
4036  AppendString2Text(string);
4037  continue;
4038  }
4039  /*
4040  Properties without special prefix. This handles attributes,
4041  properties, and profiles such as %[exif:...]. Note the profile
4042  properties may also include a glob expansion pattern.
4043  */
4044  string=GetImageProperty(property_image,pattern,exception);
4045  if (string != (const char *) NULL)
4046  {
4047  AppendString2Text(string);
4048  (void) DeleteImageArtifact(property_image,"magick-property");
4049  (void) DeleteImageOption(property_info,"magick-property");
4050  continue;
4051  }
4052  if (IsGlob(pattern) != MagickFalse)
4053  {
4054  /*
4055  Handle property 'glob' patterns such as:
4056  %[*] %[user:array_??] %[filename:e*]>
4057  */
4058  ResetImagePropertyIterator(property_image);
4059  while ((key=GetNextImageProperty(property_image)) != (const char *) NULL)
4060  if (GlobExpression(key,pattern,MagickTrue) != MagickFalse)
4061  {
4062  string=GetImageProperty(property_image,key,exception);
4063  if (string != (const char *) NULL)
4064  AppendKeyValue2Text(key,string);
4065  /* else - assertion failure? */
4066  }
4067  continue;
4068  }
4069  /*
4070  Look for a known property or image attribute such as
4071  %[basename] %[denisty] %[delay]. Also handles a braced single
4072  letter: %[b] %[G] %[g].
4073  */
4074  string=GetMagickProperty(property_info,property_image,pattern,exception);
4075  if (string != (const char *) NULL)
4076  {
4077  AppendString2Text(string);
4078  continue;
4079  }
4080  /*
4081  Look for a per-image artifact. This includes option lookup
4082  (FUTURE: interpreted according to image).
4083  */
4084  string=GetImageArtifact(property_image,pattern);
4085  if (string != (char *) NULL)
4086  {
4087  AppendString2Text(string);
4088  continue;
4089  }
4090  /*
4091  No image, so direct 'option' lookup (no delayed percent escapes).
4092  */
4093  string=GetImageOption(property_info,pattern);
4094  if (string != (char *) NULL)
4095  {
4096  AppendString2Text(string);
4097  continue;
4098  }
4099 PropertyLookupFailure:
4100  /*
4101  Failed to find any match anywhere!
4102  */
4103  if (len >= 64)
4104  {
4105  pattern[61] = '.'; /* truncate string for error message */
4106  pattern[62] = '.';
4107  pattern[63] = '.';
4108  pattern[64] = '\0';
4109  }
4110  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4111  "UnknownImageProperty","\"%%[%s]\"",pattern);
4112  }
4113  }
4114  *q='\0';
4115  if (property_image != image)
4116  property_image=DestroyImage(property_image);
4117  if (property_info != image_info)
4118  property_info=DestroyImageInfo(property_info);
4119  return(interpret_text);
4120 }
4121 
4122 /*
4123 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4124 % %
4125 % %
4126 % %
4127 % R e m o v e I m a g e P r o p e r t y %
4128 % %
4129 % %
4130 % %
4131 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4132 %
4133 % RemoveImageProperty() removes a property from the image and returns its
4134 % value.
4135 %
4136 % In this case the ConstantString() value returned should be freed by the
4137 % caller when finished.
4138 %
4139 % The format of the RemoveImageProperty method is:
4140 %
4141 % char *RemoveImageProperty(Image *image,const char *property)
4142 %
4143 % A description of each parameter follows:
4144 %
4145 % o image: the image.
4146 %
4147 % o property: the image property.
4148 %
4149 */
4150 MagickExport char *RemoveImageProperty(Image *image,const char *property)
4151 {
4152  char
4153  *value;
4154 
4155  assert(image != (Image *) NULL);
4156  assert(image->signature == MagickCoreSignature);
4157  if (image->debug != MagickFalse)
4158  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4159  if (image->properties == (void *) NULL)
4160  return((char *) NULL);
4161  value=(char *) RemoveNodeFromSplayTree((SplayTreeInfo *) image->properties,
4162  property);
4163  return(value);
4164 }
4165 
4166 /*
4167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4168 % %
4169 % %
4170 % %
4171 % R e s e t I m a g e P r o p e r t y I t e r a t o r %
4172 % %
4173 % %
4174 % %
4175 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4176 %
4177 % ResetImagePropertyIterator() resets the image properties iterator. Use it
4178 % in conjunction with GetNextImageProperty() to iterate over all the values
4179 % associated with an image property.
4180 %
4181 % The format of the ResetImagePropertyIterator method is:
4182 %
4183 % ResetImagePropertyIterator(Image *image)
4184 %
4185 % A description of each parameter follows:
4186 %
4187 % o image: the image.
4188 %
4189 */
4190 MagickExport void ResetImagePropertyIterator(const Image *image)
4191 {
4192  assert(image != (Image *) NULL);
4193  assert(image->signature == MagickCoreSignature);
4194  if (image->debug != MagickFalse)
4195  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4196  if (image->properties == (void *) NULL)
4197  return;
4198  ResetSplayTreeIterator((SplayTreeInfo *) image->properties);
4199 }
4200 
4201 /*
4202 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4203 % %
4204 % %
4205 % %
4206 % S e t I m a g e P r o p e r t y %
4207 % %
4208 % %
4209 % %
4210 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4211 %
4212 % SetImageProperty() saves the given string value either to specific known
4213 % attribute or to a freeform property string.
4214 %
4215 % Attempting to set a property that is normally calculated will produce
4216 % an exception.
4217 %
4218 % The format of the SetImageProperty method is:
4219 %
4220 % MagickBooleanType SetImageProperty(Image *image,const char *property,
4221 % const char *value,ExceptionInfo *exception)
4222 %
4223 % A description of each parameter follows:
4224 %
4225 % o image: the image.
4226 %
4227 % o property: the image property.
4228 %
4229 % o values: the image property values.
4230 %
4231 % o exception: return any errors or warnings in this structure.
4232 %
4233 */
4234 MagickExport MagickBooleanType SetImageProperty(Image *image,
4235  const char *property,const char *value,ExceptionInfo *exception)
4236 {
4237  MagickBooleanType
4238  status;
4239 
4240  MagickStatusType
4241  flags;
4242 
4243  assert(image != (Image *) NULL);
4244  assert(image->signature == MagickCoreSignature);
4245  if (image->debug != MagickFalse)
4246  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4247  if (image->properties == (void *) NULL)
4248  image->properties=NewSplayTree(CompareSplayTreeString,
4249  RelinquishMagickMemory,RelinquishMagickMemory); /* create splay-tree */
4250  if (value == (const char *) NULL)
4251  return(DeleteImageProperty(image,property)); /* delete if NULL */
4252  status=MagickTrue;
4253  if (strlen(property) <= 1)
4254  {
4255  /*
4256  Do not 'set' single letter properties - read only shorthand.
4257  */
4258  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4259  "SetReadOnlyProperty","`%s'",property);
4260  return(MagickFalse);
4261  }
4262 
4263  /* FUTURE: binary chars or quotes in key should produce a error */
4264  /* Set attributes with known names or special prefixes
4265  return result is found, or break to set a free form properity
4266  */
4267  switch (*property)
4268  {
4269 #if 0 /* Percent escape's sets values with this prefix: for later use
4270  Throwing an exception causes this setting to fail */
4271  case '8':
4272  {
4273  if (LocaleNCompare("8bim:",property,5) == 0)
4274  {
4275  (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
4276  "SetReadOnlyProperty","`%s'",property);
4277  return(MagickFalse);
4278  }
4279  break;
4280  }
4281 #endif
4282  case 'B':
4283  case 'b':
4284  {
4285  if (LocaleCompare("background",property) == 0)
4286  {
4287  (void) QueryColorCompliance(value,AllCompliance,
4288  &image->background_color,exception);
4289  /* check for FUTURE: value exception?? */
4290  /* also add user input to splay tree */
4291  }
4292  break; /* not an attribute, add as a property */
4293  }
4294  case 'C':
4295  case 'c':
4296  {
4297  if (LocaleCompare("channels",property) == 0)
4298  {
4299  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4300  "SetReadOnlyProperty","`%s'",property);
4301  return(MagickFalse);
4302  }
4303  if (LocaleCompare("colorspace",property) == 0)
4304  {
4305  ssize_t
4306  colorspace;
4307 
4308  colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
4309  value);
4310  if (colorspace < 0)
4311  return(MagickFalse); /* FUTURE: value exception?? */
4312  return(SetImageColorspace(image,(ColorspaceType) colorspace,exception));
4313  }
4314  if (LocaleCompare("compose",property) == 0)
4315  {
4316  ssize_t
4317  compose;
4318 
4319  compose=ParseCommandOption(MagickComposeOptions,MagickFalse,value);
4320  if (compose < 0)
4321  return(MagickFalse); /* FUTURE: value exception?? */
4322  image->compose=(CompositeOperator) compose;
4323  return(MagickTrue);
4324  }
4325  if (LocaleCompare("compress",property) == 0)
4326  {
4327  ssize_t
4328  compression;
4329 
4330  compression=ParseCommandOption(MagickCompressOptions,MagickFalse,
4331  value);
4332  if (compression < 0)
4333  return(MagickFalse); /* FUTURE: value exception?? */
4334  image->compression=(CompressionType) compression;
4335  return(MagickTrue);
4336  }
4337  break; /* not an attribute, add as a property */
4338  }
4339  case 'D':
4340  case 'd':
4341  {
4342  if (LocaleCompare("delay",property) == 0)
4343  {
4344  GeometryInfo
4345  geometry_info;
4346 
4347  flags=ParseGeometry(value,&geometry_info);
4348  if ((flags & GreaterValue) != 0)
4349  {
4350  if (image->delay > (size_t) floor(geometry_info.rho+0.5))
4351  image->delay=(size_t) floor(geometry_info.rho+0.5);
4352  }
4353  else
4354  if ((flags & LessValue) != 0)
4355  {
4356  if (image->delay < (size_t) floor(geometry_info.rho+0.5))
4357  image->delay=(ssize_t)
4358  floor(geometry_info.sigma+0.5);
4359  }
4360  else
4361  image->delay=(size_t) floor(geometry_info.rho+0.5);
4362  if ((flags & SigmaValue) != 0)
4363  image->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5);
4364  return(MagickTrue);
4365  }
4366  if (LocaleCompare("delay_units",property) == 0)
4367  {
4368  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4369  "SetReadOnlyProperty","`%s'",property);
4370  return(MagickFalse);
4371  }
4372  if (LocaleCompare("density",property) == 0)
4373  {
4374  GeometryInfo
4375  geometry_info;
4376 
4377  flags=ParseGeometry(value,&geometry_info);
4378  if ((flags & RhoValue) != 0)
4379  image->resolution.x=geometry_info.rho;
4380  image->resolution.y=image->resolution.x;
4381  if ((flags & SigmaValue) != 0)
4382  image->resolution.y=geometry_info.sigma;
4383  return(MagickTrue);
4384  }
4385  if (LocaleCompare("depth",property) == 0)
4386  {
4387  image->depth=StringToUnsignedLong(value);
4388  return(MagickTrue);
4389  }
4390  if (LocaleCompare("dispose",property) == 0)
4391  {
4392  ssize_t
4393  dispose;
4394 
4395  dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,value);
4396  if (dispose < 0)
4397  return(MagickFalse); /* FUTURE: value exception?? */
4398  image->dispose=(DisposeType) dispose;
4399  return(MagickTrue);
4400  }
4401  break; /* not an attribute, add as a property */
4402  }
4403 #if 0 /* Percent escape's sets values with this prefix: for later use
4404  Throwing an exception causes this setting to fail */
4405  case 'E':
4406  case 'e':
4407  {
4408  if (LocaleNCompare("exif:",property,5) == 0)
4409  {
4410  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4411  "SetReadOnlyProperty","`%s'",property);
4412  return(MagickFalse);
4413  }
4414  break; /* not an attribute, add as a property */
4415  }
4416  case 'F':
4417  case 'f':
4418  {
4419  if (LocaleNCompare("fx:",property,3) == 0)
4420  {
4421  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4422  "SetReadOnlyProperty","`%s'",property);
4423  return(MagickFalse);
4424  }
4425  break; /* not an attribute, add as a property */
4426  }
4427 #endif
4428  case 'G':
4429  case 'g':
4430  {
4431  if (LocaleCompare("gamma",property) == 0)
4432  {
4433  image->gamma=StringToDouble(value,(char **) NULL);
4434  return(MagickTrue);
4435  }
4436  if (LocaleCompare("gravity",property) == 0)
4437  {
4438  ssize_t
4439  gravity;
4440 
4441  gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,value);
4442  if (gravity < 0)
4443  return(MagickFalse); /* FUTURE: value exception?? */
4444  image->gravity=(GravityType) gravity;
4445  return(MagickTrue);
4446  }
4447  break; /* not an attribute, add as a property */
4448  }
4449  case 'H':
4450  case 'h':
4451  {
4452  if (LocaleCompare("height",property) == 0)
4453  {
4454  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4455  "SetReadOnlyProperty","`%s'",property);
4456  return(MagickFalse);
4457  }
4458  break; /* not an attribute, add as a property */
4459  }
4460  case 'I':
4461  case 'i':
4462  {
4463  if (LocaleCompare("intensity",property) == 0)
4464  {
4465  ssize_t
4466  intensity;
4467 
4468  intensity=ParseCommandOption(MagickIntentOptions,MagickFalse,value);
4469  if (intensity < 0)
4470  return(MagickFalse);
4471  image->intensity=(PixelIntensityMethod) intensity;
4472  return(MagickTrue);
4473  }
4474  if (LocaleCompare("intent",property) == 0)
4475  {
4476  ssize_t
4477  rendering_intent;
4478 
4479  rendering_intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
4480  value);
4481  if (rendering_intent < 0)
4482  return(MagickFalse); /* FUTURE: value exception?? */
4483  image->rendering_intent=(RenderingIntent) rendering_intent;
4484  return(MagickTrue);
4485  }
4486  if (LocaleCompare("interpolate",property) == 0)
4487  {
4488  ssize_t
4489  interpolate;
4490 
4491  interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
4492  value);
4493  if (interpolate < 0)
4494  return(MagickFalse); /* FUTURE: value exception?? */
4495  image->interpolate=(PixelInterpolateMethod) interpolate;
4496  return(MagickTrue);
4497  }
4498 #if 0 /* Percent escape's sets values with this prefix: for later use
4499  Throwing an exception causes this setting to fail */
4500  if (LocaleNCompare("iptc:",property,5) == 0)
4501  {
4502  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4503  "SetReadOnlyProperty","`%s'",property);
4504  return(MagickFalse);
4505  }
4506 #endif
4507  break; /* not an attribute, add as a property */
4508  }
4509  case 'K':
4510  case 'k':
4511  if (LocaleCompare("kurtosis",property) == 0)
4512  {
4513  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4514  "SetReadOnlyProperty","`%s'",property);
4515  return(MagickFalse);
4516  }
4517  break; /* not an attribute, add as a property */
4518  case 'L':
4519  case 'l':
4520  {
4521  if (LocaleCompare("loop",property) == 0)
4522  {
4523  image->iterations=StringToUnsignedLong(value);
4524  return(MagickTrue);
4525  }
4526  break; /* not an attribute, add as a property */
4527  }
4528  case 'M':
4529  case 'm':
4530  if ((LocaleCompare("magick",property) == 0) ||
4531  (LocaleCompare("max",property) == 0) ||
4532  (LocaleCompare("mean",property) == 0) ||
4533  (LocaleCompare("min",property) == 0) ||
4534  (LocaleCompare("min",property) == 0))
4535  {
4536  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4537  "SetReadOnlyProperty","`%s'",property);
4538  return(MagickFalse);
4539  }
4540  break; /* not an attribute, add as a property */
4541  case 'O':
4542  case 'o':
4543  if (LocaleCompare("opaque",property) == 0)
4544  {
4545  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4546  "SetReadOnlyProperty","`%s'",property);
4547  return(MagickFalse);
4548  }
4549  break; /* not an attribute, add as a property */
4550  case 'P':
4551  case 'p':
4552  {
4553  if (LocaleCompare("page",property) == 0)
4554  {
4555  char
4556  *geometry;
4557 
4558  geometry=GetPageGeometry(value);
4559  flags=ParseAbsoluteGeometry(geometry,&image->page);
4560  geometry=DestroyString(geometry);
4561  return(MagickTrue);
4562  }
4563 #if 0 /* Percent escape's sets values with this prefix: for later use
4564  Throwing an exception causes this setting to fail */
4565  if (LocaleNCompare("pixel:",property,6) == 0)
4566  {
4567  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4568  "SetReadOnlyProperty","`%s'",property);
4569  return(MagickFalse);
4570  }
4571 #endif
4572  if (LocaleCompare("profile",property) == 0)
4573  {
4574  ImageInfo
4575  *image_info;
4576 
4577  StringInfo
4578  *profile;
4579 
4580  image_info=AcquireImageInfo();
4581  (void) CopyMagickString(image_info->filename,value,MagickPathExtent);
4582  (void) SetImageInfo(image_info,1,exception);
4583  profile=FileToStringInfo(image_info->filename,~0UL,exception);
4584  if (profile != (StringInfo *) NULL)
4585  {
4586  status=SetImageProfile(image,image_info->magick,profile,
4587  exception);
4588  profile=DestroyStringInfo(profile);
4589  }
4590  image_info=DestroyImageInfo(image_info);
4591  return(MagickTrue);
4592  }
4593  break; /* not an attribute, add as a property */
4594  }
4595  case 'R':
4596  case 'r':
4597  {
4598  if (LocaleCompare("rendering-intent",property) == 0)
4599  {
4600  ssize_t
4601  rendering_intent;
4602 
4603  rendering_intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
4604  value);
4605  if (rendering_intent < 0)
4606  return(MagickFalse); /* FUTURE: value exception?? */
4607  image->rendering_intent=(RenderingIntent) rendering_intent;
4608  return(MagickTrue);
4609  }
4610  break; /* not an attribute, add as a property */
4611  }
4612  case 'S':
4613  case 's':
4614  if ((LocaleCompare("size",property) == 0) ||
4615  (LocaleCompare("skewness",property) == 0) ||
4616  (LocaleCompare("scenes",property) == 0) ||
4617  (LocaleCompare("standard-deviation",property) == 0))
4618  {
4619  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4620  "SetReadOnlyProperty","`%s'",property);
4621  return(MagickFalse);
4622  }
4623  break; /* not an attribute, add as a property */
4624  case 'T':
4625  case 't':
4626  {
4627  if (LocaleCompare("tile-offset",property) == 0)
4628  {
4629  char
4630  *geometry;
4631 
4632  geometry=GetPageGeometry(value);
4633  flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
4634  geometry=DestroyString(geometry);
4635  return(MagickTrue);
4636  }
4637  if (LocaleCompare("type",property) == 0)
4638  {
4639  ssize_t
4640  type;
4641 
4642  type=ParseCommandOption(MagickTypeOptions,MagickFalse,value);
4643  if (type < 0)
4644  return(MagickFalse);
4645  image->type=(ImageType) type;
4646  return(MagickTrue);
4647  }
4648  break; /* not an attribute, add as a property */
4649  }
4650  case 'U':
4651  case 'u':
4652  {
4653  if (LocaleCompare("units",property) == 0)
4654  {
4655  ssize_t
4656  units;
4657 
4658  units=ParseCommandOption(MagickResolutionOptions,MagickFalse,value);
4659  if (units < 0)
4660  return(MagickFalse); /* FUTURE: value exception?? */
4661  image->units=(ResolutionType) units;
4662  return(MagickTrue);
4663  }
4664  break; /* not an attribute, add as a property */
4665  }
4666  case 'V':
4667  case 'v':
4668  {
4669  if (LocaleCompare("version",property) == 0)
4670  {
4671  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4672  "SetReadOnlyProperty","`%s'",property);
4673  return(MagickFalse);
4674  }
4675  break; /* not an attribute, add as a property */
4676  }
4677  case 'W':
4678  case 'w':
4679  {
4680  if (LocaleCompare("width",property) == 0)
4681  {
4682  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4683  "SetReadOnlyProperty","`%s'",property);
4684  return(MagickFalse);
4685  }
4686  break; /* not an attribute, add as a property */
4687  }
4688 #if 0 /* Percent escape's sets values with this prefix: for later use
4689  Throwing an exception causes this setting to fail */
4690  case 'X':
4691  case 'x':
4692  {
4693  if (LocaleNCompare("xmp:",property,4) == 0)
4694  {
4695  (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
4696  "SetReadOnlyProperty","`%s'",property);
4697  return(MagickFalse);
4698  }
4699  break; /* not an attribute, add as a property */
4700  }
4701 #endif
4702  }
4703  /* Default: not an attribute, add as a property */
4704  status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
4705  ConstantString(property),ConstantString(value));
4706  /* FUTURE: error if status is bad? */
4707  return(status);
4708 }
_Image::rows
size_t rows
Definition: image.h:172
_Image::matte_color
PixelInfo matte_color
Definition: image.h:357
AppendString2Text
#define AppendString2Text(string)
_Image::intensity
PixelIntensityMethod intensity
Definition: image.h:222
FormatMagickSize
MagickExport ssize_t FormatMagickSize(const MagickSizeType size, const MagickBooleanType bi, const char *suffix, const size_t length, char *format)
Definition: string.c:1083
EXIF_FMT_SINGLE
#define EXIF_FMT_SINGLE
QueryColorname
MagickExport MagickBooleanType QueryColorname(const Image *magick_unused(image), const PixelInfo *color, const ComplianceType compliance, char *name, ExceptionInfo *exception)
Definition: color.c:2570
AcquireImageInfo
MagickExport ImageInfo * AcquireImageInfo(void)
Definition: image.c:323
_Image::interlace
InterlaceType interlace
Definition: image.h:225
_XMLTreeInfo
Definition: xml-tree.c:77
GetMagickPropertyLetter
static const char * GetMagickPropertyLetter(ImageInfo *image_info, Image *image, const char letter, ExceptionInfo *exception)
Definition: property.c:2428
DestroyXMLTree
MagickExport XMLTreeInfo * DestroyXMLTree(XMLTreeInfo *xml_info)
Definition: xml-tree.c:558
_Image::dispose
DisposeType dispose
Definition: image.h:237
AddValueToSplayTree
MagickExport MagickBooleanType AddValueToSplayTree(SplayTreeInfo *splay_tree, const void *key, const void *value)
Definition: splay-tree.c:154
_ImageInfo::magick
char magick[MagickPathExtent]
Definition: image.h:480
_Image::progress_monitor
MagickProgressMonitor progress_monitor
Definition: image.h:303
RemoveImageProperty
MagickExport char * RemoveImageProperty(Image *image, const char *property)
Definition: property.c:4150
IsRightsAuthorized
MagickExport MagickBooleanType IsRightsAuthorized(const PolicyDomain domain, const PolicyRights rights, const char *pattern)
Definition: policy.c:595
_Image::type
ImageType type
Definition: image.h:264
_Image::iterations
size_t iterations
Definition: image.h:248
_Image::ticks_per_second
ssize_t ticks_per_second
Definition: image.h:245
ConcatenateMagickString
MagickExport size_t ConcatenateMagickString(char *magick_restrict destination, const char *magick_restrict source, const size_t length)
Definition: string.c:428
ReadPropertyUnsignedShort
static unsigned short ReadPropertyUnsignedShort(const EndianType endian, const unsigned char *buffer)
Definition: property.c:813
_Image::filter
FilterType filter
Definition: image.h:219
ReadPropertyUnsignedLong
static unsigned int ReadPropertyUnsignedLong(const EndianType endian, const unsigned char *buffer)
Definition: property.c:764
DeleteImageOption
MagickExport MagickBooleanType DeleteImageOption(ImageInfo *image_info, const char *option)
Definition: option.c:2241
ResetImagePropertyIterator
MagickExport void ResetImagePropertyIterator(const Image *image)
Definition: property.c:4190
StringToUnsignedLong
static unsigned long StringToUnsignedLong(const char *magick_restrict value)
Definition: string-private.h:136
EXIF_FMT_SLONG
#define EXIF_FMT_SLONG
ParseCommandOption
MagickExport ssize_t ParseCommandOption(const CommandOption option, const MagickBooleanType list, const char *options)
Definition: option.c:2985
resource_.h
EXIF_FMT_SSHORT
#define EXIF_FMT_SSHORT
_Image::border_color
PixelInfo border_color
Definition: image.h:179
PixelInterpolateMethod
PixelInterpolateMethod
Definition: pixel.h:110
_Image::interpolate
PixelInterpolateMethod interpolate
Definition: image.h:255
FormatLocaleStringList
MagickPrivate ssize_t FormatLocaleStringList(char *magick_restrict, const size_t, const char *magick_restrict, va_list) magick_attribute((__format__(__printf__
GetNextXMLTreeTag
MagickExport XMLTreeInfo * GetNextXMLTreeTag(XMLTreeInfo *xml_info)
Definition: xml-tree.c:744
_ImageInfo::number_scenes
size_t number_scenes
Definition: image.h:396
_GeometryInfo::rho
double rho
Definition: geometry.h:106
ParseAbsoluteGeometry
MagickExport MagickStatusType ParseAbsoluteGeometry(const char *geometry, RectangleInfo *region_info)
Definition: geometry.c:703
_ExceptionInfo
Definition: exception.h:101
_Image::endian
EndianType endian
Definition: image.h:228
DeleteImageArtifact
MagickExport MagickBooleanType DeleteImageArtifact(Image *image, const char *artifact)
Definition: artifact.c:198
_Image::taint
MagickBooleanType taint
Definition: image.h:169
ReadPropertyMSBLong
static signed int ReadPropertyMSBLong(const unsigned char **p, size_t *length)
Definition: property.c:501
PixelIntensityMethod
PixelIntensityMethod
Definition: pixel.h:96
_ImageInfo::debug
MagickBooleanType debug
Definition: image.h:485
SkipXMPValue
static MagickBooleanType SkipXMPValue(const char *value)
Definition: property.c:1758
ExtendInterpretText
#define ExtendInterpretText(string_length)
SetImageArtifact
MagickExport MagickBooleanType SetImageArtifact(Image *image, const char *artifact, const char *value)
Definition: artifact.c:445
_ImageInfo
Definition: image.h:375
GetImageMinimumBoundingBox
MagickExport PointInfo * GetImageMinimumBoundingBox(Image *image, size_t *number_vertices, ExceptionInfo *exception)
Definition: attribute.c:1152
GetImageArtifact
MagickExport const char * GetImageArtifact(const Image *image, const char *artifact)
Definition: artifact.c:273
_PixelInfo::red
MagickRealType red
Definition: pixel.h:190
GetEXIFProperty
static MagickBooleanType GetEXIFProperty(const Image *image, const char *property, ExceptionInfo *exception)
Definition: property.c:830
StringToDouble
static double StringToDouble(const char *magick_restrict string, char **magick_restrict sentinal)
Definition: string-private.h:43
AcquireExceptionInfo
MagickExport ExceptionInfo * AcquireExceptionInfo(void)
Definition: exception.c:115
FormatLocaleString
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
Definition: locale.c:499
CopyMagickString
MagickExport size_t CopyMagickString(char *magick_restrict destination, const char *magick_restrict source, const size_t length)
Definition: string.c:756
_Image::units
ResolutionType units
Definition: image.h:198
GetICCProperty
static MagickBooleanType GetICCProperty(const Image *image, const char *property, ExceptionInfo *exception)
Definition: property.c:1676
SignatureImage
MagickExport MagickBooleanType SignatureImage(Image *image, ExceptionInfo *exception)
Definition: signature.c:470
_Image::delay
size_t delay
Definition: image.h:240
_Image::magick
char magick[MagickPathExtent]
Definition: image.h:319
MAGICKCORE_QUANTUM_DEPTH
#define MAGICKCORE_QUANTUM_DEPTH
Definition: magick-type.h:32
_Image::magick_rows
size_t magick_rows
Definition: image.h:324
ResetImageArtifactIterator
MagickExport void ResetImageArtifactIterator(const Image *image)
Definition: artifact.c:406
StringToLong
static long StringToLong(const char *magick_restrict value)
Definition: string-private.h:108
_PixelInfo::alpha
MagickRealType alpha
Definition: pixel.h:190
_ProfileInfo::info
unsigned char * info
Definition: profile.c:112
TraceSVGClippath
static char * TraceSVGClippath(const unsigned char *, size_t, const size_t, const size_t)
Definition: property.c:2090
GetImageOption
MagickExport const char * GetImageOption(const ImageInfo *image_info, const char *option)
Definition: option.c:2316
GetPageGeometry
MagickExport char * GetPageGeometry(const char *page_geometry)
Definition: geometry.c:362
_Image::montage
char * montage
Definition: image.h:201
MagickEpsilon
#define MagickEpsilon
Definition: magick-type.h:114
_Image::compression
CompressionType compression
Definition: image.h:160
GetXMLTreeChild
MagickExport XMLTreeInfo * GetXMLTreeChild(XMLTreeInfo *xml_info, const char *tag)
Definition: xml-tree.c:896
_GeometryInfo::sigma
double sigma
Definition: geometry.h:106
_Image::storage_class
ClassType storage_class
Definition: image.h:154
_RectangleInfo::width
size_t width
Definition: geometry.h:130
ReadPropertySignedLong
static signed int ReadPropertySignedLong(const EndianType endian, const unsigned char *buffer)
Definition: property.c:732
_Image::tile_offset
RectangleInfo tile_offset
Definition: image.h:261
GetImageEntropy
MagickExport MagickBooleanType GetImageEntropy(const Image *image, double *entropy, ExceptionInfo *exception)
Definition: statistic.c:1185
EXIF_FMT_BYTE
#define EXIF_FMT_BYTE
TraceEvent
Definition: log.h:52
FileToString
MagickExport char * FileToString(const char *filename, const size_t extent, ExceptionInfo *exception)
Definition: string.c:990
EXIF_FMT_URATIONAL
#define EXIF_FMT_URATIONAL
GetPixelInfo
MagickExport void GetPixelInfo(const Image *image, PixelInfo *pixel)
Definition: pixel.c:2170
GetXMLTreeTag
MagickExport const char * GetXMLTreeTag(XMLTreeInfo *xml_info)
Definition: xml-tree.c:1159
EndianType
EndianType
Definition: quantum.h:29
SetImageOption
MagickExport MagickBooleanType SetImageOption(ImageInfo *image_info, const char *option, const char *value)
Definition: option.c:3255
_Image
Definition: image.h:151
ReadPropertySignedShort
static signed short ReadPropertySignedShort(const EndianType endian, const unsigned char *buffer)
Definition: property.c:785
ReadPropertyByte
static int ReadPropertyByte(const unsigned char **p, size_t *length)
Definition: property.c:489
TracePSClippath
static char * TracePSClippath(const unsigned char *, size_t)
Definition: property.c:1864
_SplayTreeInfo
Definition: splay-tree.c:83
SetImageGray
MagickExport MagickBooleanType SetImageGray(Image *image, ExceptionInfo *exception)
Definition: colorspace.c:1392
_StringInfo
Definition: string_.h:27
EXIF_FMT_USHORT
#define EXIF_FMT_USHORT
_PointInfo::x
double x
Definition: geometry.h:123
string_.h
TAG_GPS_OFFSET
#define TAG_GPS_OFFSET
MagickCoreSignature
#define MagickCoreSignature
Definition: method-attribute.h:86
GetStringInfoDatum
MagickExport unsigned char * GetStringInfoDatum(const StringInfo *string_info)
Definition: string.c:1205
CloneImageProperties
MagickExport MagickBooleanType CloneImageProperties(Image *image, const Image *clone_image)
Definition: property.c:134
TAG_INTEROP_OFFSET
#define TAG_INTEROP_OFFSET
GetPathComponent
MagickExport void GetPathComponent(const char *path, PathType type, char *component)
Definition: utility.c:1223
MagickBooleanType
MagickBooleanType
Definition: magick-type.h:169
_Image::scene
size_t scene
Definition: image.h:240
MagickStatusType
unsigned int MagickStatusType
Definition: magick-type.h:125
AcquireString
MagickExport char * AcquireString(const char *source)
Definition: string.c:129
PerceptibleReciprocal
static double PerceptibleReciprocal(const double x)
Definition: pixel-accessor.h:234
LocaleLower
MagickExport void LocaleLower(char *string)
Definition: locale.c:1490
_Image::black_point_compensation
MagickBooleanType black_point_compensation
Definition: image.h:258
GlobExpression
MagickExport MagickBooleanType GlobExpression(const char *magick_restrict expression, const char *magick_restrict pattern, const MagickBooleanType case_insensitive)
Definition: token.c:355
DestroyFxInfo
MagickPrivate FxInfo * DestroyFxInfo(FxInfo *)
Definition: fx.c:296
CommandOptionToMnemonic
MagickExport const char * CommandOptionToMnemonic(const CommandOption option, const ssize_t type)
Definition: option.c:2694
FileToStringInfo
MagickExport StringInfo * FileToStringInfo(const char *filename, const size_t extent, ExceptionInfo *exception)
Definition: string.c:1029
DestroyStringInfo
MagickExport StringInfo * DestroyStringInfo(StringInfo *string_info)
Definition: string.c:840
GetIPTCProperty
static MagickBooleanType GetIPTCProperty(const Image *image, const char *key, ExceptionInfo *exception)
Definition: property.c:422
AcquireQuantumMemory
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:634
_ImageInfo::filename
char filename[MagickPathExtent]
Definition: image.h:480
GetColorTuple
MagickExport void GetColorTuple(const PixelInfo *pixel, const MagickBooleanType hex, char *tuple)
Definition: color.c:1518
LocaleNCompare
MagickExport int LocaleNCompare(const char *p, const char *q, const size_t length)
Definition: locale.c:1570
_PointInfo::y
double y
Definition: geometry.h:123
MaxTextExtent
#define MaxTextExtent
Definition: method-attribute.h:90
FxEvaluateChannelExpression
MagickPrivate MagickBooleanType FxEvaluateChannelExpression(FxInfo *, const PixelChannel, const ssize_t, const ssize_t, double *, ExceptionInfo *)
Definition: fx.c:2684
_Image::gravity
GravityType gravity
Definition: image.h:231
SetImageProperty
MagickExport MagickBooleanType SetImageProperty(Image *image, const char *property, const char *value, ExceptionInfo *exception)
Definition: property.c:4234
GetImageConvexHull
MagickExport PointInfo * GetImageConvexHull(const Image *image, size_t *number_vertices, ExceptionInfo *exception)
Definition: attribute.c:717
GetImageProfile
MagickExport const StringInfo * GetImageProfile(const Image *image, const char *name)
Definition: profile.c:259
_ImageInfo::scene
size_t scene
Definition: image.h:396
_Image::page
RectangleInfo page
Definition: image.h:212
GetXMLTreeContent
MagickExport const char * GetXMLTreeContent(XMLTreeInfo *xml_info)
Definition: xml-tree.c:936
IsGlob
MagickPrivate MagickBooleanType IsGlob(const char *) magick_attribute((__pure__))
Definition: token.c:600
DestroyImageProperties
MagickExport void DestroyImageProperties(Image *image)
Definition: property.c:314
_Image::magick_columns
size_t magick_columns
Definition: image.h:324
DestroySplayTree
MagickExport SplayTreeInfo * DestroySplayTree(SplayTreeInfo *splay_tree)
Definition: splay-tree.c:682
MagickPathExtent
#define MagickPathExtent
Definition: method-attribute.h:88
_Image::alpha_trait
PixelTrait alpha_trait
Definition: image.h:280
GetMagickPrecision
MagickExport int GetMagickPrecision(void)
Definition: magick.c:942
_PixelInfo::blue
MagickRealType blue
Definition: pixel.h:190
memory_.h
NewSplayTree
MagickExport SplayTreeInfo * NewSplayTree(int(*compare)(const void *, const void *), void *(*relinquish_key)(void *), void *(*relinquish_value)(void *))
Definition: splay-tree.c:1141
EXIF_FMT_DOUBLE
#define EXIF_FMT_DOUBLE
SetImageInfo
MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info, const unsigned int frames, ExceptionInfo *exception)
Definition: image.c:2693
GravityType
GravityType
Definition: geometry.h:77
_Image::magick_filename
char magick_filename[MagickPathExtent]
Definition: image.h:319
ThrowMagickException
MagickExport MagickBooleanType ThrowMagickException(ExceptionInfo *exception, const char *module, const char *function, const size_t line, const ExceptionType severity, const char *tag, const char *format,...)
Definition: exception.c:1145
LogMagickEvent
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
Definition: log.c:1660
_FxInfo
Definition: fx.c:128
IsPathAccessible
MagickExport MagickBooleanType IsPathAccessible(const char *path)
Definition: utility.c:1477
GetMagickVersion
MagickExport const char * GetMagickVersion(size_t *version)
Definition: version.c:598
SetImageBackgroundColor
MagickExport MagickBooleanType SetImageBackgroundColor(Image *image, ExceptionInfo *exception)
Definition: image.c:2395
_Image::signature
size_t signature
Definition: image.h:354
_Image::columns
size_t columns
Definition: image.h:172
GetNextImageProperty
MagickExport const char * GetNextImageProperty(const Image *image)
Definition: property.c:3436
ReadPropertyMSBShort
static signed short ReadPropertyMSBShort(const unsigned char **p, size_t *length)
Definition: property.c:541
AcquireImage
MagickExport Image * AcquireImage(const ImageInfo *image_info, ExceptionInfo *exception)
Definition: image.c:134
SubstituteString
MagickExport MagickBooleanType SubstituteString(char **string, const char *search, const char *replace)
Definition: string.c:2565
EXIFMultipleValues
#define EXIFMultipleValues(size, format, arg)
_RectangleInfo::x
ssize_t x
Definition: geometry.h:134
_Image::next
struct _Image * next
Definition: image.h:348
WarnNoImageInfoReturn
#define WarnNoImageInfoReturn(format, arg)
ResetImageOptionIterator
MagickExport void ResetImageOptionIterator(const ImageInfo *image_info)
Definition: option.c:3216
GetMagickCopyright
MagickExport const char * GetMagickCopyright(void)
Definition: version.c:75
_RectangleInfo::height
size_t height
Definition: geometry.h:130
IdentifyImageType
MagickExport ImageType IdentifyImageType(const Image *image, ExceptionInfo *exception)
Definition: attribute.c:1680
_RectangleInfo
Definition: geometry.h:127
GetImageRange
MagickExport MagickBooleanType GetImageRange(const Image *image, double *minima, double *maxima, ExceptionInfo *exception)
Definition: statistic.c:1826
QueryColorCompliance
MagickExport MagickBooleanType QueryColorCompliance(const char *name, const ComplianceType compliance, PixelInfo *color, ExceptionInfo *exception)
Definition: color.c:2180
GetImageKurtosis
MagickExport MagickBooleanType GetImageKurtosis(const Image *image, double *kurtosis, double *skewness, ExceptionInfo *exception)
Definition: statistic.c:1283
_Image::offset
ssize_t offset
Definition: image.h:206
_Image::extract_info
RectangleInfo extract_info
Definition: image.h:212
GetValueFromSplayTree
MagickExport const void * GetValueFromSplayTree(SplayTreeInfo *splay_tree, const void *key)
Definition: splay-tree.c:921
GetImageMean
MagickExport MagickBooleanType GetImageMean(const Image *image, double *mean, double *standard_deviation, ExceptionInfo *exception)
Definition: statistic.c:1333
EXIF_FMT_STRING
#define EXIF_FMT_STRING
SetImageExtent
MagickExport MagickBooleanType SetImageExtent(Image *image, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: image.c:2637
GetNextImageProfile
MagickExport char * GetNextImageProfile(const Image *image)
Definition: profile.c:298
RenderingIntent
RenderingIntent
Definition: profile.h:30
MagickMax
#define MagickMax(x, y)
Definition: image-private.h:36
SetImageProfile
MagickExport MagickBooleanType SetImageProfile(Image *image, const char *name, const StringInfo *profile, ExceptionInfo *exception)
Definition: profile.c:1912
EXIF_FMT_SRATIONAL
#define EXIF_FMT_SRATIONAL
_Image::quality
size_t quality
Definition: image.h:163
AppendKeyValue2Text
#define AppendKeyValue2Text(key, value)
_Image::colors
size_t colors
Definition: image.h:172
MaxDirectoryStack
#define MaxDirectoryStack
LocaleCompare
MagickExport int LocaleCompare(const char *p, const char *q)
Definition: locale.c:1435
DisposeType
DisposeType
Definition: layer.h:27
_Image::filename
char filename[MagickPathExtent]
Definition: image.h:319
CloneSplayTree
MagickExport SplayTreeInfo * CloneSplayTree(SplayTreeInfo *splay_tree, void *(*clone_key)(void *), void *(*clone_value)(void *))
Definition: splay-tree.c:346
GetMagickModule
#define GetMagickModule()
Definition: log.h:28
CompareSplayTreeString
MagickExport int CompareSplayTreeString(const void *target, const void *source)
Definition: splay-tree.c:412
GetNumberColors
MagickExport size_t GetNumberColors(const Image *image, FILE *file, ExceptionInfo *exception)
Definition: histogram.c:1002
InterpretImageProperties
MagickExport char * InterpretImageProperties(ImageInfo *image_info, Image *image, const char *embed_text, ExceptionInfo *exception)
Definition: property.c:3502
GetBlobSize
MagickExport MagickSizeType GetBlobSize(const Image *image)
Definition: blob.c:1844
_ImageInfo::unique
char unique[MagickPathExtent]
Definition: image.h:480
GetXMLTreeSibling
MagickExport XMLTreeInfo * GetXMLTreeSibling(XMLTreeInfo *xml_info)
Definition: xml-tree.c:1127
DestroyImageInfo
MagickExport ImageInfo * DestroyImageInfo(ImageInfo *image_info)
Definition: image.c:1231
CompressionType
CompressionType
Definition: compress.h:25
_Image::start_loop
ssize_t start_loop
Definition: image.h:252
_Image::rendering_intent
RenderingIntent rendering_intent
Definition: image.h:192
_Image::error
ErrorInfo error
Definition: image.h:297
GetNextKeyInSplayTree
MagickExport const void * GetNextKeyInSplayTree(SplayTreeInfo *splay_tree)
Definition: splay-tree.c:769
GetImageDepth
MagickExport size_t GetImageDepth(const Image *image, ExceptionInfo *exception)
Definition: attribute.c:839
EXIFMultipleFractions
#define EXIFMultipleFractions(size, format, arg1, arg2)
GetXMPProperty
static MagickBooleanType GetXMPProperty(const Image *image, const char *property)
Definition: property.c:1771
GetImageBoundingBox
MagickExport RectangleInfo GetImageBoundingBox(const Image *image, ExceptionInfo *exception)
Definition: attribute.c:389
SetImageColorspace
MagickExport MagickBooleanType SetImageColorspace(Image *image, const ColorspaceType colorspace, ExceptionInfo *exception)
Definition: colorspace.c:1312
GetImageIndexInList
MagickExport ssize_t GetImageIndexInList(const Image *images)
Definition: list.c:670
_PixelInfo::black
MagickRealType black
Definition: pixel.h:190
_GeometryInfo
Definition: geometry.h:103
DestroyString
MagickExport char * DestroyString(char *string)
Definition: string.c:813
_Image::geometry
char * geometry
Definition: image.h:201
DeleteImageProperty
MagickExport MagickBooleanType DeleteImageProperty(Image *image, const char *property)
Definition: property.c:279
GetImageProperty
MagickExport const char * GetImageProperty(const Image *image, const char *property, ExceptionInfo *exception)
Definition: property.c:2237
EXIF_FMT_UNDEFINED
#define EXIF_FMT_UNDEFINED
CloneImageInfo
MagickExport ImageInfo * CloneImageInfo(const ImageInfo *image_info)
Definition: image.c:919
GetRootValueFromSplayTree
MagickExport const void * GetRootValueFromSplayTree(SplayTreeInfo *splay_tree)
Definition: splay-tree.c:877
ParseGeometry
MagickExport MagickStatusType ParseGeometry(const char *geometry, GeometryInfo *geometry_info)
Definition: geometry.c:853
_Image::directory
char * directory
Definition: image.h:201
_Image::chromaticity
ChromaticityInfo chromaticity
Definition: image.h:189
RemoveNodeFromSplayTree
MagickExport void * RemoveNodeFromSplayTree(SplayTreeInfo *splay_tree, const void *key)
Definition: splay-tree.c:1299
DeleteNodeFromSplayTree
MagickExport MagickBooleanType DeleteNodeFromSplayTree(SplayTreeInfo *splay_tree, const void *key)
Definition: splay-tree.c:603
_ProfileInfo::length
size_t length
Definition: profile.c:109
Get8BIMProperty
static MagickBooleanType Get8BIMProperty(const Image *image, const char *key, ExceptionInfo *exception)
Definition: property.c:579
MagickMin
#define MagickMin(x, y)
Definition: image-private.h:37
GetNextImageArtifact
MagickExport const char * GetNextImageArtifact(const Image *image)
Definition: artifact.c:323
ColorspaceType
ColorspaceType
Definition: colorspace.h:25
EXIF_FMT_SBYTE
#define EXIF_FMT_SBYTE
ConcatenateString
MagickExport MagickBooleanType ConcatenateString(char **magick_restrict destination, const char *magick_restrict source)
Definition: string.c:494
ResetSplayTreeIterator
MagickExport void ResetSplayTreeIterator(SplayTreeInfo *splay_tree)
Definition: splay-tree.c:1472
RelinquishMagickMemory
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1123
_Image::total_colors
size_t total_colors
Definition: image.h:248
_Image::resolution
PointInfo resolution
Definition: image.h:209
magick_unreferenced
#define magick_unreferenced(x)
Definition: method-attribute.h:106
_Image::properties
void * properties
Definition: image.h:315
DefineImageProperty
MagickExport MagickBooleanType DefineImageProperty(Image *image, const char *property, ExceptionInfo *exception)
Definition: property.c:232
_PixelInfo::green
MagickRealType green
Definition: pixel.h:190
ImageType
ImageType
Definition: image.h:48
CloneString
MagickExport char * CloneString(char **destination, const char *source)
Definition: string.c:286
GetMagickProperty
MagickExport const char * GetMagickProperty(ImageInfo *image_info, Image *image, const char *property, ExceptionInfo *exception)
Definition: property.c:2840
_Image::compose
CompositeOperator compose
Definition: image.h:234
_ProfileInfo::name
char * name
Definition: profile.c:106
CompositeOperator
CompositeOperator
Definition: composite.h:25
ResolutionType
ResolutionType
Definition: image.h:89
ResetImageProfileIterator
MagickExport void ResetImageProfileIterator(const Image *image)
Definition: profile.c:1506
MagickExport
#define MagickExport
Definition: method-attribute.h:80
_Image::extent
MagickSizeType extent
Definition: image.h:270
_Image::orientation
OrientationType orientation
Definition: image.h:166
EXIF_FMT_ULONG
#define EXIF_FMT_ULONG
_Image::fuzz
double fuzz
Definition: image.h:216
_RectangleInfo::y
ssize_t y
Definition: geometry.h:134
FormatImageProperty
MagickExport MagickBooleanType FormatImageProperty(Image *image, const char *property, const char *format,...)
Definition: property.c:354
StringInfoToString
MagickExport char * StringInfoToString(const StringInfo *string_info)
Definition: string.c:1881
_PixelInfo
Definition: pixel.h:169
ComplianceType
ComplianceType
Definition: color.h:28
_Image::transparent_color
PixelInfo transparent_color
Definition: image.h:179
WarnNoImageReturn
#define WarnNoImageReturn(format, arg)
GetStringInfoLength
MagickExport size_t GetStringInfoLength(const StringInfo *string_info)
Definition: string.c:1234
_Image::background_color
PixelInfo background_color
Definition: image.h:179
GetImageListLength
MagickExport size_t GetImageListLength(const Image *images)
Definition: list.c:709
TraceBezierCurve
static void TraceBezierCurve(char *message, PointInfo *last, PointInfo *point)
Definition: property.c:2074
GetNextImageOption
MagickExport char * GetNextImageOption(const ImageInfo *image_info)
Definition: option.c:2620
_Image::client_data
void * client_data
Definition: image.h:306
DestroyImage
MagickExport Image * DestroyImage(Image *image)
Definition: image.c:1160
ConstantString
MagickExport char * ConstantString(const char *source)
Definition: string.c:702
_Image::gamma
double gamma
Definition: image.h:186
_PointInfo
Definition: geometry.h:120
_Image::colorspace
ColorspaceType colorspace
Definition: image.h:157
IsImageOpaque
MagickExport MagickBooleanType IsImageOpaque(const Image *image, ExceptionInfo *exception)
Definition: attribute.c:1804
NewXMLTree
MagickExport XMLTreeInfo * NewXMLTree(const char *xml, ExceptionInfo *exception)
Definition: xml-tree.c:1956
TAG_EXIF_OFFSET
#define TAG_EXIF_OFFSET
QuantumRange
#define QuantumRange
Definition: magick-type.h:87
AcquireFxInfo
MagickPrivate FxInfo * AcquireFxInfo(const Image *, const char *, ExceptionInfo *)
_Image::debug
MagickBooleanType debug
Definition: image.h:334
DestroyExceptionInfo
MagickExport ExceptionInfo * DestroyExceptionInfo(ExceptionInfo *exception)
Definition: exception.c:418
_Image::depth
size_t depth
Definition: image.h:172