granicus.if.org Git - imagemagick/blob - MagickCore/property.c

   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 %                                John Cristy                                  %
  17 %                                 March 2000                                  %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2012 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 %    http://www.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 \f
  40 /*
  41   Include declarations.
  42 */
  43 #include "MagickCore/studio.h"
  44 #include "MagickCore/attribute.h"
  45 #include "MagickCore/cache.h"
  46 #include "MagickCore/color.h"
  47 #include "MagickCore/compare.h"
  48 #include "MagickCore/constitute.h"
  49 #include "MagickCore/draw.h"
  50 #include "MagickCore/effect.h"
  51 #include "MagickCore/exception.h"
  52 #include "MagickCore/exception-private.h"
  53 #include "MagickCore/fx.h"
  54 #include "MagickCore/fx-private.h"
  55 #include "MagickCore/gem.h"
  56 #include "MagickCore/geometry.h"
  57 #include "MagickCore/histogram.h"
  58 #include "MagickCore/image.h"
  59 #include "MagickCore/image.h"
  60 #include "MagickCore/layer.h"
  61 #include "MagickCore/locale-private.h"
  62 #include "MagickCore/list.h"
  63 #include "MagickCore/magick.h"
  64 #include "MagickCore/memory_.h"
  65 #include "MagickCore/monitor.h"
  66 #include "MagickCore/montage.h"
  67 #include "MagickCore/option.h"
  68 #include "MagickCore/profile.h"
  69 #include "MagickCore/property.h"
  70 #include "MagickCore/quantum.h"
  71 #include "MagickCore/resource_.h"
  72 #include "MagickCore/splay-tree.h"
  73 #include "MagickCore/signature.h"
  74 #include "MagickCore/statistic.h"
  75 #include "MagickCore/string_.h"
  76 #include "MagickCore/string-private.h"
  77 #include "MagickCore/token.h"
  78 #include "MagickCore/token-private.h"
  79 #include "MagickCore/utility.h"
  80 #include "MagickCore/utility-private.h"
  81 #include "MagickCore/version.h"
  82 #include "MagickCore/xml-tree.h"
  83 #include "MagickCore/xml-tree-private.h"
  84 \f
  85 /*
  86 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  87 %                                                                             %
  88 %                                                                             %
  89 %                                                                             %
  90 %   C l o n e I m a g e P r o p e r t i e s                                   %
  91 %                                                                             %
  92 %                                                                             %
  93 %                                                                             %
  94 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  95 %
  96 %  CloneImageProperties() clones one or more image properties.
  97 %
  98 %  The format of the CloneImageProperties method is:
  99 %
 100 %      MagickBooleanType CloneImageProperties(Image *image,
 101 %        const Image *clone_image)
 102 %
 103 %  A description of each parameter follows:
 104 %
 105 %    o image: the image.
 106 %
 107 %    o clone_image: the clone image.
 108 %
 109 */
 110 MagickExport MagickBooleanType CloneImageProperties(Image *image,
 111   const Image *clone_image)
 112 {
 113   assert(image != (Image *) NULL);
 114   assert(image->signature == MagickSignature);
 115   if (image->debug != MagickFalse)
 116     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 117   assert(clone_image != (const Image *) NULL);
 118   assert(clone_image->signature == MagickSignature);
 119   if (clone_image->debug != MagickFalse)
 120     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 121       clone_image->filename);
 122   (void) CopyMagickString(image->filename,clone_image->filename,MaxTextExtent);
 123   (void) CopyMagickString(image->magick_filename,clone_image->magick_filename,
 124     MaxTextExtent);
 125   image->compression=clone_image->compression;
 126   image->quality=clone_image->quality;
 127   image->depth=clone_image->depth;
 128   image->background_color=clone_image->background_color;
 129   image->border_color=clone_image->border_color;
 130   image->matte_color=clone_image->matte_color;
 131   image->transparent_color=clone_image->transparent_color;
 132   image->gamma=clone_image->gamma;
 133   image->chromaticity=clone_image->chromaticity;
 134   image->rendering_intent=clone_image->rendering_intent;
 135   image->black_point_compensation=clone_image->black_point_compensation;
 136   image->units=clone_image->units;
 137   image->montage=(char *) NULL;
 138   image->directory=(char *) NULL;
 139   (void) CloneString(&image->geometry,clone_image->geometry);
 140   image->offset=clone_image->offset;
 141   image->resolution.x=clone_image->resolution.x;
 142   image->resolution.y=clone_image->resolution.y;
 143   image->page=clone_image->page;
 144   image->tile_offset=clone_image->tile_offset;
 145   image->extract_info=clone_image->extract_info;
 146   image->filter=clone_image->filter;
 147   image->fuzz=clone_image->fuzz;
 148   image->interlace=clone_image->interlace;
 149   image->interpolate=clone_image->interpolate;
 150   image->endian=clone_image->endian;
 151   image->gravity=clone_image->gravity;
 152   image->compose=clone_image->compose;
 153   image->scene=clone_image->scene;
 154   image->orientation=clone_image->orientation;
 155   image->dispose=clone_image->dispose;
 156   image->delay=clone_image->delay;
 157   image->ticks_per_second=clone_image->ticks_per_second;
 158   image->iterations=clone_image->iterations;
 159   image->total_colors=clone_image->total_colors;
 160   image->taint=clone_image->taint;
 161   image->progress_monitor=clone_image->progress_monitor;
 162   image->client_data=clone_image->client_data;
 163   image->start_loop=clone_image->start_loop;
 164   image->error=clone_image->error;
 165   image->signature=clone_image->signature;
 166   if (clone_image->properties != (void *) NULL)
 167     {
 168       if (image->properties != (void *) NULL)
 169         DestroyImageProperties(image);
 170       image->properties=CloneSplayTree((SplayTreeInfo *)
 171         clone_image->properties,(void *(*)(void *)) ConstantString,
 172         (void *(*)(void *)) ConstantString);
 173     }
 174   return(MagickTrue);
 175 }
 176 \f
 177 /*
 178 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 179 %                                                                             %
 180 %                                                                             %
 181 %                                                                             %
 182 %   D e f i n e I m a g e P r o p e r t y                                     %
 183 %                                                                             %
 184 %                                                                             %
 185 %                                                                             %
 186 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 187 %
 188 %  DefineImageProperty() associates a key/value pair with an image property.
 189 %
 190 %  The format of the DefineImageProperty method is:
 191 %
 192 %      MagickBooleanType DefineImageProperty(Image *image,
 193 %        const char *property,ExceptionInfo *exception)
 194 %
 195 %  A description of each parameter follows:
 196 %
 197 %    o image: the image.
 198 %
 199 %    o property: the image property.
 200 %
 201 %    o exception: return any errors or warnings in this structure.
 202 %
 203 */
 204 MagickExport MagickBooleanType DefineImageProperty(Image *image,
 205   const char *property,ExceptionInfo *exception)
 206 {
 207   char
 208     key[MaxTextExtent],
 209     value[MaxTextExtent];
 210
 211   register char
 212     *p;
 213
 214   assert(image != (Image *) NULL);
 215   assert(property != (const char *) NULL);
 216   (void) CopyMagickString(key,property,MaxTextExtent-1);
 217   for (p=key; *p != '\0'; p++)
 218     if (*p == '=')
 219       break;
 220   *value='\0';
 221   if (*p == '=')
 222     (void) CopyMagickString(value,p+1,MaxTextExtent);
 223   *p='\0';
 224   return(SetImageProperty(image,key,value,exception));
 225 }
 226 \f
 227 /*
 228 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 229 %                                                                             %
 230 %                                                                             %
 231 %                                                                             %
 232 %   D e l e t e I m a g e P r o p e r t y                                     %
 233 %                                                                             %
 234 %                                                                             %
 235 %                                                                             %
 236 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 237 %
 238 %  DeleteImageProperty() deletes an image property.
 239 %
 240 %  The format of the DeleteImageProperty method is:
 241 %
 242 %      MagickBooleanType DeleteImageProperty(Image *image,const char *property)
 243 %
 244 %  A description of each parameter follows:
 245 %
 246 %    o image: the image.
 247 %
 248 %    o property: the image property.
 249 %
 250 */
 251 MagickExport MagickBooleanType DeleteImageProperty(Image *image,
 252   const char *property)
 253 {
 254   assert(image != (Image *) NULL);
 255   assert(image->signature == MagickSignature);
 256   if (image->debug != MagickFalse)
 257     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 258       image->filename);
 259   if (image->properties == (void *) NULL)
 260     return(MagickFalse);
 261   return(DeleteNodeFromSplayTree((SplayTreeInfo *) image->properties,property));
 262 }
 263 \f
 264 /*
 265 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 266 %                                                                             %
 267 %                                                                             %
 268 %                                                                             %
 269 %   D e s t r o y I m a g e P r o p e r t i e s                               %
 270 %                                                                             %
 271 %                                                                             %
 272 %                                                                             %
 273 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 274 %
 275 %  DestroyImageProperties() releases memory associated with image property
 276 %  values.
 277 %
 278 %  The format of the DestroyDefines method is:
 279 %
 280 %      void DestroyImageProperties(Image *image)
 281 %
 282 %  A description of each parameter follows:
 283 %
 284 %    o image: the image.
 285 %
 286 */
 287 MagickExport void DestroyImageProperties(Image *image)
 288 {
 289   assert(image != (Image *) NULL);
 290   assert(image->signature == MagickSignature);
 291   if (image->debug != MagickFalse)
 292     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 293       image->filename);
 294   if (image->properties != (void *) NULL)
 295     image->properties=(void *) DestroySplayTree((SplayTreeInfo *)
 296       image->properties);
 297 }
 298 \f
 299 /*
 300 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 301 %                                                                             %
 302 %                                                                             %
 303 %                                                                             %
 304 %  F o r m a t I m a g e P r o p e r t y                                      %
 305 %                                                                             %
 306 %                                                                             %
 307 %                                                                             %
 308 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 309 %
 310 %  FormatImageProperty() permits formatted property/value pairs to be saved as
 311 %  an image property.
 312 %
 313 %  The format of the FormatImageProperty method is:
 314 %
 315 %      MagickBooleanType FormatImageProperty(Image *image,const char *property,
 316 %        const char *format,...)
 317 %
 318 %  A description of each parameter follows.
 319 %
 320 %   o  image:  The image.
 321 %
 322 %   o  property:  The attribute property.
 323 %
 324 %   o  format:  A string describing the format to use to write the remaining
 325 %      arguments.
 326 %
 327 */
 328 MagickExport MagickBooleanType FormatImageProperty(Image *image,
 329   const char *property,const char *format,...)
 330 {
 331   char
 332     value[MaxTextExtent];
 333
 334   ExceptionInfo
 335     *exception;
 336
 337   MagickBooleanType
 338     status;
 339
 340   ssize_t
 341     n;
 342
 343   va_list
 344     operands;
 345
 346   va_start(operands,format);
 347   n=FormatLocaleStringList(value,MaxTextExtent,format,operands);
 348   (void) n;
 349   va_end(operands);
 350   exception=AcquireExceptionInfo();
 351   status=SetImageProperty(image,property,value,exception);
 352   exception=DestroyExceptionInfo(exception);
 353   return(status);
 354 }
 355 \f
 356 /*
 357 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 358 %                                                                             %
 359 %                                                                             %
 360 %                                                                             %
 361 %   G e t I m a g e P r o p e r t y                                           %
 362 %                                                                             %
 363 %                                                                             %
 364 %                                                                             %
 365 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 366 %
 367 %  GetImageProperty() gets a value associated with an image property.
 368 %
 369 %  The format of the GetImageProperty method is:
 370 %
 371 %      const char *GetImageProperty(const Image *image,const char *key,
 372 %        ExceptionInfo *exception)
 373 %
 374 %  A description of each parameter follows:
 375 %
 376 %    o image: the image.
 377 %
 378 %    o key: the key.
 379 %
 380 %    o exception: return any errors or warnings in this structure.
 381 %
 382 */
 383
 384 static char
 385   *TracePSClippath(const unsigned char *,size_t,const size_t,
 386     const size_t),
 387   *TraceSVGClippath(const unsigned char *,size_t,const size_t,
 388     const size_t);
 389
 390 static MagickBooleanType GetIPTCProperty(const Image *image,const char *key,
 391   ExceptionInfo *exception)
 392 {
 393   char
 394     *attribute,
 395     *message;
 396
 397   const StringInfo
 398     *profile;
 399
 400   long
 401     count,
 402     dataset,
 403     record;
 404
 405   register ssize_t
 406     i;
 407
 408   size_t
 409     length;
 410
 411   profile=GetImageProfile(image,"iptc");
 412   if (profile == (StringInfo *) NULL)
 413     profile=GetImageProfile(image,"8bim");
 414   if (profile == (StringInfo *) NULL)
 415     return(MagickFalse);
 416   count=sscanf(key,"IPTC:%ld:%ld",&dataset,&record);
 417   if (count != 2)
 418     return(MagickFalse);
 419   attribute=(char *) NULL;
 420   for (i=0; i < (ssize_t) GetStringInfoLength(profile); i+=(ssize_t) length)
 421   {
 422     length=1;
 423     if ((ssize_t) GetStringInfoDatum(profile)[i] != 0x1c)
 424       continue;
 425     length=(size_t) (GetStringInfoDatum(profile)[i+3] << 8);
 426     length|=GetStringInfoDatum(profile)[i+4];
 427     if (((long) GetStringInfoDatum(profile)[i+1] == dataset) &&
 428         ((long) GetStringInfoDatum(profile)[i+2] == record))
 429       {
 430         message=(char *) NULL;
 431         if (~length >= 1)
 432           message=(char *) AcquireQuantumMemory(length+1UL,sizeof(*message));
 433         if (message != (char *) NULL)
 434           {
 435             (void) CopyMagickString(message,(char *) GetStringInfoDatum(
 436               profile)+i+5,length+1);
 437             (void) ConcatenateString(&attribute,message);
 438             (void) ConcatenateString(&attribute,";");
 439             message=DestroyString(message);
 440           }
 441       }
 442     i+=5;
 443   }
 444   if ((attribute == (char *) NULL) || (*attribute == ';'))
 445     {
 446       if (attribute != (char *) NULL)
 447         attribute=DestroyString(attribute);
 448       return(MagickFalse);
 449     }
 450   attribute[strlen(attribute)-1]='\0';
 451   (void) SetImageProperty((Image *) image,key,(const char *) attribute,
 452     exception);
 453   attribute=DestroyString(attribute);
 454   return(MagickTrue);
 455 }
 456
 457 static inline ssize_t MagickMax(const ssize_t x,const ssize_t y)
 458 {
 459   if (x > y)
 460     return(x);
 461   return(y);
 462 }
 463
 464 static inline ssize_t MagickMin(const ssize_t x,const ssize_t y)
 465 {
 466   if (x < y)
 467     return(x);
 468   return(y);
 469 }
 470
 471 static inline int ReadPropertyByte(const unsigned char **p,size_t *length)
 472 {
 473   int
 474     c;
 475
 476   if (*length < 1)
 477     return(EOF);
 478   c=(int) (*(*p)++);
 479   (*length)--;
 480   return(c);
 481 }
 482
 483 static inline size_t ReadPropertyMSBLong(const unsigned char **p,
 484   size_t *length)
 485 {
 486   int
 487     c;
 488
 489   register ssize_t
 490     i;
 491
 492   unsigned char
 493     buffer[4];
 494
 495   size_t
 496     value;
 497
 498   if (*length < 4)
 499     return(~0UL);
 500   for (i=0; i < 4; i++)
 501   {
 502     c=(int) (*(*p)++);
 503     (*length)--;
 504     buffer[i]=(unsigned char) c;
 505   }
 506   value=(size_t) (buffer[0] << 24);
 507   value|=buffer[1] << 16;
 508   value|=buffer[2] << 8;
 509   value|=buffer[3];
 510   return(value & 0xffffffff);
 511 }
 512
 513 static inline unsigned short ReadPropertyMSBShort(const unsigned char **p,
 514   size_t *length)
 515 {
 516   int
 517     c;
 518
 519   register ssize_t
 520     i;
 521
 522   unsigned char
 523     buffer[2];
 524
 525   unsigned short
 526     value;
 527
 528   if (*length < 2)
 529     return((unsigned short) ~0U);
 530   for (i=0; i < 2; i++)
 531   {
 532     c=(int) (*(*p)++);
 533     (*length)--;
 534     buffer[i]=(unsigned char) c;
 535   }
 536   value=(unsigned short) (buffer[0] << 8);
 537   value|=buffer[1];
 538   return((unsigned short) (value & 0xffff));
 539 }
 540
 541 static MagickBooleanType Get8BIMProperty(const Image *image,const char *key,
 542   ExceptionInfo *exception)
 543 {
 544   char
 545     *attribute,
 546     format[MaxTextExtent],
 547     name[MaxTextExtent],
 548     *resource;
 549
 550   const StringInfo
 551     *profile;
 552
 553   const unsigned char
 554     *info;
 555
 556   long
 557     start,
 558     stop;
 559
 560   MagickBooleanType
 561     status;
 562
 563   register ssize_t
 564     i;
 565
 566   ssize_t
 567     count,
 568     id,
 569     sub_number;
 570
 571   size_t
 572     length;
 573
 574   /*
 575     There are no newlines in path names, so it's safe as terminator.
 576   */
 577   profile=GetImageProfile(image,"8bim");
 578   if (profile == (StringInfo *) NULL)
 579     return(MagickFalse);
 580   count=(ssize_t) sscanf(key,"8BIM:%ld,%ld:%[^\n]\n%[^\n]",&start,&stop,name,
 581     format);
 582   if ((count != 2) && (count != 3) && (count != 4))
 583     return(MagickFalse);
 584   if (count < 4)
 585     (void) CopyMagickString(format,"SVG",MaxTextExtent);
 586   if (count < 3)
 587     *name='\0';
 588   sub_number=1;
 589   if (*name == '#')
 590     sub_number=(ssize_t) StringToLong(&name[1]);
 591   sub_number=MagickMax(sub_number,1L);
 592   resource=(char *) NULL;
 593   status=MagickFalse;
 594   length=GetStringInfoLength(profile);
 595   info=GetStringInfoDatum(profile);
 596   while ((length > 0) && (status == MagickFalse))
 597   {
 598     if (ReadPropertyByte(&info,&length) != (unsigned char) '8')
 599       continue;
 600     if (ReadPropertyByte(&info,&length) != (unsigned char) 'B')
 601       continue;
 602     if (ReadPropertyByte(&info,&length) != (unsigned char) 'I')
 603       continue;
 604     if (ReadPropertyByte(&info,&length) != (unsigned char) 'M')
 605       continue;
 606     id=(ssize_t) ((int) ReadPropertyMSBShort(&info,&length));
 607     if (id < (ssize_t) start)
 608       continue;
 609     if (id > (ssize_t) stop)
 610       continue;
 611     if (resource != (char *) NULL)
 612       resource=DestroyString(resource);
 613     count=(ssize_t) ReadPropertyByte(&info,&length);
 614     if ((count != 0) && ((size_t) count <= length))
 615       {
 616         resource=(char *) NULL;
 617         if (~(1UL*count) >= (MaxTextExtent-1))
 618           resource=(char *) AcquireQuantumMemory((size_t) count+MaxTextExtent,
 619             sizeof(*resource));
 620         if (resource != (char *) NULL)
 621           {
 622             for (i=0; i < (ssize_t) count; i++)
 623               resource[i]=(char) ReadPropertyByte(&info,&length);
 624             resource[count]='\0';
 625           }
 626       }
 627     if ((count & 0x01) == 0)
 628       (void) ReadPropertyByte(&info,&length);
 629     count=(ssize_t) ((int) ReadPropertyMSBLong(&info,&length));
 630     if ((*name != '\0') && (*name != '#'))
 631       if ((resource == (char *) NULL) || (LocaleCompare(name,resource) != 0))
 632         {
 633           /*
 634             No name match, scroll forward and try next.
 635           */
 636           info+=count;
 637           length-=MagickMin(count,(ssize_t) length);
 638           continue;
 639         }
 640     if ((*name == '#') && (sub_number != 1))
 641       {
 642         /*
 643           No numbered match, scroll forward and try next.
 644         */
 645         sub_number--;
 646         info+=count;
 647         length-=MagickMin(count,(ssize_t) length);
 648         continue;
 649       }
 650     /*
 651       We have the resource of interest.
 652     */
 653     attribute=(char *) NULL;
 654     if (~(1UL*count) >= (MaxTextExtent-1))
 655       attribute=(char *) AcquireQuantumMemory((size_t) count+MaxTextExtent,
 656         sizeof(*attribute));
 657     if (attribute != (char *) NULL)
 658       {
 659         (void) CopyMagickMemory(attribute,(char *) info,(size_t) count);
 660         attribute[count]='\0';
 661         info+=count;
 662         length-=MagickMin(count,(ssize_t) length);
 663         if ((id <= 1999) || (id >= 2999))
 664           (void) SetImageProperty((Image *) image,key,(const char *)
 665             attribute,exception);
 666         else
 667           {
 668             char
 669               *path;
 670
 671             if (LocaleCompare(format,"svg") == 0)
 672               path=TraceSVGClippath((unsigned char *) attribute,(size_t) count,
 673                 image->columns,image->rows);
 674             else
 675               path=TracePSClippath((unsigned char *) attribute,(size_t) count,
 676                 image->columns,image->rows);
 677             (void) SetImageProperty((Image *) image,key,(const char *) path,
 678               exception);
 679             path=DestroyString(path);
 680           }
 681         attribute=DestroyString(attribute);
 682         status=MagickTrue;
 683       }
 684   }
 685   if (resource != (char *) NULL)
 686     resource=DestroyString(resource);
 687   return(status);
 688 }
 689
 690 static inline unsigned short ReadPropertyShort(const EndianType endian,
 691   const unsigned char *buffer)
 692 {
 693   unsigned short
 694     value;
 695
 696   if (endian == MSBEndian)
 697     {
 698       value=(unsigned short) ((((unsigned char *) buffer)[0] << 8) |
 699         ((unsigned char *) buffer)[1]);
 700       return((unsigned short) (value & 0xffff));
 701     }
 702   value=(unsigned short) ((buffer[1] << 8) | buffer[0]);
 703   return((unsigned short) (value & 0xffff));
 704 }
 705
 706 static inline size_t ReadPropertyLong(const EndianType endian,
 707   const unsigned char *buffer)
 708 {
 709   size_t
 710     value;
 711
 712   if (endian == MSBEndian)
 713     {
 714       value=(size_t) ((buffer[0] << 24) | (buffer[1] << 16) |
 715         (buffer[2] << 8) | buffer[3]);
 716       return((size_t) (value & 0xffffffff));
 717     }
 718   value=(size_t) ((buffer[3] << 24) | (buffer[2] << 16) |
 719     (buffer[1] << 8 ) | (buffer[0]));
 720   return((size_t) (value & 0xffffffff));
 721 }
 722
 723 static MagickBooleanType GetEXIFProperty(const Image *image,
 724   const char *property,ExceptionInfo *exception)
 725 {
 726 #define MaxDirectoryStack  16
 727 #define EXIF_DELIMITER  "\n"
 728 #define EXIF_NUM_FORMATS  12
 729 #define EXIF_FMT_BYTE  1
 730 #define EXIF_FMT_STRING  2
 731 #define EXIF_FMT_USHORT  3
 732 #define EXIF_FMT_ULONG  4
 733 #define EXIF_FMT_URATIONAL  5
 734 #define EXIF_FMT_SBYTE  6
 735 #define EXIF_FMT_UNDEFINED  7
 736 #define EXIF_FMT_SSHORT  8
 737 #define EXIF_FMT_SLONG  9
 738 #define EXIF_FMT_SRATIONAL  10
 739 #define EXIF_FMT_SINGLE  11
 740 #define EXIF_FMT_DOUBLE  12
 741 #define TAG_EXIF_OFFSET  0x8769
 742 #define TAG_GPS_OFFSET  0x8825
 743 #define TAG_INTEROP_OFFSET  0xa005
 744
 745 #define EXIFMultipleValues(size,format,arg) \
 746 { \
 747    ssize_t \
 748      component; \
 749  \
 750    size_t \
 751      length; \
 752  \
 753    unsigned char \
 754      *p1; \
 755  \
 756    length=0; \
 757    p1=p; \
 758    for (component=0; component < components; component++) \
 759    { \
 760      length+=FormatLocaleString(buffer+length,MaxTextExtent-length, \
 761        format", ",arg); \
 762      if (length >= (MaxTextExtent-1)) \
 763        length=MaxTextExtent-1; \
 764      p1+=size; \
 765    } \
 766    if (length > 1) \
 767      buffer[length-2]='\0'; \
 768    value=AcquireString(buffer); \
 769 }
 770
 771 #define EXIFMultipleFractions(size,format,arg1,arg2) \
 772 { \
 773    ssize_t \
 774      component; \
 775  \
 776    size_t \
 777      length; \
 778  \
 779    unsigned char \
 780      *p1; \
 781  \
 782    length=0; \
 783    p1=p; \
 784    for (component=0; component < components; component++) \
 785    { \
 786      length+=FormatLocaleString(buffer+length,MaxTextExtent-length, \
 787        format", ",(arg1),(arg2)); \
 788      if (length >= (MaxTextExtent-1)) \
 789        length=MaxTextExtent-1; \
 790      p1+=size; \
 791    } \
 792    if (length > 1) \
 793      buffer[length-2]='\0'; \
 794    value=AcquireString(buffer); \
 795 }
 796
 797   typedef struct _DirectoryInfo
 798   {
 799     const unsigned char
 800       *directory;
 801
 802     size_t
 803       entry;
 804
 805     ssize_t
 806       offset;
 807   } DirectoryInfo;
 808
 809   typedef struct _TagInfo
 810   {
 811     size_t
 812       tag;
 813
 814     const char
 815       *description;
 816   } TagInfo;
 817
 818   static TagInfo
 819     EXIFTag[] =
 820     {
 821       {  0x001, "exif:InteroperabilityIndex" },
 822       {  0x002, "exif:InteroperabilityVersion" },
 823       {  0x100, "exif:ImageWidth" },
 824       {  0x101, "exif:ImageLength" },
 825       {  0x102, "exif:BitsPerSample" },
 826       {  0x103, "exif:Compression" },
 827       {  0x106, "exif:PhotometricInterpretation" },
 828       {  0x10a, "exif:FillOrder" },
 829       {  0x10d, "exif:DocumentName" },
 830       {  0x10e, "exif:ImageDescription" },
 831       {  0x10f, "exif:Make" },
 832       {  0x110, "exif:Model" },
 833       {  0x111, "exif:StripOffsets" },
 834       {  0x112, "exif:Orientation" },
 835       {  0x115, "exif:SamplesPerPixel" },
 836       {  0x116, "exif:RowsPerStrip" },
 837       {  0x117, "exif:StripByteCounts" },
 838       {  0x11a, "exif:XResolution" },
 839       {  0x11b, "exif:YResolution" },
 840       {  0x11c, "exif:PlanarConfiguration" },
 841       {  0x11d, "exif:PageName" },
 842       {  0x11e, "exif:XPosition" },
 843       {  0x11f, "exif:YPosition" },
 844       {  0x118, "exif:MinSampleValue" },
 845       {  0x119, "exif:MaxSampleValue" },
 846       {  0x120, "exif:FreeOffsets" },
 847       {  0x121, "exif:FreeByteCounts" },
 848       {  0x122, "exif:GrayResponseUnit" },
 849       {  0x123, "exif:GrayResponseCurve" },
 850       {  0x124, "exif:T4Options" },
 851       {  0x125, "exif:T6Options" },
 852       {  0x128, "exif:ResolutionUnit" },
 853       {  0x12d, "exif:TransferFunction" },
 854       {  0x131, "exif:Software" },
 855       {  0x132, "exif:DateTime" },
 856       {  0x13b, "exif:Artist" },
 857       {  0x13e, "exif:WhitePoint" },
 858       {  0x13f, "exif:PrimaryChromaticities" },
 859       {  0x140, "exif:ColorMap" },
 860       {  0x141, "exif:HalfToneHints" },
 861       {  0x142, "exif:TileWidth" },
 862       {  0x143, "exif:TileLength" },
 863       {  0x144, "exif:TileOffsets" },
 864       {  0x145, "exif:TileByteCounts" },
 865       {  0x14a, "exif:SubIFD" },
 866       {  0x14c, "exif:InkSet" },
 867       {  0x14d, "exif:InkNames" },
 868       {  0x14e, "exif:NumberOfInks" },
 869       {  0x150, "exif:DotRange" },
 870       {  0x151, "exif:TargetPrinter" },
 871       {  0x152, "exif:ExtraSample" },
 872       {  0x153, "exif:SampleFormat" },
 873       {  0x154, "exif:SMinSampleValue" },
 874       {  0x155, "exif:SMaxSampleValue" },
 875       {  0x156, "exif:TransferRange" },
 876       {  0x157, "exif:ClipPath" },
 877       {  0x158, "exif:XClipPathUnits" },
 878       {  0x159, "exif:YClipPathUnits" },
 879       {  0x15a, "exif:Indexed" },
 880       {  0x15b, "exif:JPEGTables" },
 881       {  0x15f, "exif:OPIProxy" },
 882       {  0x200, "exif:JPEGProc" },
 883       {  0x201, "exif:JPEGInterchangeFormat" },
 884       {  0x202, "exif:JPEGInterchangeFormatLength" },
 885       {  0x203, "exif:JPEGRestartInterval" },
 886       {  0x205, "exif:JPEGLosslessPredictors" },
 887       {  0x206, "exif:JPEGPointTransforms" },
 888       {  0x207, "exif:JPEGQTables" },
 889       {  0x208, "exif:JPEGDCTables" },
 890       {  0x209, "exif:JPEGACTables" },
 891       {  0x211, "exif:YCbCrCoefficients" },
 892       {  0x212, "exif:YCbCrSubSampling" },
 893       {  0x213, "exif:YCbCrPositioning" },
 894       {  0x214, "exif:ReferenceBlackWhite" },
 895       {  0x2bc, "exif:ExtensibleMetadataPlatform" },
 896       {  0x301, "exif:Gamma" },
 897       {  0x302, "exif:ICCProfileDescriptor" },
 898       {  0x303, "exif:SRGBRenderingIntent" },
 899       {  0x320, "exif:ImageTitle" },
 900       {  0x5001, "exif:ResolutionXUnit" },
 901       {  0x5002, "exif:ResolutionYUnit" },
 902       {  0x5003, "exif:ResolutionXLengthUnit" },
 903       {  0x5004, "exif:ResolutionYLengthUnit" },
 904       {  0x5005, "exif:PrintFlags" },
 905       {  0x5006, "exif:PrintFlagsVersion" },
 906       {  0x5007, "exif:PrintFlagsCrop" },
 907       {  0x5008, "exif:PrintFlagsBleedWidth" },
 908       {  0x5009, "exif:PrintFlagsBleedWidthScale" },
 909       {  0x500A, "exif:HalftoneLPI" },
 910       {  0x500B, "exif:HalftoneLPIUnit" },
 911       {  0x500C, "exif:HalftoneDegree" },
 912       {  0x500D, "exif:HalftoneShape" },
 913       {  0x500E, "exif:HalftoneMisc" },
 914       {  0x500F, "exif:HalftoneScreen" },
 915       {  0x5010, "exif:JPEGQuality" },
 916       {  0x5011, "exif:GridSize" },
 917       {  0x5012, "exif:ThumbnailFormat" },
 918       {  0x5013, "exif:ThumbnailWidth" },
 919       {  0x5014, "exif:ThumbnailHeight" },
 920       {  0x5015, "exif:ThumbnailColorDepth" },
 921       {  0x5016, "exif:ThumbnailPlanes" },
 922       {  0x5017, "exif:ThumbnailRawBytes" },
 923       {  0x5018, "exif:ThumbnailSize" },
 924       {  0x5019, "exif:ThumbnailCompressedSize" },
 925       {  0x501a, "exif:ColorTransferFunction" },
 926       {  0x501b, "exif:ThumbnailData" },
 927       {  0x5020, "exif:ThumbnailImageWidth" },
 928       {  0x5021, "exif:ThumbnailImageHeight" },
 929       {  0x5022, "exif:ThumbnailBitsPerSample" },
 930       {  0x5023, "exif:ThumbnailCompression" },
 931       {  0x5024, "exif:ThumbnailPhotometricInterp" },
 932       {  0x5025, "exif:ThumbnailImageDescription" },
 933       {  0x5026, "exif:ThumbnailEquipMake" },
 934       {  0x5027, "exif:ThumbnailEquipModel" },
 935       {  0x5028, "exif:ThumbnailStripOffsets" },
 936       {  0x5029, "exif:ThumbnailOrientation" },
 937       {  0x502a, "exif:ThumbnailSamplesPerPixel" },
 938       {  0x502b, "exif:ThumbnailRowsPerStrip" },
 939       {  0x502c, "exif:ThumbnailStripBytesCount" },
 940       {  0x502d, "exif:ThumbnailResolutionX" },
 941       {  0x502e, "exif:ThumbnailResolutionY" },
 942       {  0x502f, "exif:ThumbnailPlanarConfig" },
 943       {  0x5030, "exif:ThumbnailResolutionUnit" },
 944       {  0x5031, "exif:ThumbnailTransferFunction" },
 945       {  0x5032, "exif:ThumbnailSoftwareUsed" },
 946       {  0x5033, "exif:ThumbnailDateTime" },
 947       {  0x5034, "exif:ThumbnailArtist" },
 948       {  0x5035, "exif:ThumbnailWhitePoint" },
 949       {  0x5036, "exif:ThumbnailPrimaryChromaticities" },
 950       {  0x5037, "exif:ThumbnailYCbCrCoefficients" },
 951       {  0x5038, "exif:ThumbnailYCbCrSubsampling" },
 952       {  0x5039, "exif:ThumbnailYCbCrPositioning" },
 953       {  0x503A, "exif:ThumbnailRefBlackWhite" },
 954       {  0x503B, "exif:ThumbnailCopyRight" },
 955       {  0x5090, "exif:LuminanceTable" },
 956       {  0x5091, "exif:ChrominanceTable" },
 957       {  0x5100, "exif:FrameDelay" },
 958       {  0x5101, "exif:LoopCount" },
 959       {  0x5110, "exif:PixelUnit" },
 960       {  0x5111, "exif:PixelPerUnitX" },
 961       {  0x5112, "exif:PixelPerUnitY" },
 962       {  0x5113, "exif:PaletteHistogram" },
 963       {  0x1000, "exif:RelatedImageFileFormat" },
 964       {  0x1001, "exif:RelatedImageLength" },
 965       {  0x1002, "exif:RelatedImageWidth" },
 966       {  0x800d, "exif:ImageID" },
 967       {  0x80e3, "exif:Matteing" },
 968       {  0x80e4, "exif:DataType" },
 969       {  0x80e5, "exif:ImageDepth" },
 970       {  0x80e6, "exif:TileDepth" },
 971       {  0x828d, "exif:CFARepeatPatternDim" },
 972       {  0x828e, "exif:CFAPattern2" },
 973       {  0x828f, "exif:BatteryLevel" },
 974       {  0x8298, "exif:Copyright" },
 975       {  0x829a, "exif:ExposureTime" },
 976       {  0x829d, "exif:FNumber" },
 977       {  0x83bb, "exif:IPTC/NAA" },
 978       {  0x84e3, "exif:IT8RasterPadding" },
 979       {  0x84e5, "exif:IT8ColorTable" },
 980       {  0x8649, "exif:ImageResourceInformation" },
 981       {  0x8769, "exif:ExifOffset" },
 982       {  0x8773, "exif:InterColorProfile" },
 983       {  0x8822, "exif:ExposureProgram" },
 984       {  0x8824, "exif:SpectralSensitivity" },
 985       {  0x8825, "exif:GPSInfo" },
 986       {  0x8827, "exif:ISOSpeedRatings" },
 987       {  0x8828, "exif:OECF" },
 988       {  0x8829, "exif:Interlace" },
 989       {  0x882a, "exif:TimeZoneOffset" },
 990       {  0x882b, "exif:SelfTimerMode" },
 991       {  0x9000, "exif:ExifVersion" },
 992       {  0x9003, "exif:DateTimeOriginal" },
 993       {  0x9004, "exif:DateTimeDigitized" },
 994       {  0x9101, "exif:ComponentsConfiguration" },
 995       {  0x9102, "exif:CompressedBitsPerPixel" },
 996       {  0x9201, "exif:ShutterSpeedValue" },
 997       {  0x9202, "exif:ApertureValue" },
 998       {  0x9203, "exif:BrightnessValue" },
 999       {  0x9204, "exif:ExposureBiasValue" },
1000       {  0x9205, "exif:MaxApertureValue" },
1001       {  0x9206, "exif:SubjectDistance" },
1002       {  0x9207, "exif:MeteringMode" },
1003       {  0x9208, "exif:LightSource" },
1004       {  0x9209, "exif:Flash" },
1005       {  0x920a, "exif:FocalLength" },
1006       {  0x920b, "exif:FlashEnergy" },
1007       {  0x920c, "exif:SpatialFrequencyResponse" },
1008       {  0x920d, "exif:Noise" },
1009       {  0x9211, "exif:ImageNumber" },
1010       {  0x9212, "exif:SecurityClassification" },
1011       {  0x9213, "exif:ImageHistory" },
1012       {  0x9214, "exif:SubjectArea" },
1013       {  0x9215, "exif:ExposureIndex" },
1014       {  0x9216, "exif:TIFF-EPStandardID" },
1015       {  0x927c, "exif:MakerNote" },
1016       {  0x9C9b, "exif:WinXP-Title" },
1017       {  0x9C9c, "exif:WinXP-Comments" },
1018       {  0x9C9d, "exif:WinXP-Author" },
1019       {  0x9C9e, "exif:WinXP-Keywords" },
1020       {  0x9C9f, "exif:WinXP-Subject" },
1021       {  0x9286, "exif:UserComment" },
1022       {  0x9290, "exif:SubSecTime" },
1023       {  0x9291, "exif:SubSecTimeOriginal" },
1024       {  0x9292, "exif:SubSecTimeDigitized" },
1025       {  0xa000, "exif:FlashPixVersion" },
1026       {  0xa001, "exif:ColorSpace" },
1027       {  0xa002, "exif:ExifImageWidth" },
1028       {  0xa003, "exif:ExifImageLength" },
1029       {  0xa004, "exif:RelatedSoundFile" },
1030       {  0xa005, "exif:InteroperabilityOffset" },
1031       {  0xa20b, "exif:FlashEnergy" },
1032       {  0xa20c, "exif:SpatialFrequencyResponse" },
1033       {  0xa20d, "exif:Noise" },
1034       {  0xa20e, "exif:FocalPlaneXResolution" },
1035       {  0xa20f, "exif:FocalPlaneYResolution" },
1036       {  0xa210, "exif:FocalPlaneResolutionUnit" },
1037       {  0xa214, "exif:SubjectLocation" },
1038       {  0xa215, "exif:ExposureIndex" },
1039       {  0xa216, "exif:TIFF/EPStandardID" },
1040       {  0xa217, "exif:SensingMethod" },
1041       {  0xa300, "exif:FileSource" },
1042       {  0xa301, "exif:SceneType" },
1043       {  0xa302, "exif:CFAPattern" },
1044       {  0xa401, "exif:CustomRendered" },
1045       {  0xa402, "exif:ExposureMode" },
1046       {  0xa403, "exif:WhiteBalance" },
1047       {  0xa404, "exif:DigitalZoomRatio" },
1048       {  0xa405, "exif:FocalLengthIn35mmFilm" },
1049       {  0xa406, "exif:SceneCaptureType" },
1050       {  0xa407, "exif:GainControl" },
1051       {  0xa408, "exif:Contrast" },
1052       {  0xa409, "exif:Saturation" },
1053       {  0xa40a, "exif:Sharpness" },
1054       {  0xa40b, "exif:DeviceSettingDescription" },
1055       {  0xa40c, "exif:SubjectDistanceRange" },
1056       {  0xa420, "exif:ImageUniqueID" },
1057       {  0xc4a5, "exif:PrintImageMatching" },
1058       {  0xa500, "exif:Gamma" },
1059       {  0xc640, "exif:CR2Slice" },
1060       { 0x10000, "exif:GPSVersionID" },
1061       { 0x10001, "exif:GPSLatitudeRef" },
1062       { 0x10002, "exif:GPSLatitude" },
1063       { 0x10003, "exif:GPSLongitudeRef" },
1064       { 0x10004, "exif:GPSLongitude" },
1065       { 0x10005, "exif:GPSAltitudeRef" },
1066       { 0x10006, "exif:GPSAltitude" },
1067       { 0x10007, "exif:GPSTimeStamp" },
1068       { 0x10008, "exif:GPSSatellites" },
1069       { 0x10009, "exif:GPSStatus" },
1070       { 0x1000a, "exif:GPSMeasureMode" },
1071       { 0x1000b, "exif:GPSDop" },
1072       { 0x1000c, "exif:GPSSpeedRef" },
1073       { 0x1000d, "exif:GPSSpeed" },
1074       { 0x1000e, "exif:GPSTrackRef" },
1075       { 0x1000f, "exif:GPSTrack" },
1076       { 0x10010, "exif:GPSImgDirectionRef" },
1077       { 0x10011, "exif:GPSImgDirection" },
1078       { 0x10012, "exif:GPSMapDatum" },
1079       { 0x10013, "exif:GPSDestLatitudeRef" },
1080       { 0x10014, "exif:GPSDestLatitude" },
1081       { 0x10015, "exif:GPSDestLongitudeRef" },
1082       { 0x10016, "exif:GPSDestLongitude" },
1083       { 0x10017, "exif:GPSDestBearingRef" },
1084       { 0x10018, "exif:GPSDestBearing" },
1085       { 0x10019, "exif:GPSDestDistanceRef" },
1086       { 0x1001a, "exif:GPSDestDistance" },
1087       { 0x1001b, "exif:GPSProcessingMethod" },
1088       { 0x1001c, "exif:GPSAreaInformation" },
1089       { 0x1001d, "exif:GPSDateStamp" },
1090       { 0x1001e, "exif:GPSDifferential" },
1091       {  0x0000, NULL}
1092     };
1093
1094   const StringInfo
1095     *profile;
1096
1097   const unsigned char
1098     *directory,
1099     *exif;
1100
1101   DirectoryInfo
1102     directory_stack[MaxDirectoryStack];
1103
1104   EndianType
1105     endian;
1106
1107   MagickBooleanType
1108     status;
1109
1110   register ssize_t
1111     i;
1112
1113   size_t
1114     entry,
1115     length,
1116     number_entries,
1117     tag;
1118
1119   SplayTreeInfo
1120     *exif_resources;
1121
1122   ssize_t
1123     all,
1124     id,
1125     level,
1126     offset,
1127     tag_offset,
1128     tag_value;
1129
1130   static int
1131     tag_bytes[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
1132
1133   /*
1134     If EXIF data exists, then try to parse the request for a tag.
1135   */
1136   profile=GetImageProfile(image,"exif");
1137   if (profile == (StringInfo *) NULL)
1138     return(MagickFalse);
1139   if ((property == (const char *) NULL) || (*property == '\0'))
1140     return(MagickFalse);
1141   while (isspace((int) ((unsigned char) *property)) != 0)
1142     property++;
1143   all=0;
1144   tag=(~0UL);
1145   switch (*(property+5))
1146   {
1147     case '*':
1148     {
1149       /*
1150         Caller has asked for all the tags in the EXIF data.
1151       */
1152       tag=0;
1153       all=1; /* return the data in description=value format */
1154       break;
1155     }
1156     case '!':
1157     {
1158       tag=0;
1159       all=2; /* return the data in tagid=value format */
1160       break;
1161     }
1162     case '#':
1163     case '@':
1164     {
1165       int
1166         c;
1167
1168       size_t
1169         n;
1170
1171       /*
1172         Check for a hex based tag specification first.
1173       */
1174       tag=(*(property+5) == '@') ? 1UL : 0UL;
1175       property+=6;
1176       n=strlen(property);
1177       if (n != 4)
1178         return(MagickFalse);
1179       /*
1180         Parse tag specification as a hex number.
1181       */
1182       n/=4;
1183       do
1184       {
1185         for (i=(ssize_t) n-1L; i >= 0; i--)
1186         {
1187           c=(*property++);
1188           tag<<=4;
1189           if ((c >= '0') && (c <= '9'))
1190             tag|=(c-'0');
1191           else
1192             if ((c >= 'A') && (c <= 'F'))
1193               tag|=(c-('A'-10));
1194             else
1195               if ((c >= 'a') && (c <= 'f'))
1196                 tag|=(c-('a'-10));
1197               else
1198                 return(MagickFalse);
1199         }
1200       } while (*property != '\0');
1201       break;
1202     }
1203     default:
1204     {
1205       /*
1206         Try to match the text with a tag name instead.
1207       */
1208       for (i=0; ; i++)
1209       {
1210         if (EXIFTag[i].tag == 0)
1211           break;
1212         if (LocaleCompare(EXIFTag[i].description,property) == 0)
1213           {
1214             tag=(size_t) EXIFTag[i].tag;
1215             break;
1216           }
1217       }
1218       break;
1219     }
1220   }
1221   if (tag == (~0UL))
1222     return(MagickFalse);
1223   length=GetStringInfoLength(profile);
1224   exif=GetStringInfoDatum(profile);
1225   while (length != 0)
1226   {
1227     if (ReadPropertyByte(&exif,&length) != 0x45)
1228       continue;
1229     if (ReadPropertyByte(&exif,&length) != 0x78)
1230       continue;
1231     if (ReadPropertyByte(&exif,&length) != 0x69)
1232       continue;
1233     if (ReadPropertyByte(&exif,&length) != 0x66)
1234       continue;
1235     if (ReadPropertyByte(&exif,&length) != 0x00)
1236       continue;
1237     if (ReadPropertyByte(&exif,&length) != 0x00)
1238       continue;
1239     break;
1240   }
1241   if (length < 16)
1242     return(MagickFalse);
1243   id=(ssize_t) ((int) ReadPropertyShort(LSBEndian,exif));
1244   endian=LSBEndian;
1245   if (id == 0x4949)
1246     endian=LSBEndian;
1247   else
1248     if (id == 0x4D4D)
1249       endian=MSBEndian;
1250     else
1251       return(MagickFalse);
1252   if (ReadPropertyShort(endian,exif+2) != 0x002a)
1253     return(MagickFalse);
1254   /*
1255     This the offset to the first IFD.
1256   */
1257   offset=(ssize_t) ((int) ReadPropertyLong(endian,exif+4));
1258   if ((offset < 0) || (size_t) offset >= length)
1259     return(MagickFalse);
1260   /*
1261     Set the pointer to the first IFD and follow it were it leads.
1262   */
1263   status=MagickFalse;
1264   directory=exif+offset;
1265   level=0;
1266   entry=0;
1267   tag_offset=0;
1268   exif_resources=NewSplayTree((int (*)(const void *,const void *)) NULL,
1269     (void *(*)(void *)) NULL,(void *(*)(void *)) NULL);
1270   do
1271   {
1272     /*
1273       If there is anything on the stack then pop it off.
1274     */
1275     if (level > 0)
1276       {
1277         level--;
1278         directory=directory_stack[level].directory;
1279         entry=directory_stack[level].entry;
1280         tag_offset=directory_stack[level].offset;
1281       }
1282     /*
1283       Determine how many entries there are in the current IFD.
1284     */
1285     number_entries=(size_t) ((int) ReadPropertyShort(endian,directory));
1286     for ( ; entry < number_entries; entry++)
1287     {
1288       register unsigned char
1289         *p,
1290         *q;
1291
1292       size_t
1293         format,
1294         number_bytes;
1295
1296       ssize_t
1297         components;
1298
1299       q=(unsigned char *) (directory+(12*entry)+2);
1300       if (GetValueFromSplayTree(exif_resources,q) == q)
1301         break;
1302       (void) AddValueToSplayTree(exif_resources,q,q);
1303       tag_value=(ssize_t) ((int) ReadPropertyShort(endian,q)+tag_offset);
1304       format=(size_t) ((int) ReadPropertyShort(endian,q+2));
1305       if (format >= (sizeof(tag_bytes)/sizeof(*tag_bytes)))
1306         break;
1307       components=(ssize_t) ((int) ReadPropertyLong(endian,q+4));
1308       number_bytes=(size_t) components*tag_bytes[format];
1309       if (number_bytes < components)
1310         break;  /* prevent overflow */
1311       if (number_bytes <= 4)
1312         p=q+8;
1313       else
1314         {
1315           ssize_t
1316             offset;
1317
1318           /*
1319             The directory entry contains an offset.
1320           */
1321           offset=(ssize_t) ((int) ReadPropertyLong(endian,q+8));
1322           if ((size_t) (offset+number_bytes) > length)
1323             continue;
1324           if (~length < number_bytes)
1325             continue;  /* prevent overflow */
1326           p=(unsigned char *) (exif+offset);
1327         }
1328       if ((all != 0) || (tag == (size_t) tag_value))
1329         {
1330           char
1331             buffer[MaxTextExtent],
1332             *value;
1333
1334           value=(char *) NULL;
1335           *buffer='\0';
1336           switch (format)
1337           {
1338             case EXIF_FMT_BYTE:
1339             case EXIF_FMT_UNDEFINED:
1340             {
1341               EXIFMultipleValues(1,"%.20g",(double) (*(unsigned char *) p1));
1342               break;
1343             }
1344             case EXIF_FMT_SBYTE:
1345             {
1346               EXIFMultipleValues(1,"%.20g",(double) (*(signed char *) p1));
1347               break;
1348             }
1349             case EXIF_FMT_SSHORT:
1350             {
1351               EXIFMultipleValues(2,"%hd",ReadPropertyShort(endian,p1));
1352               break;
1353             }
1354             case EXIF_FMT_USHORT:
1355             {
1356               EXIFMultipleValues(2,"%hu",ReadPropertyShort(endian,p1));
1357               break;
1358             }
1359             case EXIF_FMT_ULONG:
1360             {
1361               EXIFMultipleValues(4,"%.20g",(double)
1362                 ((int) ReadPropertyLong(endian,p1)));
1363               break;
1364             }
1365             case EXIF_FMT_SLONG:
1366             {
1367               EXIFMultipleValues(4,"%.20g",(double)
1368                 ((int) ReadPropertyLong(endian,p1)));
1369               break;
1370             }
1371             case EXIF_FMT_URATIONAL:
1372             {
1373               EXIFMultipleFractions(8,"%.20g/%.20g",(double)
1374                 ((int) ReadPropertyLong(endian,p1)),(double)
1375                 ((int) ReadPropertyLong(endian,p1+4)));
1376               break;
1377             }
1378             case EXIF_FMT_SRATIONAL:
1379             {
1380               EXIFMultipleFractions(8,"%.20g/%.20g",(double)
1381                 ((int) ReadPropertyLong(endian,p1)),(double)
1382                 ((int) ReadPropertyLong(endian,p1+4)));
1383               break;
1384             }
1385             case EXIF_FMT_SINGLE:
1386             {
1387               EXIFMultipleValues(4,"%f",(double) *(float *) p1);
1388               break;
1389             }
1390             case EXIF_FMT_DOUBLE:
1391             {
1392               EXIFMultipleValues(8,"%f",*(double *) p1);
1393               break;
1394             }
1395             default:
1396             case EXIF_FMT_STRING:
1397             {
1398               value=(char *) NULL;
1399               if (~(1UL*number_bytes) >= 1)
1400                 value=(char *) AcquireQuantumMemory((size_t) number_bytes+1UL,
1401                   sizeof(*value));
1402               if (value != (char *) NULL)
1403                 {
1404                   register ssize_t
1405                     i;
1406
1407                   for (i=0; i < (ssize_t) number_bytes; i++)
1408                   {
1409                     value[i]='.';
1410                     if ((isprint((int) p[i]) != 0) || (p[i] == '\0'))
1411                       value[i]=(char) p[i];
1412                   }
1413                   value[i]='\0';
1414                 }
1415               break;
1416             }
1417           }
1418           if (value != (char *) NULL)
1419             {
1420               char
1421                 key[MaxTextExtent];
1422
1423               register const char
1424                 *p;
1425
1426               (void) CopyMagickString(key,property,MaxTextExtent);
1427               switch (all)
1428               {
1429                 case 1:
1430                 {
1431                   const char
1432                     *description;
1433
1434                   register ssize_t
1435                     i;
1436
1437                   description="unknown";
1438                   for (i=0; ; i++)
1439                   {
1440                     if (EXIFTag[i].tag == 0)
1441                       break;
1442                     if ((ssize_t) EXIFTag[i].tag == tag_value)
1443                       {
1444                         description=EXIFTag[i].description;
1445                         break;
1446                       }
1447                   }
1448                   (void) FormatLocaleString(key,MaxTextExtent,"%s",description);
1449                   break;
1450                 }
1451                 case 2:
1452                 {
1453                   if (tag_value < 0x10000)
1454                     (void) FormatLocaleString(key,MaxTextExtent,"#%04lx",
1455                       (unsigned long) tag_value);
1456                   else
1457                     if (tag_value < 0x20000)
1458                       (void) FormatLocaleString(key,MaxTextExtent,"@%04lx",
1459                         (unsigned long) (tag_value & 0xffff));
1460                     else
1461                       (void) FormatLocaleString(key,MaxTextExtent,"unknown");
1462                   break;
1463                 }
1464               }
1465               p=(const char *) NULL;
1466               if (image->properties != (void *) NULL)
1467                 p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
1468                   image->properties,key);
1469               if (p == (const char *) NULL)
1470                 (void) SetImageProperty((Image *) image,key,value,exception);
1471               value=DestroyString(value);
1472               status=MagickTrue;
1473             }
1474         }
1475         if ((tag_value == TAG_EXIF_OFFSET) ||
1476             (tag_value == TAG_INTEROP_OFFSET) || (tag_value == TAG_GPS_OFFSET))
1477           {
1478             ssize_t
1479               offset;
1480
1481             offset=(ssize_t) ((int) ReadPropertyLong(endian,p));
1482             if (((size_t) offset < length) && (level < (MaxDirectoryStack-2)))
1483               {
1484                 ssize_t
1485                   tag_offset1;
1486
1487                 tag_offset1=(ssize_t) ((tag_value == TAG_GPS_OFFSET) ? 0x10000 :
1488                   0);
1489                 directory_stack[level].directory=directory;
1490                 entry++;
1491                 directory_stack[level].entry=entry;
1492                 directory_stack[level].offset=tag_offset;
1493                 level++;
1494                 directory_stack[level].directory=exif+offset;
1495                 directory_stack[level].offset=tag_offset1;
1496                 directory_stack[level].entry=0;
1497                 level++;
1498                 if ((directory+2+(12*number_entries)) > (exif+length))
1499                   break;
1500                 offset=(ssize_t) ((int) ReadPropertyLong(endian,directory+2+(12*
1501                   number_entries)));
1502                 if ((offset != 0) && ((size_t) offset < length) &&
1503                     (level < (MaxDirectoryStack-2)))
1504                   {
1505                     directory_stack[level].directory=exif+offset;
1506                     directory_stack[level].entry=0;
1507                     directory_stack[level].offset=tag_offset1;
1508                     level++;
1509                   }
1510               }
1511             break;
1512           }
1513     }
1514   } while (level > 0);
1515   exif_resources=DestroySplayTree(exif_resources);
1516   return(status);
1517 }
1518
1519 static MagickBooleanType GetXMPProperty(const Image *image,const char *property)
1520 {
1521   char
1522     *xmp_profile;
1523
1524   const StringInfo
1525     *profile;
1526
1527   ExceptionInfo
1528     *exception;
1529
1530   MagickBooleanType
1531     status;
1532
1533   register const char
1534     *p;
1535
1536   XMLTreeInfo
1537     *child,
1538     *description,
1539     *node,
1540     *rdf,
1541     *xmp;
1542
1543   profile=GetImageProfile(image,"xmp");
1544   if (profile == (StringInfo *) NULL)
1545     return(MagickFalse);
1546   if ((property == (const char *) NULL) || (*property == '\0'))
1547     return(MagickFalse);
1548   xmp_profile=StringInfoToString(profile);
1549   if (xmp_profile == (char *) NULL)
1550     return(MagickFalse);
1551   for (p=xmp_profile; *p != '\0'; p++)
1552     if ((*p == '<') && (*(p+1) == 'x'))
1553       break;
1554   exception=AcquireExceptionInfo();
1555   xmp=NewXMLTree((char *) p,exception);
1556   xmp_profile=DestroyString(xmp_profile);
1557   exception=DestroyExceptionInfo(exception);
1558   if (xmp == (XMLTreeInfo *) NULL)
1559     return(MagickFalse);
1560   status=MagickFalse;
1561   rdf=GetXMLTreeChild(xmp,"rdf:RDF");
1562   if (rdf != (XMLTreeInfo *) NULL)
1563     {
1564       if (image->properties == (void *) NULL)
1565         ((Image *) image)->properties=NewSplayTree(CompareSplayTreeString,
1566           RelinquishMagickMemory,RelinquishMagickMemory);
1567       description=GetXMLTreeChild(rdf,"rdf:Description");
1568       while (description != (XMLTreeInfo *) NULL)
1569       {
1570         node=GetXMLTreeChild(description,(const char *) NULL);
1571         while (node != (XMLTreeInfo *) NULL)
1572         {
1573           child=GetXMLTreeChild(node,(const char *) NULL);
1574           if (child == (XMLTreeInfo *) NULL)
1575             (void) AddValueToSplayTree((SplayTreeInfo *) image->properties,
1576               ConstantString(GetXMLTreeTag(node)),
1577               ConstantString(GetXMLTreeContent(node)));
1578           while (child != (XMLTreeInfo *) NULL)
1579           {
1580             if (LocaleCompare(GetXMLTreeTag(child),"rdf:Seq") != 0)
1581               (void) AddValueToSplayTree((SplayTreeInfo *) image->properties,
1582                 ConstantString(GetXMLTreeTag(child)),
1583                 ConstantString(GetXMLTreeContent(child)));
1584             child=GetXMLTreeSibling(child);
1585           }
1586           node=GetXMLTreeSibling(node);
1587         }
1588         description=GetNextXMLTreeTag(description);
1589       }
1590     }
1591   xmp=DestroyXMLTree(xmp);
1592   return(status);
1593 }
1594
1595 static char *TracePSClippath(const unsigned char *blob,size_t length,
1596   const size_t magick_unused(columns),const size_t magick_unused(rows))
1597 {
1598   char
1599     *path,
1600     *message;
1601
1602   MagickBooleanType
1603     in_subpath;
1604
1605   PointInfo
1606     first[3],
1607     last[3],
1608     point[3];
1609
1610   register ssize_t
1611     i,
1612     x;
1613
1614   ssize_t
1615     knot_count,
1616     selector,
1617     y;
1618
1619   path=AcquireString((char *) NULL);
1620   if (path == (char *) NULL)
1621     return((char *) NULL);
1622   message=AcquireString((char *) NULL);
1623   (void) FormatLocaleString(message,MaxTextExtent,"/ClipImage\n");
1624   (void) ConcatenateString(&path,message);
1625   (void) FormatLocaleString(message,MaxTextExtent,"{\n");
1626   (void) ConcatenateString(&path,message);
1627   (void) FormatLocaleString(message,MaxTextExtent,"  /c {curveto} bind def\n");
1628   (void) ConcatenateString(&path,message);
1629   (void) FormatLocaleString(message,MaxTextExtent,"  /l {lineto} bind def\n");
1630   (void) ConcatenateString(&path,message);
1631   (void) FormatLocaleString(message,MaxTextExtent,"  /m {moveto} bind def\n");
1632   (void) ConcatenateString(&path,message);
1633   (void) FormatLocaleString(message,MaxTextExtent,
1634     "  /v {currentpoint 6 2 roll curveto} bind def\n");
1635   (void) ConcatenateString(&path,message);
1636   (void) FormatLocaleString(message,MaxTextExtent,
1637     "  /y {2 copy curveto} bind def\n");
1638   (void) ConcatenateString(&path,message);
1639   (void) FormatLocaleString(message,MaxTextExtent,
1640     "  /z {closepath} bind def\n");
1641   (void) ConcatenateString(&path,message);
1642   (void) FormatLocaleString(message,MaxTextExtent,"  newpath\n");
1643   (void) ConcatenateString(&path,message);
1644   /*
1645     The clipping path format is defined in "Adobe Photoshop File
1646     Formats Specification" version 6.0 downloadable from adobe.com.
1647   */
1648   (void) ResetMagickMemory(point,0,sizeof(point));
1649   (void) ResetMagickMemory(first,0,sizeof(first));
1650   (void) ResetMagickMemory(last,0,sizeof(last));
1651   knot_count=0;
1652   in_subpath=MagickFalse;
1653   while (length > 0)
1654   {
1655     selector=(ssize_t) ((int) ReadPropertyMSBShort(&blob,&length));
1656     switch (selector)
1657     {
1658       case 0:
1659       case 3:
1660       {
1661         if (knot_count != 0)
1662           {
1663             blob+=24;
1664             length-=MagickMin(24,(ssize_t) length);
1665             break;
1666           }
1667         /*
1668           Expected subpath length record.
1669         */
1670         knot_count=(ssize_t) ((int) ReadPropertyMSBShort(&blob,&length));
1671         blob+=22;
1672         length-=MagickMin(22,(ssize_t) length);
1673         break;
1674       }
1675       case 1:
1676       case 2:
1677       case 4:
1678       case 5:
1679       {
1680         if (knot_count == 0)
1681           {
1682             /*
1683               Unexpected subpath knot
1684             */
1685             blob+=24;
1686             length-=MagickMin(24,(ssize_t) length);
1687             break;
1688           }
1689         /*
1690           Add sub-path knot
1691         */
1692         for (i=0; i < 3; i++)
1693         {
1694           size_t
1695             xx,
1696             yy;
1697
1698           yy=(size_t) ((int) ReadPropertyMSBLong(&blob,&length));
1699           xx=(size_t) ((int) ReadPropertyMSBLong(&blob,&length));
1700           x=(ssize_t) xx;
1701           if (xx > 2147483647)
1702             x=(ssize_t) xx-4294967295U-1;
1703           y=(ssize_t) yy;
1704           if (yy > 2147483647)
1705             y=(ssize_t) yy-4294967295U-1;
1706           point[i].x=(double) x/4096/4096;
1707           point[i].y=1.0-(double) y/4096/4096;
1708         }
1709         if (in_subpath == MagickFalse)
1710           {
1711             (void) FormatLocaleString(message,MaxTextExtent,"  %g %g m\n",
1712               point[1].x,point[1].y);
1713             for (i=0; i < 3; i++)
1714             {
1715               first[i]=point[i];
1716               last[i]=point[i];
1717             }
1718           }
1719         else
1720           {
1721             /*
1722               Handle special cases when Bezier curves are used to describe
1723               corners and straight lines.
1724             */
1725             if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
1726                 (point[0].x == point[1].x) && (point[0].y == point[1].y))
1727               (void) FormatLocaleString(message,MaxTextExtent,
1728                 "  %g %g l\n",point[1].x,point[1].y);
1729             else
1730               if ((last[1].x == last[2].x) && (last[1].y == last[2].y))
1731                 (void) FormatLocaleString(message,MaxTextExtent,
1732                   "  %g %g %g %g v\n",point[0].x,point[0].y,
1733                   point[1].x,point[1].y);
1734               else
1735                 if ((point[0].x == point[1].x) && (point[0].y == point[1].y))
1736                   (void) FormatLocaleString(message,MaxTextExtent,
1737                     "  %g %g %g %g y\n",last[2].x,last[2].y,
1738                     point[1].x,point[1].y);
1739                 else
1740                   (void) FormatLocaleString(message,MaxTextExtent,
1741                     "  %g %g %g %g %g %g c\n",last[2].x,
1742                     last[2].y,point[0].x,point[0].y,point[1].x,point[1].y);
1743             for (i=0; i < 3; i++)
1744               last[i]=point[i];
1745           }
1746         (void) ConcatenateString(&path,message);
1747         in_subpath=MagickTrue;
1748         knot_count--;
1749         /*
1750           Close the subpath if there are no more knots.
1751         */
1752         if (knot_count == 0)
1753           {
1754             /*
1755               Same special handling as above except we compare to the
1756               first point in the path and close the path.
1757             */
1758             if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
1759                 (first[0].x == first[1].x) && (first[0].y == first[1].y))
1760               (void) FormatLocaleString(message,MaxTextExtent,
1761                 "  %g %g l z\n",first[1].x,first[1].y);
1762             else
1763               if ((last[1].x == last[2].x) && (last[1].y == last[2].y))
1764                 (void) FormatLocaleString(message,MaxTextExtent,
1765                   "  %g %g %g %g v z\n",first[0].x,first[0].y,
1766                   first[1].x,first[1].y);
1767               else
1768                 if ((first[0].x == first[1].x) && (first[0].y == first[1].y))
1769                   (void) FormatLocaleString(message,MaxTextExtent,
1770                     "  %g %g %g %g y z\n",last[2].x,last[2].y,
1771                     first[1].x,first[1].y);
1772                 else
1773                   (void) FormatLocaleString(message,MaxTextExtent,
1774                     "  %g %g %g %g %g %g c z\n",last[2].x,
1775                     last[2].y,first[0].x,first[0].y,first[1].x,first[1].y);
1776             (void) ConcatenateString(&path,message);
1777             in_subpath=MagickFalse;
1778           }
1779         break;
1780       }
1781       case 6:
1782       case 7:
1783       case 8:
1784       default:
1785       {
1786         blob+=24;
1787         length-=MagickMin(24,(ssize_t) length);
1788         break;
1789       }
1790     }
1791   }
1792   /*
1793     Returns an empty PS path if the path has no knots.
1794   */
1795   (void) FormatLocaleString(message,MaxTextExtent,"  eoclip\n");
1796   (void) ConcatenateString(&path,message);
1797   (void) FormatLocaleString(message,MaxTextExtent,"} bind def");
1798   (void) ConcatenateString(&path,message);
1799   message=DestroyString(message);
1800   return(path);
1801 }
1802
1803 static char *TraceSVGClippath(const unsigned char *blob,size_t length,
1804   const size_t columns,const size_t rows)
1805 {
1806   char
1807     *path,
1808     *message;
1809
1810   MagickBooleanType
1811     in_subpath;
1812
1813   PointInfo
1814     first[3],
1815     last[3],
1816     point[3];
1817
1818   register ssize_t
1819     i;
1820
1821   ssize_t
1822     knot_count,
1823     selector,
1824     x,
1825     y;
1826
1827   path=AcquireString((char *) NULL);
1828   if (path == (char *) NULL)
1829     return((char *) NULL);
1830   message=AcquireString((char *) NULL);
1831   (void) FormatLocaleString(message,MaxTextExtent,
1832     "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n");
1833   (void) ConcatenateString(&path,message);
1834   (void) FormatLocaleString(message,MaxTextExtent,
1835     "<svg width=\"%.20g\" height=\"%.20g\">\n",(double) columns,(double) rows);
1836   (void) ConcatenateString(&path,message);
1837   (void) FormatLocaleString(message,MaxTextExtent,"<g>\n");
1838   (void) ConcatenateString(&path,message);
1839   (void) FormatLocaleString(message,MaxTextExtent,
1840     "<path style=\"fill:#00000000;stroke:#00000000;");
1841   (void) ConcatenateString(&path,message);
1842   (void) FormatLocaleString(message,MaxTextExtent,
1843     "stroke-width:0;stroke-antialiasing:false\" d=\"\n");
1844   (void) ConcatenateString(&path,message);
1845   (void) ResetMagickMemory(point,0,sizeof(point));
1846   (void) ResetMagickMemory(first,0,sizeof(first));
1847   (void) ResetMagickMemory(last,0,sizeof(last));
1848   knot_count=0;
1849   in_subpath=MagickFalse;
1850   while (length != 0)
1851   {
1852     selector=(ssize_t) ((int) ReadPropertyMSBShort(&blob,&length));
1853     switch (selector)
1854     {
1855       case 0:
1856       case 3:
1857       {
1858         if (knot_count != 0)
1859           {
1860             blob+=24;
1861             length-=MagickMin(24,(ssize_t) length);
1862             break;
1863           }
1864         /*
1865           Expected subpath length record.
1866         */
1867         knot_count=(ssize_t) ((int) ReadPropertyMSBShort(&blob,&length));
1868         blob+=22;
1869         length-=MagickMin(22,(ssize_t) length);
1870         break;
1871       }
1872       case 1:
1873       case 2:
1874       case 4:
1875       case 5:
1876       {
1877         if (knot_count == 0)
1878           {
1879             /*
1880               Unexpected subpath knot.
1881             */
1882             blob+=24;
1883             length-=MagickMin(24,(ssize_t) length);
1884             break;
1885           }
1886         /*
1887           Add sub-path knot
1888         */
1889         for (i=0; i < 3; i++)
1890         {
1891           size_t
1892             xx,
1893             yy;
1894
1895           yy=(size_t) ((int) ReadPropertyMSBLong(&blob,&length));
1896           xx=(size_t) ((int) ReadPropertyMSBLong(&blob,&length));
1897           x=(ssize_t) xx;
1898           if (xx > 2147483647)
1899             x=(ssize_t) xx-4294967295U-1;
1900           y=(ssize_t) yy;
1901           if (yy > 2147483647)
1902             y=(ssize_t) yy-4294967295U-1;
1903           point[i].x=(double) x*columns/4096/4096;
1904           point[i].y=(double) y*rows/4096/4096;
1905         }
1906         if (in_subpath == MagickFalse)
1907           {
1908             (void) FormatLocaleString(message,MaxTextExtent,"M %g,%g\n",
1909               point[1].x,point[1].y);
1910             for (i=0; i < 3; i++)
1911             {
1912               first[i]=point[i];
1913               last[i]=point[i];
1914             }
1915           }
1916         else
1917           {
1918             if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
1919                 (point[0].x == point[1].x) && (point[0].y == point[1].y))
1920               (void) FormatLocaleString(message,MaxTextExtent,"L %g,%g\n",
1921                 point[1].x,point[1].y);
1922             else
1923               (void) FormatLocaleString(message,MaxTextExtent,
1924                 "C %g,%g %g,%g %g,%g\n",last[2].x,last[2].y,
1925                 point[0].x,point[0].y,point[1].x,point[1].y);
1926             for (i=0; i < 3; i++)
1927               last[i]=point[i];
1928           }
1929         (void) ConcatenateString(&path,message);
1930         in_subpath=MagickTrue;
1931         knot_count--;
1932         /*
1933           Close the subpath if there are no more knots.
1934         */
1935         if (knot_count == 0)
1936           {
1937             if ((last[1].x == last[2].x) && (last[1].y == last[2].y) &&
1938                 (first[0].x == first[1].x) && (first[0].y == first[1].y))
1939               (void) FormatLocaleString(message,MaxTextExtent,
1940                 "L %g,%g Z\n",first[1].x,first[1].y);
1941             else
1942               {
1943                 (void) FormatLocaleString(message,MaxTextExtent,
1944                   "C %g,%g %g,%g %g,%g Z\n",last[2].x,
1945                   last[2].y,first[0].x,first[0].y,first[1].x,first[1].y);
1946                 (void) ConcatenateString(&path,message);
1947               }
1948             in_subpath=MagickFalse;
1949           }
1950         break;
1951       }
1952       case 6:
1953       case 7:
1954       case 8:
1955       default:
1956       {
1957         blob+=24;
1958         length-=MagickMin(24,(ssize_t) length);
1959         break;
1960       }
1961     }
1962   }
1963   /*
1964     Return an empty SVG image if the path does not have knots.
1965   */
1966   (void) FormatLocaleString(message,MaxTextExtent,"\"/>\n");
1967   (void) ConcatenateString(&path,message);
1968   (void) FormatLocaleString(message,MaxTextExtent,"</g>\n");
1969   (void) ConcatenateString(&path,message);
1970   (void) FormatLocaleString(message,MaxTextExtent,"</svg>\n");
1971   (void) ConcatenateString(&path,message);
1972   message=DestroyString(message);
1973   return(path);
1974 }
1975
1976 MagickExport const char *GetImageProperty(const Image *image,
1977   const char *property,ExceptionInfo *exception)
1978 {
1979   FxInfo
1980     *fx_info;
1981
1982   MagickRealType
1983     alpha;
1984
1985   MagickStatusType
1986     status;
1987
1988   register const char
1989     *p;
1990
1991   assert(image != (Image *) NULL);
1992   assert(image->signature == MagickSignature);
1993   if (image->debug != MagickFalse)
1994     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1995   p=(const char *) NULL;
1996   if (image->properties != (void *) NULL)
1997     {
1998       if (property == (const char *) NULL)
1999         {
2000           ResetSplayTreeIterator((SplayTreeInfo *) image->properties);
2001           p=(const char *) GetNextValueInSplayTree((SplayTreeInfo *)
2002             image->properties);
2003           return(p);
2004         }
2005       if (LocaleNCompare("fx:",property,3) != 0)
2006         {
2007           p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2008             image->properties,property);
2009           if (p != (const char *) NULL)
2010             return(p);
2011         }
2012     }
2013   if ((property == (const char *) NULL) ||
2014       (strchr(property,':') == (char *) NULL))
2015     return(p);
2016   switch (*property)
2017   {
2018     case '8':
2019     {
2020       if (LocaleNCompare("8bim:",property,5) == 0)
2021         {
2022           if ((Get8BIMProperty(image,property,exception) != MagickFalse) &&
2023               (image->properties != (void *) NULL))
2024             {
2025               p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2026                 image->properties,property);
2027               return(p);
2028             }
2029         }
2030       break;
2031     }
2032     case 'E':
2033     case 'e':
2034     {
2035       if (LocaleNCompare("exif:",property,5) == 0)
2036         {
2037           if ((GetEXIFProperty(image,property,exception) != MagickFalse) &&
2038               (image->properties != (void *) NULL))
2039             {
2040               p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2041                 image->properties,property);
2042               return(p);
2043             }
2044         }
2045       break;
2046     }
2047     case 'F':
2048     case 'f':
2049     {
2050       if (LocaleNCompare("fx:",property,3) == 0)
2051         {
2052           fx_info=AcquireFxInfo(image,property+3,exception);
2053           status=FxEvaluateChannelExpression(fx_info,IntensityPixelChannel,0,0,
2054             &alpha,exception);
2055           fx_info=DestroyFxInfo(fx_info);
2056           if (status != MagickFalse)
2057             {
2058               char
2059                 value[MaxTextExtent];
2060
2061               (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2062                 GetMagickPrecision(),(double) alpha);
2063               (void) SetImageProperty((Image *) image,property,value,exception);
2064             }
2065           if (image->properties != (void *) NULL)
2066             {
2067               p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2068                 image->properties,property);
2069               return(p);
2070             }
2071         }
2072       break;
2073     }
2074     case 'I':
2075     case 'i':
2076     {
2077       if (LocaleNCompare("iptc:",property,5) == 0)
2078         {
2079           if ((GetIPTCProperty(image,property,exception) != MagickFalse) &&
2080               (image->properties != (void *) NULL))
2081             {
2082               p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2083                 image->properties,property);
2084               return(p);
2085             }
2086         }
2087       break;
2088     }
2089     case 'P':
2090     case 'p':
2091     {
2092       if (LocaleNCompare("pixel:",property,6) == 0)
2093         {
2094           PixelInfo
2095             pixel;
2096
2097           GetPixelInfo(image,&pixel);
2098           fx_info=AcquireFxInfo(image,property+6,exception);
2099           status=FxEvaluateChannelExpression(fx_info,RedPixelChannel,0,0,
2100             &alpha,exception);
2101           pixel.red=(MagickRealType) QuantumRange*alpha;
2102           status|=FxEvaluateChannelExpression(fx_info,GreenPixelChannel,0,0,
2103             &alpha,exception);
2104           pixel.green=(MagickRealType) QuantumRange*alpha;
2105           status|=FxEvaluateChannelExpression(fx_info,BluePixelChannel,0,0,
2106             &alpha,exception);
2107           pixel.blue=(MagickRealType) QuantumRange*alpha;
2108           if (image->colorspace == CMYKColorspace)
2109             {
2110               status|=FxEvaluateChannelExpression(fx_info,BlackPixelChannel,0,0,
2111                 &alpha,exception);
2112               pixel.black=(MagickRealType) QuantumRange*alpha;
2113             }
2114           status|=FxEvaluateChannelExpression(fx_info,AlphaPixelChannel,0,0,
2115             &alpha,exception);
2116           pixel.alpha=(MagickRealType) QuantumRange*(1.0-alpha);
2117           fx_info=DestroyFxInfo(fx_info);
2118           if (status != MagickFalse)
2119             {
2120               char
2121                 name[MaxTextExtent];
2122
2123               (void) QueryColorname(image,&pixel,SVGCompliance,name,
2124                 exception);
2125               (void) SetImageProperty((Image *) image,property,name,exception);
2126               return(GetImageProperty(image,property,exception));
2127             }
2128         }
2129       break;
2130     }
2131     case 'X':
2132     case 'x':
2133     {
2134       if (LocaleNCompare("xmp:",property,4) == 0)
2135         {
2136           if ((GetXMPProperty(image,property) != MagickFalse) &&
2137               (image->properties != (void *) NULL))
2138             {
2139               p=(const char *) GetValueFromSplayTree((SplayTreeInfo *)
2140                 image->properties,property);
2141               return(p);
2142             }
2143         }
2144       break;
2145     }
2146     default:
2147       break;
2148   }
2149   return(p);
2150 }
2151 \f
2152 /*
2153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2154 %                                                                             %
2155 %                                                                             %
2156 %                                                                             %
2157 +   G e t M a g i c k P r o p e r t y                                         %
2158 %                                                                             %
2159 %                                                                             %
2160 %                                                                             %
2161 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2162 %
2163 %  GetMagickProperty() gets a value associated with an image property.
2164 %
2165 %  The format of the GetMagickProperty method is:
2166 %
2167 %      const char *GetMagickProperty(const ImageInfo *image_info,Image *image,
2168 %        const char *key,ExceptionInfo *exception)
2169 %
2170 %  A description of each parameter follows:
2171 %
2172 %    o image_info: the image info.
2173 %
2174 %    o image: the image.
2175 %
2176 %    o key: the key.
2177 %
2178 %    o exception: return any errors or warnings in this structure.
2179 %
2180 */
2181 MagickExport const char *GetMagickProperty(const ImageInfo *image_info,
2182   Image *image,const char *property,ExceptionInfo *exception)
2183 {
2184   char
2185     value[MaxTextExtent],
2186     filename[MaxTextExtent];
2187
2188   *value='\0';
2189   switch (*property)
2190   {
2191     case 'b':
2192     {
2193       if (LocaleNCompare("base",property,4) == 0)
2194         {
2195           GetPathComponent(image->magick_filename,BasePath,filename);
2196           (void) CopyMagickString(value,filename,MaxTextExtent);
2197           break;
2198         }
2199       break;
2200     }
2201     case 'c':
2202     {
2203       if (LocaleNCompare("channels",property,8) == 0)
2204         {
2205           /*
2206             Image channels.
2207           */
2208           (void) FormatLocaleString(value,MaxTextExtent,"%s",
2209             CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
2210             image->colorspace));
2211           LocaleLower(value);
2212           if (image->matte != MagickFalse)
2213             (void) ConcatenateMagickString(value,"a",MaxTextExtent);
2214           break;
2215         }
2216       if (LocaleNCompare("colorspace",property,10) == 0)
2217         {
2218           ColorspaceType
2219             colorspace;
2220
2221           /*
2222             Image storage class and colorspace.
2223           */
2224           colorspace=image->colorspace;
2225           if (IsImageGray(image,exception) != MagickFalse)
2226             colorspace=GRAYColorspace;
2227           (void) FormatLocaleString(value,MaxTextExtent,"%s",
2228             CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
2229             colorspace));
2230           break;
2231         }
2232       if (LocaleNCompare("copyright",property,9) == 0)
2233         {
2234           (void) CopyMagickString(value,GetMagickCopyright(),MaxTextExtent);
2235           break;
2236         }
2237       break;
2238     }
2239     case 'd':
2240     {
2241       if (LocaleNCompare("depth",property,5) == 0)
2242         {
2243           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2244             image->depth);
2245           break;
2246         }
2247       if (LocaleNCompare("directory",property,9) == 0)
2248         {
2249           GetPathComponent(image->magick_filename,HeadPath,filename);
2250           (void) CopyMagickString(value,filename,MaxTextExtent);
2251           break;
2252         }
2253       break;
2254     }
2255     case 'e':
2256     {
2257       if (LocaleNCompare("extension",property,9) == 0)
2258         {
2259           GetPathComponent(image->magick_filename,ExtensionPath,filename);
2260           (void) CopyMagickString(value,filename,MaxTextExtent);
2261           break;
2262         }
2263       break;
2264     }
2265     case 'g':
2266     {
2267       if (LocaleNCompare("group",property,5) == 0)
2268         {
2269           (void) FormatLocaleString(value,MaxTextExtent,"0x%lx",
2270             (unsigned long) image_info->group);
2271           break;
2272         }
2273       break;
2274     }
2275     case 'h':
2276     {
2277       if (LocaleNCompare("height",property,6) == 0)
2278         {
2279           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",
2280             image->magick_rows != 0 ? (double) image->magick_rows : 256.0);
2281           break;
2282         }
2283       break;
2284     }
2285     case 'i':
2286     {
2287       if (LocaleNCompare("input",property,5) == 0)
2288         {
2289           (void) CopyMagickString(value,image->filename,MaxTextExtent);
2290           break;
2291         }
2292       break;
2293     }
2294     case 'k':
2295     {
2296       if (LocaleNCompare("kurtosis",property,8) == 0)
2297         {
2298           double
2299             kurtosis,
2300             skewness;
2301
2302           (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
2303           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2304             GetMagickPrecision(),kurtosis);
2305           break;
2306         }
2307       break;
2308     }
2309     case 'm':
2310     {
2311       if (LocaleNCompare("magick",property,6) == 0)
2312         {
2313           (void) CopyMagickString(value,image->magick,MaxTextExtent);
2314           break;
2315         }
2316       if (LocaleNCompare("max",property,3) == 0)
2317         {
2318           double
2319             maximum,
2320             minimum;
2321
2322           (void) GetImageRange(image,&minimum,&maximum,exception);
2323           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2324             GetMagickPrecision(),maximum);
2325           break;
2326         }
2327       if (LocaleNCompare("mean",property,4) == 0)
2328         {
2329           double
2330             mean,
2331             standard_deviation;
2332
2333           (void) GetImageMean(image,&mean,&standard_deviation,
2334              exception);
2335           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2336             GetMagickPrecision(),mean);
2337           break;
2338         }
2339       if (LocaleNCompare("min",property,3) == 0)
2340         {
2341           double
2342             maximum,
2343             minimum;
2344
2345           (void) GetImageRange(image,&minimum,&maximum,exception);
2346           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2347             GetMagickPrecision(),minimum);
2348           break;
2349         }
2350       break;
2351     }
2352     case 'n':
2353     {
2354       if (LocaleNCompare("name",property,4) == 0)
2355         {
2356           (void) CopyMagickString(value,filename,MaxTextExtent);
2357           break;
2358         }
2359      break;
2360     }
2361     case 'o':
2362     {
2363       if (LocaleNCompare("opaque",property,6) == 0)
2364         {
2365           MagickBooleanType
2366             opaque;
2367
2368           opaque=IsImageOpaque(image,exception);
2369           (void) CopyMagickString(value,opaque == MagickFalse ? "false" :
2370             "true",MaxTextExtent);
2371           break;
2372         }
2373       if (LocaleNCompare("orientation",property,11) == 0)
2374         {
2375           (void) FormatLocaleString(value,MaxTextExtent,"%s",
2376             CommandOptionToMnemonic(MagickOrientationOptions,(ssize_t)
2377             image->orientation));
2378           break;
2379         }
2380       if (LocaleNCompare("output",property,6) == 0)
2381         {
2382           (void) CopyMagickString(value,image_info->filename,MaxTextExtent);
2383           break;
2384         }
2385      break;
2386     }
2387     case 'p':
2388     {
2389       if (LocaleNCompare("page",property,4) == 0)
2390         {
2391           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2392             GetImageIndexInList(image)+1);
2393           break;
2394         }
2395       break;
2396     }
2397     case 'r':
2398     {
2399       if (LocaleNCompare("resolution.x",property,11) == 0)
2400         {
2401           (void) FormatLocaleString(value,MaxTextExtent,"%g",
2402             image->resolution.x);
2403           break;
2404         }
2405       if (LocaleNCompare("resolution.y",property,11) == 0)
2406         {
2407           (void) FormatLocaleString(value,MaxTextExtent,"%g",
2408             image->resolution.y);
2409           break;
2410         }
2411       break;
2412     }
2413     case 's':
2414     {
2415       if (LocaleNCompare("size",property,4) == 0)
2416         {
2417           char
2418             format[MaxTextExtent];
2419
2420           (void) FormatMagickSize(GetBlobSize(image),MagickFalse,format);
2421           (void) FormatLocaleString(value,MaxTextExtent,"%sB",format);
2422           break;
2423         }
2424       if (LocaleNCompare("scenes",property,6) == 0)
2425         {
2426           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2427             GetImageListLength(image));
2428           break;
2429         }
2430       if (LocaleNCompare("scene",property,5) == 0)
2431         {
2432           /* FUTURE: I am not certain this property return makes sense! */
2433           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2434             image->scene);
2435           if (image_info->number_scenes != 0)
2436             (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2437               image_info->scene);
2438           break;
2439         }
2440       if (LocaleNCompare("skewness",property,8) == 0)
2441         {
2442           double
2443             kurtosis,
2444             skewness;
2445
2446           (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
2447           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2448             GetMagickPrecision(),skewness);
2449           break;
2450         }
2451       if (LocaleNCompare("standard-deviation",property,18) == 0)
2452         {
2453           double
2454             mean,
2455             standard_deviation;
2456
2457           (void) GetImageMean(image,&mean,&standard_deviation,
2458             exception);
2459           (void) FormatLocaleString(value,MaxTextExtent,"%.*g",
2460             GetMagickPrecision(),standard_deviation);
2461           break;
2462         }
2463        break;
2464     }
2465     case 'u':
2466     {
2467       if (LocaleNCompare("unique",property,6) == 0)
2468         {
2469           (void) CopyMagickString(filename,image_info->unique,MaxTextExtent);
2470           (void) CopyMagickString(value,filename,MaxTextExtent);
2471           break;
2472         }
2473       break;
2474     }
2475     case 'v':
2476     {
2477       if (LocaleNCompare("version",property,7) == 0)
2478         {
2479           (void) CopyMagickString(value,GetMagickVersion((size_t *) NULL),
2480             MaxTextExtent);
2481           break;
2482         }
2483       break;
2484     }
2485     case 'w':
2486     {
2487       if (LocaleNCompare("width",property,5) == 0)
2488         {
2489           (void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
2490             (image->magick_columns != 0 ? image->magick_columns : 256));
2491           break;
2492         }
2493       break;
2494     }
2495     case 'z':
2496     {
2497       if (LocaleNCompare("zero",property,4) == 0)
2498         {
2499           (void) CopyMagickString(filename,image_info->zero,MaxTextExtent);
2500           (void) CopyMagickString(value,filename,MaxTextExtent);
2501           break;
2502         }
2503       break;
2504     }
2505   }
2506   if (*value != '\0')
2507    {
2508      if (image->properties == (void *) NULL)
2509        image->properties=NewSplayTree(CompareSplayTreeString,
2510          RelinquishMagickMemory,RelinquishMagickMemory);
2511      (void) AddValueToSplayTree((SplayTreeInfo *) image->properties,
2512        ConstantString(property),ConstantString(value));
2513    }
2514   return(GetImageProperty(image,property,exception));
2515 }
2516 \f
2517 /*
2518 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2519 %                                                                             %
2520 %                                                                             %
2521 %                                                                             %
2522 %   G e t N e x t I m a g e P r o p e r t y                                   %
2523 %                                                                             %
2524 %                                                                             %
2525 %                                                                             %
2526 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2527 %
2528 %  GetNextImageProperty() gets the next image property value.
2529 %
2530 %  The format of the GetNextImageProperty method is:
2531 %
2532 %      char *GetNextImageProperty(const Image *image)
2533 %
2534 %  A description of each parameter follows:
2535 %
2536 %    o image: the image.
2537 %
2538 */
2539 MagickExport char *GetNextImageProperty(const Image *image)
2540 {
2541   assert(image != (Image *) NULL);
2542   assert(image->signature == MagickSignature);
2543   if (image->debug != MagickFalse)
2544     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2545       image->filename);
2546   if (image->properties == (void *) NULL)
2547     return((char *) NULL);
2548   return((char *) GetNextKeyInSplayTree((SplayTreeInfo *) image->properties));
2549 }
2550 \f
2551 /*
2552 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2553 %                                                                             %
2554 %                                                                             %
2555 %                                                                             %
2556 %   I n t e r p r e t I m a g e P r o p e r t i e s                           %
2557 %                                                                             %
2558 %                                                                             %
2559 %                                                                             %
2560 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2561 %
2562 %  InterpretImageProperties() replaces any embedded formatting characters with
2563 %  the appropriate image property and returns the interpreted text.  Free with
2564 %  DestoryString() or RelinquishMagickMemory().
2565 %
2566 %  The format of the InterpretImageProperties method is:
2567 %
2568 %      char *InterpretImageProperties(const ImageInfo *image_info,Image *image,
2569 %        const char *embed_text,ExceptionInfo *exception)
2570 %
2571 %  A description of each parameter follows:
2572 %
2573 %    o image_info: the image info.
2574 %
2575 %    o image: the image.
2576 %
2577 %    o embed_text: the address of a character string containing the embedded
2578 %      formatting characters.
2579 %
2580 %    o exception: return any errors or warnings in this structure.
2581 %
2582 */
2583 MagickExport char *InterpretImageProperties(const ImageInfo *image_info,
2584   Image *image,const char *embed_text,ExceptionInfo *exception)
2585 {
2586   char
2587     filename[MaxTextExtent],
2588     *interpret_text,
2589     *text;
2590
2591   const char
2592     *value;
2593
2594   register char
2595     *q;
2596
2597   register const char
2598     *p;
2599
2600   register ssize_t
2601     i;
2602
2603   size_t
2604     extent,
2605     length;
2606
2607   assert(image != (Image *) NULL);
2608   assert(image->signature == MagickSignature);
2609   if (image->debug != MagickFalse)
2610     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2611   if ((embed_text == (const char *) NULL) || (*embed_text == '\0'))
2612     return((char *) NULL);
2613   text=(char *) embed_text;
2614   if ((*text == '@') && ((*(text+1) == '-') ||
2615       (IsPathAccessible(text+1) != MagickFalse)))
2616     return(FileToString(embed_text+1,~0,exception));
2617   /*
2618     Translate any embedded format characters.
2619   */
2620   interpret_text=AcquireString(text);
2621   extent=MaxTextExtent;
2622   p=text;
2623   for (q=interpret_text; *p != '\0'; p++)
2624   {
2625     *q='\0';
2626     if ((size_t) (q-interpret_text+MaxTextExtent) >= extent)
2627       {
2628         extent+=MaxTextExtent;
2629         interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+
2630           MaxTextExtent+1,sizeof(*interpret_text));
2631         if (interpret_text == (char *) NULL)
2632           break;
2633         q=interpret_text+strlen(interpret_text);
2634       }
2635     /*
2636       Process formatting characters in text.
2637     */
2638     if ((*p == '\\') && (*(p+1) == 'r'))
2639       {
2640         *q++='\r';
2641         p++;
2642         continue;
2643       }
2644     if ((*p == '\\') && (*(p+1) == 'n'))
2645       {
2646         *q++='\n';
2647         p++;
2648         continue;
2649       }
2650     if (*p == '\\')
2651       {
2652         p++;
2653         *q++=(*p);
2654         continue;
2655       }
2656     if (*p != '%')
2657       {
2658         *q++=(*p);
2659         continue;
2660       }
2661     p++;
2662     switch (*p)
2663     {
2664       case '[':  /* multi-character substitution */
2665       {
2666         char
2667           pattern[MaxTextExtent];
2668
2669         const char
2670           *key,
2671           *value;
2672
2673         ssize_t
2674           depth;
2675
2676         /*
2677           Image value.
2678         */
2679         if (strchr(p,']') == (char *) NULL)
2680           break;
2681         depth=1;
2682         p++;
2683         for (i=0; (i < (MaxTextExtent-1L)) && (*p != '\0'); i++)
2684         {
2685           if (*p == '[')
2686             depth++;
2687           if (*p == ']')
2688             depth--;
2689           if (depth <= 0)
2690             break;
2691           pattern[i]=(*p++);
2692         }
2693         pattern[i]='\0';
2694         value=GetImageProperty(image,pattern,exception);
2695         if (value != (const char *) NULL)
2696           {
2697             length=strlen(value);
2698             if ((size_t) (q-interpret_text+length+1) >= extent)
2699               {
2700                 extent+=length;
2701                 interpret_text=(char *) ResizeQuantumMemory(interpret_text,
2702                   extent+MaxTextExtent,sizeof(*interpret_text));
2703                 if (interpret_text == (char *) NULL)
2704                   break;
2705                 q=interpret_text+strlen(interpret_text);
2706               }
2707             (void) CopyMagickString(q,value,extent);
2708             q+=length;
2709             break;
2710           }
2711         else
2712           if (IsGlob(pattern) != MagickFalse)
2713             {
2714               /*
2715                 Iterate over image properties.
2716               */
2717               ResetImagePropertyIterator(image);
2718               key=GetNextImageProperty(image);
2719               while (key != (const char *) NULL)
2720               {
2721                 if (GlobExpression(key,pattern,MagickTrue) != MagickFalse)
2722                   {
2723                     value=GetImageProperty(image,key,exception);
2724                     if (value != (const char *) NULL)
2725                       {
2726                         length=strlen(key)+strlen(value)+2;
2727                         if ((size_t) (q-interpret_text+length+1) >= extent)
2728                           {
2729                             extent+=length;
2730                             interpret_text=(char *) ResizeQuantumMemory(
2731                               interpret_text,extent+MaxTextExtent,
2732                               sizeof(*interpret_text));
2733                             if (interpret_text == (char *) NULL)
2734                               break;
2735                             q=interpret_text+strlen(interpret_text);
2736                           }
2737                         q+=FormatLocaleString(q,extent,"%s=%s\n",key,value);
2738                       }
2739                   }
2740                 key=GetNextImageProperty(image);
2741               }
2742             }
2743         value=GetMagickProperty(image_info,image,pattern,exception);
2744         if (value != (const char *) NULL)
2745           {
2746             length=strlen(value);
2747             if ((size_t) (q-interpret_text+length+1) >= extent)
2748               {
2749                 extent+=length;
2750                 interpret_text=(char *) ResizeQuantumMemory(interpret_text,
2751                   extent+MaxTextExtent,sizeof(*interpret_text));
2752                 if (interpret_text == (char *) NULL)
2753                   break;
2754                 q=interpret_text+strlen(interpret_text);
2755               }
2756             (void) CopyMagickString(q,value,extent);
2757             q+=length;
2758             break;
2759           }
2760         if (image_info == (ImageInfo *) NULL)
2761           break;
2762         value=GetImageOption(image_info,pattern);
2763         if (value != (char *) NULL)
2764           {
2765             length=strlen(value);
2766             if ((size_t) (q-interpret_text+length+1) >= extent)
2767               {
2768                 extent+=length;
2769                 interpret_text=(char *) ResizeQuantumMemory(interpret_text,
2770                   extent+MaxTextExtent,sizeof(*interpret_text));
2771                 if (interpret_text == (char *) NULL)
2772                   break;
2773                 q=interpret_text+strlen(interpret_text);
2774               }
2775             (void) CopyMagickString(q,value,extent);
2776             q+=length;
2777             break;
2778           }
2779         break;
2780       }
2781       case 'b':  /* image size as read in */
2782       {
2783         char
2784           format[MaxTextExtent];
2785
2786         (void) FormatLocaleString(format,MaxTextExtent,"%.20g",(double)
2787           ((MagickOffsetType) image->extent));
2788         if (image->extent != (MagickSizeType) ((size_t) image->extent))
2789           (void) FormatMagickSize(image->extent,MagickFalse,format);
2790         q+=ConcatenateMagickString(q,format,extent);
2791         q+=ConcatenateMagickString(q,"B",extent);
2792         break;
2793       }
2794       case 'c':  /* image comment properity */
2795       {
2796         value=GetImageProperty(image,"comment",exception);
2797         if (value == (const char *) NULL)
2798           break;
2799         length=strlen(value);
2800         if ((size_t) (q-interpret_text+length+1) >= extent)
2801           {
2802             extent+=length;
2803             interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+
2804               MaxTextExtent,sizeof(*interpret_text));
2805             if (interpret_text == (char *) NULL)
2806               break;
2807             q=interpret_text+strlen(interpret_text);
2808           }
2809         (void) CopyMagickString(q,value,extent);
2810         q+=length;
2811         break;
2812       }
2813       case 'd':  /* Directory component of filename */
2814       {
2815         GetPathComponent(image->magick_filename,HeadPath,filename);
2816         q+=CopyMagickString(q,filename,extent);
2817         break;
2818       }
2819       case 'e': /* Filename extension (suffix) of image file */
2820       {
2821         GetPathComponent(image->magick_filename,ExtensionPath,filename);
2822         q+=CopyMagickString(q,filename,extent);
2823         break;
2824       }
2825       case 'f': /* Filename without directory component */
2826       {
2827         GetPathComponent(image->magick_filename,TailPath,filename);
2828         q+=CopyMagickString(q,filename,extent);
2829         break;
2830       }
2831       case 't': /* Base filename without directory or extention */
2832       {
2833         GetPathComponent(image->magick_filename,BasePath,filename);
2834         q+=CopyMagickString(q,filename,extent);
2835         break;
2836       }
2837       case 'g': /* Image geometry,  canvas and offset */
2838       {
2839         q+=FormatLocaleString(q,extent,"%.20gx%.20g%+.20g%+.20g",(double)
2840           image->page.width,(double) image->page.height,(double) image->page.x,
2841           (double) image->page.y);
2842         break;
2843       }
2844       case 'h': /* Image height */
2845       {
2846         q+=FormatLocaleString(q,extent,"%.20g",(double) (image->rows != 0 ?
2847           image->rows : image->magick_rows));
2848         break;
2849       }
2850       case 'i': /* Images filename - (output filename with "info:" ) */
2851       {
2852         q+=CopyMagickString(q,image->filename,extent);
2853         break;
2854       }
2855       case 'k': /* Number of unique colors  */
2856       {
2857         q+=FormatLocaleString(q,extent,"%.20g",(double) GetNumberColors(image,
2858           (FILE *) NULL,exception));
2859         break;
2860       }
2861       case 'l': /* Image label  */
2862       {
2863         value=GetImageProperty(image,"label",exception);
2864         if (value == (const char *) NULL)
2865           break;
2866         length=strlen(value);
2867         if ((size_t) (q-interpret_text+length+1) >= extent)
2868           {
2869             extent+=length;
2870             interpret_text=(char *) ResizeQuantumMemory(interpret_text,extent+
2871               MaxTextExtent,sizeof(*interpret_text));
2872             if (interpret_text == (char *) NULL)
2873               break;
2874             q=interpret_text+strlen(interpret_text);
2875           }
2876         q+=CopyMagickString(q,value,extent);
2877         break;
2878       }
2879       case 'm': /* Image format (file magick) */
2880       {
2881         q+=CopyMagickString(q,image->magick,extent);
2882         break;
2883       }
2884       case 'M': /* Magick filename - exactly as given incl. read mods */
2885       {
2886         q+=CopyMagickString(q,image->magick_filename,extent);
2887         break;
2888       }
2889       case 'n': /* Number of images in the list.  */
2890       {
2891         q+=FormatLocaleString(q,extent,"%.20g",(double)
2892           GetImageListLength(image));
2893         break;
2894       }
2895       case 'o': /* Image output filename */
2896       {
2897         q+=CopyMagickString(q,image_info->filename,extent);
2898         break;
2899       }
2900       case 'p': /* Image index in current image list  */
2901       {
2902         q+=FormatLocaleString(q,extent,"%.20g",(double)
2903           GetImageIndexInList(image));
2904         break;
2905       }
2906       case 'q': /* Quantum depth of image in memory */
2907       {
2908         q+=FormatLocaleString(q,extent,"%.20g",(double)
2909           MAGICKCORE_QUANTUM_DEPTH);
2910         break;
2911       }
2912       case 'r': /* Image storage class and colorspace.  */
2913       {
2914         ColorspaceType
2915           colorspace;
2916
2917         colorspace=image->colorspace;
2918         if (IsImageGray(image,exception) != MagickFalse)
2919           colorspace=GRAYColorspace;
2920         q+=FormatLocaleString(q,extent,"%s%s%s",CommandOptionToMnemonic(
2921           MagickClassOptions,(ssize_t) image->storage_class),
2922           CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t) colorspace),
2923           image->matte != MagickFalse ? "Matte" : "");
2924         break;
2925       }
2926       case 's': /* Image scene number  */
2927       {
2928         if (image_info->number_scenes == 0)
2929           q+=FormatLocaleString(q,extent,"%.20g",(double) image->scene);
2930         else
2931           q+=FormatLocaleString(q,extent,"%.20g",(double) image_info->scene);
2932         break;
2933       }
2934       case 'u': /* Unique filename */
2935       {
2936         (void) CopyMagickString(filename,image_info->unique,extent);
2937         q+=CopyMagickString(q,filename,extent);
2938         break;
2939       }
2940       case 'w': /* Image width  */
2941       {
2942         q+=FormatLocaleString(q,extent,"%.20g",(double) (image->columns != 0 ?
2943           image->columns : image->magick_columns));
2944         break;
2945       }
2946       case 'x': /* Image horizontal resolution (density).  */
2947       {
2948         q+=FormatLocaleString(q,extent,"%g %s",image->resolution.x,
2949           CommandOptionToMnemonic(MagickResolutionOptions,(ssize_t)
2950             image->units));
2951         break;
2952       }
2953       case 'y': /* Image vertical resolution (density)  */
2954       {
2955         q+=FormatLocaleString(q,extent,"%g %s",image->resolution.y,
2956           CommandOptionToMnemonic(MagickResolutionOptions,(ssize_t)
2957           image->units));
2958         break;
2959       }
2960       case 'z': /* Image depth as read in */
2961       {
2962         q+=FormatLocaleString(q,extent,"%.20g",(double) image->depth);
2963         break;
2964       }
2965       case 'A': /* Image alpha channel  */
2966       {
2967         q+=FormatLocaleString(q,extent,"%s",CommandOptionToMnemonic(
2968           MagickBooleanOptions,(ssize_t) image->matte));
2969         break;
2970       }
2971       case 'C': /* Image compression method.  */
2972       {
2973         q+=FormatLocaleString(q,extent,"%s",CommandOptionToMnemonic(
2974           MagickCompressOptions,(ssize_t) image->compression));
2975         break;
2976       }
2977       case 'D': /* Image dispose method.  */
2978       {
2979         q+=FormatLocaleString(q,extent,"%s",CommandOptionToMnemonic(
2980           MagickDisposeOptions,(ssize_t) image->dispose));
2981         break;
2982       }
2983       case 'G': /* Image size as geometry = "%wx%h" */
2984       {
2985         q+=FormatLocaleString(q,extent,"%.20gx%.20g",(double)
2986           image->magick_columns,(double) image->magick_rows);
2987         break;
2988       }
2989       case 'H': /* layer canvas height */
2990       {
2991         q+=FormatLocaleString(q,extent,"%.20g",(double) image->page.height);
2992         break;
2993       }
2994       case 'O': /* layer canvas offset with sign = "+%X+%Y" */
2995       {
2996         q+=FormatLocaleString(q,extent,"%+ld%+ld",(long) image->page.x,(long)
2997           image->page.y);
2998         break;
2999       }
3000       case 'P': /* layer canvas page size = "%Wx%H" */
3001       {
3002         q+=FormatLocaleString(q,extent,"%.20gx%.20g",(double) image->page.width,
3003           (double) image->page.height);
3004         break;
3005       }
3006       case 'Q': /* image compression quality */
3007       {
3008         q+=FormatLocaleString(q,extent,"%.20g",(double) image->quality);
3009         break;
3010       }
3011       case 'S': /* Image scenes  */
3012       {
3013         if (image_info->number_scenes == 0)
3014           q+=CopyMagickString(q,"2147483647",extent);
3015         else
3016           q+=FormatLocaleString(q,extent,"%.20g",(double) (image_info->scene+
3017             image_info->number_scenes));
3018         break;
3019       }
3020       case 'T': /* image time delay for animations */
3021       {
3022         q+=FormatLocaleString(q,extent,"%.20g",(double) image->delay);
3023         break;
3024       }
3025       case 'W': /* layer canvas width */
3026       {
3027         q+=FormatLocaleString(q,extent,"%.20g",(double) image->page.width);
3028         break;
3029       }
3030       case 'X': /* layer canvas X offset */
3031       {
3032         q+=FormatLocaleString(q,extent,"%+.20g",(double) image->page.x);
3033         break;
3034       }
3035       case 'Y': /* layer canvas Y offset */
3036       {
3037         q+=FormatLocaleString(q,extent,"%+.20g",(double) image->page.y);
3038         break;
3039       }
3040       case 'Z': /* Unique filename. */
3041       {
3042         (void) CopyMagickString(filename,image_info->zero,extent);
3043         q+=CopyMagickString(q,filename,extent);
3044         break;
3045       }
3046       case '@': /* Image bounding box.  */
3047       {
3048         RectangleInfo
3049           page;
3050
3051         page=GetImageBoundingBox(image,exception);
3052         q+=FormatLocaleString(q,MaxTextExtent,"%.20gx%.20g%+.20g%+.20g",
3053           (double) page.width,(double) page.height,(double) page.x,(double)
3054           page.y);
3055         break;
3056       }
3057       case '#': /* Image signature */
3058       {
3059         (void) SignatureImage(image,exception);
3060         value=GetImageProperty(image,"signature",exception);
3061         if (value == (const char *) NULL)
3062           break;
3063         q+=CopyMagickString(q,value,extent);
3064         break;
3065       }
3066       case '%': /* percent escaped */
3067       {
3068         *q++=(*p);
3069         break;
3070       }
3071       default: /* percent not expanded */
3072       {
3073         *q++='%';
3074         *q++=(*p);
3075         break;
3076       }
3077     }
3078   }
3079   *q='\0';
3080   if (text != (const char *) embed_text)
3081     text=DestroyString(text);
3082   (void) SubstituteString(&interpret_text,"&lt;","<");
3083   (void) SubstituteString(&interpret_text,"&gt;",">");
3084   return(interpret_text);
3085 }
3086 \f
3087 /*
3088 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3089 %                                                                             %
3090 %                                                                             %
3091 %                                                                             %
3092 %   R e m o v e I m a g e P r o p e r t y                                     %
3093 %                                                                             %
3094 %                                                                             %
3095 %                                                                             %
3096 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3097 %
3098 %  RemoveImageProperty() removes a property from the image and returns its
3099 %  value.
3100 %
3101 %  The format of the RemoveImageProperty method is:
3102 %
3103 %      char *RemoveImageProperty(Image *image,const char *property)
3104 %
3105 %  A description of each parameter follows:
3106 %
3107 %    o image: the image.
3108 %
3109 %    o property: the image property.
3110 %
3111 */
3112 MagickExport char *RemoveImageProperty(Image *image,
3113   const char *property)
3114 {
3115   char
3116     *value;
3117
3118   assert(image != (Image *) NULL);
3119   assert(image->signature == MagickSignature);
3120   if (image->debug != MagickFalse)
3121     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3122       image->filename);
3123   if (image->properties == (void *) NULL)
3124     return((char *) NULL);
3125   value=(char *) RemoveNodeFromSplayTree((SplayTreeInfo *) image->properties,
3126     property);
3127   return(value);
3128 }
3129 \f
3130 /*
3131 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3132 %                                                                             %
3133 %                                                                             %
3134 %                                                                             %
3135 %   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                       %
3136 %                                                                             %
3137 %                                                                             %
3138 %                                                                             %
3139 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3140 %
3141 %  ResetImagePropertyIterator() resets the image properties iterator.  Use it
3142 %  in conjunction with GetNextImageProperty() to iterate over all the values
3143 %  associated with an image property.
3144 %
3145 %  The format of the ResetImagePropertyIterator method is:
3146 %
3147 %      ResetImagePropertyIterator(Image *image)
3148 %
3149 %  A description of each parameter follows:
3150 %
3151 %    o image: the image.
3152 %
3153 */
3154 MagickExport void ResetImagePropertyIterator(const Image *image)
3155 {
3156   assert(image != (Image *) NULL);
3157   assert(image->signature == MagickSignature);
3158   if (image->debug != MagickFalse)
3159     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3160       image->filename);
3161   if (image->properties == (void *) NULL)
3162     return;
3163   ResetSplayTreeIterator((SplayTreeInfo *) image->properties);
3164 }
3165 \f
3166 /*
3167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3168 %                                                                             %
3169 %                                                                             %
3170 %                                                                             %
3171 %   S e t I m a g e P r o p e r t y                                           %
3172 %                                                                             %
3173 %                                                                             %
3174 %                                                                             %
3175 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3176 %
3177 %  SetImageProperty() associates an value with an image property.
3178 %
3179 %  The format of the SetImageProperty method is:
3180 %
3181 %      MagickBooleanType SetImageProperty(Image *image,const char *property,
3182 %        const char *value,ExceptionInfo *exception)
3183 %
3184 %  A description of each parameter follows:
3185 %
3186 %    o image: the image.
3187 %
3188 %    o property: the image property.
3189 %
3190 %    o values: the image property values.
3191 %
3192 %    o exception: return any errors or warnings in this structure.
3193 %
3194 */
3195 MagickExport MagickBooleanType SetImageProperty(Image *image,
3196   const char *property,const char *value,ExceptionInfo *exception)
3197 {
3198   MagickBooleanType
3199     status;
3200
3201   MagickStatusType
3202     flags;
3203
3204   assert(image != (Image *) NULL);
3205   assert(image->signature == MagickSignature);
3206   if (image->debug != MagickFalse)
3207     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3208       image->filename);
3209   if (image->properties == (void *) NULL)
3210     image->properties=NewSplayTree(CompareSplayTreeString,
3211       RelinquishMagickMemory,RelinquishMagickMemory);
3212   if ((value == (const char *) NULL) || (*value == '\0'))
3213     return(DeleteImageProperty(image,property));
3214   status=MagickTrue;
3215   switch (*property)
3216   {
3217     case 'B':
3218     case 'b':
3219     {
3220       if (LocaleCompare(property,"background") == 0)
3221         {
3222           (void) QueryColorCompliance(value,AllCompliance,
3223             &image->background_color,exception);
3224           break;
3225         }
3226       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3227         ConstantString(property),ConstantString(value));
3228       break;
3229     }
3230     case 'C':
3231     case 'c':
3232     {
3233       if (LocaleCompare(property,"colorspace") == 0)
3234         {
3235           ssize_t
3236             colorspace;
3237
3238           colorspace=ParseCommandOption(MagickColorspaceOptions,MagickFalse,
3239             value);
3240           if (colorspace < 0)
3241             break;
3242           (void) SetImageColorspace(image,(ColorspaceType) colorspace,
3243             exception);
3244           break;
3245         }
3246       if (LocaleCompare(property,"compose") == 0)
3247         {
3248           ssize_t
3249             compose;
3250
3251           compose=ParseCommandOption(MagickComposeOptions,MagickFalse,value);
3252           if (compose < 0)
3253             break;
3254           image->compose=(CompositeOperator) compose;
3255           break;
3256         }
3257       if (LocaleCompare(property,"compress") == 0)
3258         {
3259           ssize_t
3260             compression;
3261
3262           compression=ParseCommandOption(MagickCompressOptions,MagickFalse,
3263             value);
3264           if (compression < 0)
3265             break;
3266           image->compression=(CompressionType) compression;
3267           break;
3268         }
3269       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3270         ConstantString(property),ConstantString(value));
3271       break;
3272     }
3273     case 'D':
3274     case 'd':
3275     {
3276       if (LocaleCompare(property,"delay") == 0)
3277         {
3278           GeometryInfo
3279             geometry_info;
3280
3281           flags=ParseGeometry(value,&geometry_info);
3282           if ((flags & GreaterValue) != 0)
3283             {
3284               if (image->delay > (size_t) floor(geometry_info.rho+0.5))
3285                 image->delay=(size_t) floor(geometry_info.rho+0.5);
3286             }
3287           else
3288             if ((flags & LessValue) != 0)
3289               {
3290                 if (image->delay < (size_t) floor(geometry_info.rho+0.5))
3291                   image->ticks_per_second=(ssize_t)
3292                     floor(geometry_info.sigma+0.5);
3293               }
3294             else
3295               image->delay=(size_t) floor(geometry_info.rho+0.5);
3296           if ((flags & SigmaValue) != 0)
3297             image->ticks_per_second=(ssize_t) floor(geometry_info.sigma+0.5);
3298           break;
3299         }
3300       if (LocaleCompare(property,"density") == 0)
3301         {
3302           GeometryInfo
3303             geometry_info;
3304
3305           flags=ParseGeometry(value,&geometry_info);
3306           image->resolution.x=geometry_info.rho;
3307           image->resolution.y=geometry_info.sigma;
3308           if ((flags & SigmaValue) == 0)
3309             image->resolution.y=image->resolution.x;
3310         }
3311       if (LocaleCompare(property,"depth") == 0)
3312         {
3313           image->depth=StringToUnsignedLong(value);
3314           break;
3315         }
3316       if (LocaleCompare(property,"dispose") == 0)
3317         {
3318           ssize_t
3319             dispose;
3320
3321           dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse,value);
3322           if (dispose < 0)
3323             break;
3324           image->dispose=(DisposeType) dispose;
3325           break;
3326         }
3327       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3328         ConstantString(property),ConstantString(value));
3329       break;
3330     }
3331     case 'G':
3332     case 'g':
3333     {
3334       if (LocaleCompare(property,"gravity") == 0)
3335         {
3336           ssize_t
3337             gravity;
3338
3339           gravity=ParseCommandOption(MagickGravityOptions,MagickFalse,value);
3340           if (gravity < 0)
3341             break;
3342           image->gravity=(GravityType) gravity;
3343           break;
3344         }
3345       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3346         ConstantString(property),ConstantString(value));
3347       break;
3348     }
3349     case 'I':
3350     case 'i':
3351     {
3352       if (LocaleCompare(property,"intent") == 0)
3353         {
3354           ssize_t
3355             rendering_intent;
3356
3357           rendering_intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
3358             value);
3359           if (rendering_intent < 0)
3360             break;
3361           image->rendering_intent=(RenderingIntent) rendering_intent;
3362           break;
3363         }
3364       if (LocaleCompare(property,"interpolate") == 0)
3365         {
3366           ssize_t
3367             interpolate;
3368
3369           interpolate=ParseCommandOption(MagickInterpolateOptions,MagickFalse,
3370             value);
3371           if (interpolate < 0)
3372             break;
3373           image->interpolate=(PixelInterpolateMethod) interpolate;
3374           break;
3375         }
3376       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3377         ConstantString(property),ConstantString(value));
3378       break;
3379     }
3380     case 'L':
3381     case 'l':
3382     {
3383       if (LocaleCompare(property,"loop") == 0)
3384         {
3385           image->iterations=StringToUnsignedLong(value);
3386           break;
3387         }
3388       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3389         ConstantString(property),ConstantString(value));
3390       break;
3391     }
3392     case 'P':
3393     case 'p':
3394     {
3395       if (LocaleCompare(property,"page") == 0)
3396         {
3397           char
3398             *geometry;
3399
3400           geometry=GetPageGeometry(value);
3401           flags=ParseAbsoluteGeometry(geometry,&image->page);
3402           geometry=DestroyString(geometry);
3403           break;
3404         }
3405       if (LocaleCompare(property,"profile") == 0)
3406         {
3407           ImageInfo
3408             *image_info;
3409
3410           StringInfo
3411             *profile;
3412
3413           image_info=AcquireImageInfo();
3414           (void) CopyMagickString(image_info->filename,value,MaxTextExtent);
3415           (void) SetImageInfo(image_info,1,exception);
3416           profile=FileToStringInfo(image_info->filename,~0UL,exception);
3417           if (profile != (StringInfo *) NULL)
3418             status=SetImageProfile(image,image_info->magick,profile,exception);
3419           image_info=DestroyImageInfo(image_info);
3420           break;
3421         }
3422       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3423         ConstantString(property),ConstantString(value));
3424       break;
3425     }
3426     case 'R':
3427     case 'r':
3428     {
3429       if (LocaleCompare(property,"rendering-intent") == 0)
3430         {
3431           ssize_t
3432             rendering_intent;
3433
3434           rendering_intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
3435             value);
3436           if (rendering_intent < 0)
3437             break;
3438           image->rendering_intent=(RenderingIntent) rendering_intent;
3439           break;
3440         }
3441       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3442         ConstantString(property),ConstantString(value));
3443       break;
3444     }
3445     case 'T':
3446     case 't':
3447     {
3448       if (LocaleCompare(property,"tile-offset") == 0)
3449         {
3450           char
3451             *geometry;
3452
3453           geometry=GetPageGeometry(value);
3454           flags=ParseAbsoluteGeometry(geometry,&image->tile_offset);
3455           geometry=DestroyString(geometry);
3456           break;
3457         }
3458       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3459         ConstantString(property),ConstantString(value));
3460       break;
3461     }
3462     case 'U':
3463     case 'u':
3464     {
3465       if (LocaleCompare(property,"units") == 0)
3466         {
3467           ssize_t
3468             units;
3469
3470           units=ParseCommandOption(MagickResolutionOptions,MagickFalse,value);
3471           if (units < 0)
3472             break;
3473           image->units=(ResolutionType) units;
3474           break;
3475         }
3476       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3477         ConstantString(property),ConstantString(value));
3478       break;
3479     }
3480     default:
3481     {
3482       status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
3483         ConstantString(property),ConstantString(value));
3484       break;
3485     }
3486   }
3487   return(status);
3488 }