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