MagickCore 7.1.1
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
profile.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% PPPP RRRR OOO FFFFF IIIII L EEEEE %
7% P P R R O O F I L E %
8% PPPP RRRR O O FFF I L EEE %
9% P R R O O F I L E %
10% P R R OOO F IIIII LLLLL EEEEE %
11% %
12% %
13% MagickCore Image Profile Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1992 %
18% %
19% %
20% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
21% dedicated to making software imaging solutions freely available. %
22% %
23% You may not use this file except in compliance with the License. You may %
24% obtain a copy of the License at %
25% %
26% https://imagemagick.org/script/license.php %
27% %
28% Unless required by applicable law or agreed to in writing, software %
29% distributed under the License is distributed on an "AS IS" BASIS, %
30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31% See the License for the specific language governing permissions and %
32% limitations under the License. %
33% %
34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35%
36%
37*/
38␌
39/*
40 Include declarations.
41*/
42#include "MagickCore/studio.h"
43#include "MagickCore/artifact.h"
44#include "MagickCore/attribute.h"
45#include "MagickCore/cache.h"
46#include "MagickCore/color.h"
47#include "MagickCore/colorspace-private.h"
48#include "MagickCore/configure.h"
49#include "MagickCore/exception.h"
50#include "MagickCore/exception-private.h"
51#include "MagickCore/image.h"
52#include "MagickCore/linked-list.h"
53#include "MagickCore/memory_.h"
54#include "MagickCore/monitor.h"
55#include "MagickCore/monitor-private.h"
56#include "MagickCore/option.h"
57#include "MagickCore/option-private.h"
58#include "MagickCore/pixel-accessor.h"
59#include "MagickCore/profile.h"
60#include "MagickCore/profile-private.h"
61#include "MagickCore/property.h"
62#include "MagickCore/quantum.h"
63#include "MagickCore/quantum-private.h"
64#include "MagickCore/resource_.h"
65#include "MagickCore/splay-tree.h"
66#include "MagickCore/string_.h"
67#include "MagickCore/string-private.h"
68#include "MagickCore/thread-private.h"
69#include "MagickCore/token.h"
70#include "MagickCore/utility.h"
71#if defined(MAGICKCORE_LCMS_DELEGATE)
72#include <wchar.h>
73#if defined(MAGICKCORE_HAVE_LCMS_LCMS2_H)
74#include <lcms/lcms2.h>
75#else
76#include "lcms2.h"
77#endif
78#endif
79#if defined(MAGICKCORE_XML_DELEGATE)
80# include <libxml/parser.h>
81# include <libxml/tree.h>
82#endif
83␌
84/*
85 Forward declarations
86*/
87static MagickBooleanType
88 SetImageProfileInternal(Image *,const char *,StringInfo *,
89 const MagickBooleanType,ExceptionInfo *);
90
91static void
92 WriteTo8BimProfile(Image *,const char*,const StringInfo *);
93␌
94/*
95 Typedef declarations
96*/
97struct _ProfileInfo
98{
99 char
100 *name;
101
102 size_t
103 length;
104
105 unsigned char
106 *info;
107
108 size_t
109 signature;
110};
111
112typedef struct _CMSExceptionInfo
113{
114 Image
115 *image;
116
117 ExceptionInfo
118 *exception;
119} CMSExceptionInfo;
120␌
121/*
122%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
123% %
124% %
125% %
126% C l o n e I m a g e P r o f i l e s %
127% %
128% %
129% %
130%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
131%
132% CloneImageProfiles() clones one or more image profiles.
133%
134% The format of the CloneImageProfiles method is:
135%
136% MagickBooleanType CloneImageProfiles(Image *image,
137% const Image *clone_image)
138%
139% A description of each parameter follows:
140%
141% o image: the image.
142%
143% o clone_image: the clone image.
144%
145*/
146MagickExport MagickBooleanType CloneImageProfiles(Image *image,
147 const Image *clone_image)
148{
149 assert(image != (Image *) NULL);
150 assert(image->signature == MagickCoreSignature);
151 assert(clone_image != (const Image *) NULL);
152 assert(clone_image->signature == MagickCoreSignature);
153 if (IsEventLogging() != MagickFalse)
154 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
155 if (clone_image->profiles != (void *) NULL)
156 {
157 if (image->profiles != (void *) NULL)
158 DestroyImageProfiles(image);
159 image->profiles=CloneSplayTree((SplayTreeInfo *) clone_image->profiles,
160 (void *(*)(void *)) ConstantString,(void *(*)(void *)) CloneStringInfo);
161 }
162 return(MagickTrue);
163}
164␌
165/*
166%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
167% %
168% %
169% %
170% D e l e t e I m a g e P r o f i l e %
171% %
172% %
173% %
174%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
175%
176% DeleteImageProfile() deletes a profile from the image by its name.
177%
178% The format of the DeleteImageProfile method is:
179%
180% MagickBooleanType DeleteImageProfile(Image *image,const char *name)
181%
182% A description of each parameter follows:
183%
184% o image: the image.
185%
186% o name: the profile name.
187%
188*/
189MagickExport MagickBooleanType DeleteImageProfile(Image *image,const char *name)
190{
191 assert(image != (Image *) NULL);
192 assert(image->signature == MagickCoreSignature);
193 if (IsEventLogging() != MagickFalse)
194 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
195 if (image->profiles == (SplayTreeInfo *) NULL)
196 return(MagickFalse);
197 WriteTo8BimProfile(image,name,(StringInfo *) NULL);
198 return(DeleteNodeFromSplayTree((SplayTreeInfo *) image->profiles,name));
199}
200␌
201/*
202%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
203% %
204% %
205% %
206% D e s t r o y I m a g e P r o f i l e s %
207% %
208% %
209% %
210%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
211%
212% DestroyImageProfiles() releases memory associated with an image profile map.
213%
214% The format of the DestroyProfiles method is:
215%
216% void DestroyImageProfiles(Image *image)
217%
218% A description of each parameter follows:
219%
220% o image: the image.
221%
222*/
223MagickExport void DestroyImageProfiles(Image *image)
224{
225 if (image->profiles != (SplayTreeInfo *) NULL)
226 image->profiles=DestroySplayTree((SplayTreeInfo *) image->profiles);
227}
228␌
229/*
230%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
231% %
232% %
233% %
234% G e t I m a g e P r o f i l e %
235% %
236% %
237% %
238%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
239%
240% GetImageProfile() gets a profile associated with an image by name.
241%
242% The format of the GetImageProfile method is:
243%
244% const StringInfo *GetImageProfile(const Image *image,const char *name)
245%
246% A description of each parameter follows:
247%
248% o image: the image.
249%
250% o name: the profile name.
251%
252*/
253MagickExport const StringInfo *GetImageProfile(const Image *image,
254 const char *name)
255{
256 const StringInfo
257 *profile;
258
259 assert(image != (Image *) NULL);
260 assert(image->signature == MagickCoreSignature);
261 if (IsEventLogging() != MagickFalse)
262 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
263 if (image->profiles == (SplayTreeInfo *) NULL)
264 return((StringInfo *) NULL);
265 profile=(const StringInfo *) GetValueFromSplayTree((SplayTreeInfo *)
266 image->profiles,name);
267 return(profile);
268}
269␌
270/*
271%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
272% %
273% %
274% %
275% G e t N e x t I m a g e P r o f i l e %
276% %
277% %
278% %
279%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
280%
281% GetNextImageProfile() gets the next profile name for an image.
282%
283% The format of the GetNextImageProfile method is:
284%
285% char *GetNextImageProfile(const Image *image)
286%
287% A description of each parameter follows:
288%
289% o hash_info: the hash info.
290%
291*/
292MagickExport char *GetNextImageProfile(const Image *image)
293{
294 assert(image != (Image *) NULL);
295 assert(image->signature == MagickCoreSignature);
296 if (IsEventLogging() != MagickFalse)
297 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
298 if (image->profiles == (SplayTreeInfo *) NULL)
299 return((char *) NULL);
300 return((char *) GetNextKeyInSplayTree((SplayTreeInfo *) image->profiles));
301}
302␌
303/*
304%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
305% %
306% %
307% %
308% P r o f i l e I m a g e %
309% %
310% %
311% %
312%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
313%
314% ProfileImage() associates, applies, or removes an ICM, IPTC, or generic
315% profile with / to / from an image. If the profile is NULL, it is removed
316% from the image otherwise added or applied. Use a name of '*' and a profile
317% of NULL to remove all profiles from the image.
318%
319% ICC and ICM profiles are handled as follows: If the image does not have
320% an associated color profile, the one you provide is associated with the
321% image and the image pixels are not transformed. Otherwise, the colorspace
322% transform defined by the existing and new profile are applied to the image
323% pixels and the new profile is associated with the image.
324%
325% The format of the ProfileImage method is:
326%
327% MagickBooleanType ProfileImage(Image *image,const char *name,
328% const void *datum,const size_t length,const MagickBooleanType clone)
329%
330% A description of each parameter follows:
331%
332% o image: the image.
333%
334% o name: Name of profile to add or remove: ICC, IPTC, or generic profile.
335%
336% o datum: the profile data.
337%
338% o length: the length of the profile.
339%
340% o clone: should be MagickFalse.
341%
342*/
343
344#if defined(MAGICKCORE_LCMS_DELEGATE)
345
346typedef struct _LCMSInfo
347{
348 ColorspaceType
349 colorspace;
350
351 cmsUInt32Number
352 type;
353
354 size_t
355 channels;
356
357 cmsHPROFILE
358 profile;
359
360 int
361 intent;
362
363 double
364 scale[4],
365 translate[4];
366
367 void
368 **magick_restrict pixels;
369} LCMSInfo;
370
371#if LCMS_VERSION < 2060
372static void* cmsGetContextUserData(cmsContext ContextID)
373{
374 return(ContextID);
375}
376
377static cmsContext cmsCreateContext(void *magick_unused(Plugin),void *UserData)
378{
379 magick_unreferenced(Plugin);
380 return((cmsContext) UserData);
381}
382
383static void cmsSetLogErrorHandlerTHR(cmsContext magick_unused(ContextID),
384 cmsLogErrorHandlerFunction Fn)
385{
386 magick_unreferenced(ContextID);
387 cmsSetLogErrorHandler(Fn);
388}
389
390static void cmsDeleteContext(cmsContext magick_unused(ContextID))
391{
392 magick_unreferenced(ContextID);
393}
394#endif
395
396static void **DestroyPixelTLS(void **pixels)
397{
398 ssize_t
399 i;
400
401 if (pixels == (void **) NULL)
402 return((void **) NULL);
403 for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
404 if (pixels[i] != (void *) NULL)
405 pixels[i]=RelinquishMagickMemory(pixels[i]);
406 pixels=(void **) RelinquishMagickMemory(pixels);
407 return(pixels);
408}
409
410static void **AcquirePixelTLS(const size_t columns,const size_t channels,
411 MagickBooleanType highres)
412{
413 ssize_t
414 i;
415
416 size_t
417 number_threads;
418
419 size_t
420 size;
421
422 void
423 **pixels;
424
425 number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
426 pixels=(void **) AcquireQuantumMemory(number_threads,sizeof(*pixels));
427 if (pixels == (void **) NULL)
428 return((void **) NULL);
429 (void) memset(pixels,0,number_threads*sizeof(*pixels));
430 size=sizeof(double);
431 if (highres == MagickFalse)
432 size=sizeof(Quantum);
433 for (i=0; i < (ssize_t) number_threads; i++)
434 {
435 pixels[i]=AcquireQuantumMemory(columns,channels*size);
436 if (pixels[i] == (void *) NULL)
437 return(DestroyPixelTLS(pixels));
438 }
439 return(pixels);
440}
441
442static cmsHTRANSFORM *DestroyTransformTLS(cmsHTRANSFORM *transform)
443{
444 ssize_t
445 i;
446
447 assert(transform != (cmsHTRANSFORM *) NULL);
448 for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
449 if (transform[i] != (cmsHTRANSFORM) NULL)
450 cmsDeleteTransform(transform[i]);
451 transform=(cmsHTRANSFORM *) RelinquishMagickMemory(transform);
452 return(transform);
453}
454
455static cmsHTRANSFORM *AcquireTransformTLS(const LCMSInfo *source_info,
456 const LCMSInfo *target_info,const cmsUInt32Number flags,
457 cmsContext cms_context)
458{
459 cmsHTRANSFORM
460 *transform;
461
462 size_t
463 number_threads;
464
465 ssize_t
466 i;
467
468 number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
469 transform=(cmsHTRANSFORM *) AcquireQuantumMemory(number_threads,
470 sizeof(*transform));
471 if (transform == (cmsHTRANSFORM *) NULL)
472 return((cmsHTRANSFORM *) NULL);
473 (void) memset(transform,0,number_threads*sizeof(*transform));
474 for (i=0; i < (ssize_t) number_threads; i++)
475 {
476 transform[i]=cmsCreateTransformTHR(cms_context,source_info->profile,
477 source_info->type,target_info->profile,target_info->type,
478 (cmsUInt32Number) target_info->intent,flags);
479 if (transform[i] == (cmsHTRANSFORM) NULL)
480 return(DestroyTransformTLS(transform));
481 }
482 return(transform);
483}
484
485static void CMSExceptionHandler(cmsContext context,cmsUInt32Number severity,
486 const char *message)
487{
488 CMSExceptionInfo
489 *cms_exception;
490
491 ExceptionInfo
492 *exception;
493
494 Image
495 *image;
496
497 cms_exception=(CMSExceptionInfo *) cmsGetContextUserData(context);
498 if (cms_exception == (CMSExceptionInfo *) NULL)
499 return;
500 exception=cms_exception->exception;
501 if (exception == (ExceptionInfo *) NULL)
502 return;
503 image=cms_exception->image;
504 if (image == (Image *) NULL)
505 {
506 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
507 "UnableToTransformColorspace","`%s'","unknown context");
508 return;
509 }
510 if (image->debug != MagickFalse)
511 (void) LogMagickEvent(TransformEvent,GetMagickModule(),"lcms: #%u, %s",
512 severity,message != (char *) NULL ? message : "no message");
513 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
514 "UnableToTransformColorspace","`%s', %s (#%u)",image->filename,
515 message != (char *) NULL ? message : "no message",severity);
516}
517
518static void TransformDoublePixels(const int id,const Image* image,
519 const LCMSInfo *source_info,const LCMSInfo *target_info,
520 const cmsHTRANSFORM *transform,Quantum *q)
521{
522#define GetLCMSPixel(source_info,pixel,index) \
523 (source_info->scale[index]*(((double) QuantumScale*(double) pixel)+ \
524 source_info->translate[index]))
525#define SetLCMSPixel(target_info,pixel,index) ClampToQuantum( \
526 target_info->scale[index]*(((double) QuantumRange*(double) pixel)+ \
527 target_info->translate[index]))
528
529 double
530 *p;
531
532 ssize_t
533 x;
534
535 p=(double *) source_info->pixels[id];
536 for (x=0; x < (ssize_t) image->columns; x++)
537 {
538 *p++=GetLCMSPixel(source_info,GetPixelRed(image,q),0);
539 if (source_info->channels > 1)
540 {
541 *p++=GetLCMSPixel(source_info,GetPixelGreen(image,q),1);
542 *p++=GetLCMSPixel(source_info,GetPixelBlue(image,q),2);
543 }
544 if (source_info->channels > 3)
545 *p++=GetLCMSPixel(source_info,GetPixelBlack(image,q),3);
546 q+=GetPixelChannels(image);
547 }
548 cmsDoTransform(transform[id],source_info->pixels[id],target_info->pixels[id],
549 (unsigned int) image->columns);
550 p=(double *) target_info->pixels[id];
551 q-=GetPixelChannels(image)*image->columns;
552 for (x=0; x < (ssize_t) image->columns; x++)
553 {
554 if (target_info->channels == 1)
555 SetPixelGray(image,SetLCMSPixel(target_info,*p,0),q);
556 else
557 SetPixelRed(image,SetLCMSPixel(target_info,*p,0),q);
558 p++;
559 if (target_info->channels > 1)
560 {
561 SetPixelGreen(image,SetLCMSPixel(target_info,*p,1),q);
562 p++;
563 SetPixelBlue(image,SetLCMSPixel(target_info,*p,2),q);
564 p++;
565 }
566 if (target_info->channels > 3)
567 {
568 SetPixelBlack(image,SetLCMSPixel(target_info,*p,3),q);
569 p++;
570 }
571 q+=GetPixelChannels(image);
572 }
573}
574
575static void TransformQuantumPixels(const int id,const Image* image,
576 const LCMSInfo *source_info,const LCMSInfo *target_info,
577 const cmsHTRANSFORM *transform,Quantum *q)
578{
579 Quantum
580 *p;
581
582 ssize_t
583 x;
584
585 p=(Quantum *) source_info->pixels[id];
586 for (x=0; x < (ssize_t) image->columns; x++)
587 {
588 *p++=GetPixelRed(image,q);
589 if (source_info->channels > 1)
590 {
591 *p++=GetPixelGreen(image,q);
592 *p++=GetPixelBlue(image,q);
593 }
594 if (source_info->channels > 3)
595 *p++=GetPixelBlack(image,q);
596 q+=GetPixelChannels(image);
597 }
598 cmsDoTransform(transform[id],source_info->pixels[id],target_info->pixels[id],
599 (unsigned int) image->columns);
600 p=(Quantum *) target_info->pixels[id];
601 q-=GetPixelChannels(image)*image->columns;
602 for (x=0; x < (ssize_t) image->columns; x++)
603 {
604 if (target_info->channels == 1)
605 SetPixelGray(image,*p++,q);
606 else
607 SetPixelRed(image,*p++,q);
608 if (target_info->channels > 1)
609 {
610 SetPixelGreen(image,*p++,q);
611 SetPixelBlue(image,*p++,q);
612 }
613 if (target_info->channels > 3)
614 SetPixelBlack(image,*p++,q);
615 q+=GetPixelChannels(image);
616 }
617}
618
619static inline void SetLCMSInfoTranslate(LCMSInfo *info,const double translate)
620{
621 info->translate[0]=translate;
622 info->translate[1]=translate;
623 info->translate[2]=translate;
624 info->translate[3]=translate;
625}
626
627static inline void SetLCMSInfoScale(LCMSInfo *info,const double scale)
628{
629 info->scale[0]=scale;
630 info->scale[1]=scale;
631 info->scale[2]=scale;
632 info->scale[3]=scale;
633}
634#endif
635
636static void SetsRGBImageProfile(Image *image,ExceptionInfo *exception)
637{
638 static unsigned char
639 sRGBProfile[] =
640 {
641 0x00, 0x00, 0x0c, 0x8c, 0x61, 0x72, 0x67, 0x6c, 0x02, 0x20, 0x00, 0x00,
642 0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
643 0x07, 0xde, 0x00, 0x01, 0x00, 0x06, 0x00, 0x16, 0x00, 0x0f, 0x00, 0x3a,
644 0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
645 0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00,
646 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
647 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x61, 0x72, 0x67, 0x6c,
648 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
649 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
650 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
651 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
652 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x99,
653 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0xec, 0x00, 0x00, 0x00, 0x67,
654 0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70,
655 0x64, 0x6d, 0x64, 0x64, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
656 0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x00, 0x0c,
657 0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x58, 0x00, 0x00, 0x00, 0x67,
658 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x24,
659 0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xe4, 0x00, 0x00, 0x00, 0x14,
660 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x24,
661 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x04, 0x1c, 0x00, 0x00, 0x00, 0x14,
662 0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x14,
663 0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x04, 0x44, 0x00, 0x00, 0x00, 0x14,
664 0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x04, 0x58, 0x00, 0x00, 0x00, 0x14,
665 0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x04, 0x6c, 0x00, 0x00, 0x00, 0x14,
666 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x08, 0x0c,
667 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x08, 0x0c,
668 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x08, 0x0c,
669 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,
670 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36,
671 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x28, 0x45, 0x71, 0x75, 0x69, 0x76,
672 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x77, 0x77, 0x77,
673 0x2e, 0x73, 0x72, 0x67, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x20, 0x31, 0x39,
674 0x39, 0x38, 0x20, 0x48, 0x50, 0x20, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c,
675 0x65, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
676 0x00, 0x3f, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31,
677 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x28, 0x45, 0x71, 0x75,
678 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x77,
679 0x77, 0x77, 0x2e, 0x73, 0x72, 0x67, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x20,
680 0x31, 0x39, 0x39, 0x38, 0x20, 0x48, 0x50, 0x20, 0x70, 0x72, 0x6f, 0x66,
681 0x69, 0x6c, 0x65, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
682 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x72, 0x65, 0x61,
683 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x47, 0x72, 0x61, 0x65, 0x6d,
684 0x65, 0x20, 0x57, 0x2e, 0x20, 0x47, 0x69, 0x6c, 0x6c, 0x2e, 0x20, 0x52,
685 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x74, 0x6f,
686 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20,
687 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x2e, 0x20, 0x4e, 0x6f, 0x20, 0x57,
688 0x61, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x79, 0x2c, 0x20, 0x55, 0x73, 0x65,
689 0x20, 0x61, 0x74, 0x20, 0x79, 0x6f, 0x75, 0x72, 0x20, 0x6f, 0x77, 0x6e,
690 0x20, 0x72, 0x69, 0x73, 0x6b, 0x2e, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
691 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20,
692 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
693 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
694 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
695 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e,
696 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
697 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
698 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
699 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
700 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
701 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
702 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
703 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61,
704 0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
705 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43,
706 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
707 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63,
708 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
709 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
710 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
711 0x00, 0x00, 0x00, 0x00, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
712 0x43, 0x52, 0x54, 0x20, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
713 0x00, 0x00, 0x00, 0x0d, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36,
714 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
715 0x00, 0x00, 0x00, 0x0d, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36,
716 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
717 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
718 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
719 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
720 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
721 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0x7c,
722 0x00, 0x14, 0x5f, 0x30, 0x00, 0x10, 0xce, 0x02, 0x00, 0x03, 0xed, 0xb2,
723 0x00, 0x04, 0x13, 0x0a, 0x00, 0x03, 0x5c, 0x67, 0x00, 0x00, 0x00, 0x01,
724 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x0a, 0x3d,
725 0x00, 0x50, 0x00, 0x00, 0x00, 0x57, 0x1e, 0xb8, 0x6d, 0x65, 0x61, 0x73,
726 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
727 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
728 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02, 0x58, 0x59, 0x5a, 0x20,
729 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
730 0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
731 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
732 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xa0,
733 0x00, 0x00, 0x38, 0xf5, 0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
734 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x97, 0x00, 0x00, 0xb7, 0x87,
735 0x00, 0x00, 0x18, 0xd9, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
736 0x00, 0x00, 0x24, 0x9f, 0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0xb6, 0xc4,
737 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
738 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f, 0x00, 0x14, 0x00, 0x19,
739 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
740 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a, 0x00, 0x4f, 0x00, 0x54,
741 0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
742 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86, 0x00, 0x8b, 0x00, 0x90,
743 0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
744 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1, 0x00, 0xc6, 0x00, 0xcb,
745 0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
746 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01, 0x01, 0x07, 0x01, 0x0d,
747 0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
748 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c, 0x01, 0x52, 0x01, 0x59,
749 0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
750 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1, 0x01, 0xa9, 0x01, 0xb1,
751 0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
752 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03, 0x02, 0x0c, 0x02, 0x14,
753 0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
754 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71, 0x02, 0x7a, 0x02, 0x84,
755 0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
756 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb, 0x02, 0xf5, 0x03, 0x00,
757 0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
758 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72, 0x03, 0x7e, 0x03, 0x8a,
759 0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
760 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06, 0x04, 0x13, 0x04, 0x20,
761 0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
762 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8, 0x04, 0xb6, 0x04, 0xc4,
763 0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
764 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58, 0x05, 0x67, 0x05, 0x77,
765 0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
766 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16, 0x06, 0x27, 0x06, 0x37,
767 0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
768 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3, 0x06, 0xf5, 0x07, 0x07,
769 0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
770 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf, 0x07, 0xd2, 0x07, 0xe5,
771 0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
772 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa, 0x08, 0xbe, 0x08, 0xd2,
773 0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
774 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4, 0x09, 0xba, 0x09, 0xcf,
775 0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
776 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae, 0x0a, 0xc5, 0x0a, 0xdc,
777 0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
778 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8, 0x0b, 0xe1, 0x0b, 0xf9,
779 0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
780 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3, 0x0d, 0x0d, 0x0d, 0x26,
781 0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
782 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e, 0x0e, 0x49, 0x0e, 0x64,
783 0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
784 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a, 0x0f, 0x96, 0x0f, 0xb3,
785 0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
786 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7, 0x10, 0xf5, 0x11, 0x13,
787 0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
788 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45, 0x12, 0x64, 0x12, 0x84,
789 0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
790 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5, 0x13, 0xe5, 0x14, 0x06,
791 0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
792 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56, 0x15, 0x78, 0x15, 0x9b,
793 0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
794 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa, 0x17, 0x1d, 0x17, 0x41,
795 0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
796 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf, 0x18, 0xd5, 0x18, 0xfa,
797 0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
798 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77, 0x1a, 0x9e, 0x1a, 0xc5,
799 0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
800 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52, 0x1c, 0x7b, 0x1c, 0xa3,
801 0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
802 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40, 0x1e, 0x6a, 0x1e, 0x94,
803 0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
804 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41, 0x20, 0x6c, 0x20, 0x98,
805 0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
806 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55, 0x22, 0x82, 0x22, 0xaf,
807 0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
808 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c, 0x24, 0xab, 0x24, 0xda,
809 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
810 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7, 0x26, 0xe8, 0x27, 0x18,
811 0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
812 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06, 0x29, 0x38, 0x29, 0x6b,
813 0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
814 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69, 0x2b, 0x9d, 0x2b, 0xd1,
815 0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
816 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1, 0x2e, 0x16, 0x2e, 0x4c,
817 0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
818 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c, 0x30, 0xa4, 0x30, 0xdb,
819 0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
820 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d, 0x33, 0x46, 0x33, 0x7f,
821 0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
822 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2, 0x35, 0xfd, 0x36, 0x37,
823 0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
824 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c, 0x38, 0xc8, 0x39, 0x05,
825 0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
826 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b, 0x3b, 0xaa, 0x3b, 0xe8,
827 0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
828 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60, 0x3e, 0xa0, 0x3e, 0xe0,
829 0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
830 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a, 0x41, 0xac, 0x41, 0xee,
831 0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
832 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a, 0x44, 0xce, 0x45, 0x12,
833 0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
834 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0, 0x48, 0x05, 0x48, 0x4b,
835 0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
836 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c, 0x4b, 0x53, 0x4b, 0x9a,
837 0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
838 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e, 0x4e, 0xb7, 0x4f, 0x00,
839 0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
840 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6, 0x52, 0x31, 0x52, 0x7c,
841 0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
842 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75, 0x55, 0xc2, 0x56, 0x0f,
843 0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
844 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a, 0x59, 0x69, 0x59, 0xb8,
845 0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
846 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6, 0x5d, 0x27, 0x5d, 0x78,
847 0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
848 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa, 0x60, 0xfc, 0x61, 0x4f,
849 0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
850 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94, 0x64, 0xe9, 0x65, 0x3d,
851 0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
852 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96, 0x68, 0xec, 0x69, 0x43,
853 0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
854 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf, 0x6d, 0x08, 0x6d, 0x60,
855 0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
856 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0, 0x71, 0x3a, 0x71, 0x95,
857 0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
858 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28, 0x75, 0x85, 0x75, 0xe1,
859 0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
860 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89, 0x79, 0xe7, 0x7a, 0x46,
861 0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
862 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01, 0x7e, 0x62, 0x7e, 0xc2,
863 0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
864 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92, 0x82, 0xf4, 0x83, 0x57,
865 0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
866 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b, 0x87, 0x9f, 0x88, 0x04,
867 0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
868 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc, 0x8c, 0x63, 0x8c, 0xca,
869 0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
870 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6, 0x91, 0x3f, 0x91, 0xa8,
871 0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
872 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9, 0x96, 0x34, 0x96, 0x9f,
873 0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
874 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5, 0x9b, 0x42, 0x9b, 0xaf,
875 0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
876 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa, 0xa0, 0x69, 0xa0, 0xd8,
877 0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
878 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38, 0xa5, 0xa9, 0xa6, 0x1a,
879 0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
880 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f, 0xab, 0x02, 0xab, 0x75,
881 0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
882 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00, 0xb0, 0x75, 0xb0, 0xea,
883 0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
884 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a, 0xb6, 0x01, 0xb6, 0x79,
885 0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
886 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e, 0xbb, 0xa7, 0xbc, 0x21,
887 0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
888 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec, 0xc1, 0x67, 0xc1, 0xe3,
889 0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
890 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3, 0xc7, 0x41, 0xc7, 0xbf,
891 0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
892 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5, 0xcd, 0x35, 0xcd, 0xb5,
893 0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
894 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1, 0xd3, 0x44, 0xd3, 0xc6,
895 0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
896 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8, 0xd9, 0x6c, 0xd9, 0xf1,
897 0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
898 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29, 0xdf, 0xaf, 0xe0, 0x36,
899 0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
900 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84, 0xe6, 0x0d, 0xe6, 0x96,
901 0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
902 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb, 0xec, 0x86, 0xed, 0x11,
903 0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
904 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c, 0xf3, 0x19, 0xf3, 0xa7,
905 0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
906 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38, 0xf9, 0xc7, 0xfa, 0x57,
907 0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
908 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
909 };
910
911 StringInfo
912 *profile;
913
914 assert(image != (Image *) NULL);
915 assert(image->signature == MagickCoreSignature);
916 if (GetImageProfile(image,"icc") != (const StringInfo *) NULL)
917 return;
918 profile=BlobToProfileStringInfo("icc",sRGBProfile,sizeof(sRGBProfile),
919 exception);
920 (void) SetImageProfilePrivate(image,profile,exception);
921}
922
923MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
924 const void *datum,const size_t length,ExceptionInfo *exception)
925{
926#define ProfileImageTag "Profile/Image"
927#ifndef TYPE_XYZ_8
928 #define TYPE_XYZ_8 (COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(1))
929#endif
930#define ThrowProfileException(severity,tag,context) \
931{ \
932 if (profile != (StringInfo *) NULL) \
933 profile=DestroyStringInfo(profile); \
934 if (cms_context != (cmsContext) NULL) \
935 cmsDeleteContext(cms_context); \
936 if (source_info.profile != (cmsHPROFILE) NULL) \
937 (void) cmsCloseProfile(source_info.profile); \
938 if (target_info.profile != (cmsHPROFILE) NULL) \
939 (void) cmsCloseProfile(target_info.profile); \
940 ThrowBinaryException(severity,tag,context); \
941}
942
943 MagickBooleanType
944 status;
945
946 StringInfo
947 *profile;
948
949 assert(image != (Image *) NULL);
950 assert(image->signature == MagickCoreSignature);
951 assert(name != (const char *) NULL);
952 if (IsEventLogging() != MagickFalse)
953 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
954 if ((datum == (const void *) NULL) || (length == 0))
955 {
956 char
957 *next;
958
959 /*
960 Delete image profile(s).
961 */
962 ResetImageProfileIterator(image);
963 for (next=GetNextImageProfile(image); next != (const char *) NULL; )
964 {
965 if (IsOptionMember(next,name) != MagickFalse)
966 {
967 (void) DeleteImageProfile(image,next);
968 ResetImageProfileIterator(image);
969 }
970 next=GetNextImageProfile(image);
971 }
972 return(MagickTrue);
973 }
974 /*
975 Add a ICC, IPTC, or generic profile to the image.
976 */
977 status=MagickTrue;
978 profile=AcquireProfileStringInfo(name,(size_t) length,exception);
979 if (profile == (StringInfo *) NULL)
980 return(MagickFalse);
981 SetStringInfoDatum(profile,(unsigned char *) datum);
982 if ((LocaleCompare(name,"icc") != 0) && (LocaleCompare(name,"icm") != 0))
983 status=SetImageProfilePrivate(image,profile,exception);
984 else
985 {
986 const StringInfo
987 *icc_profile;
988
989 icc_profile=GetImageProfile(image,"icc");
990 if ((icc_profile != (const StringInfo *) NULL) &&
991 (CompareStringInfo(icc_profile,profile) == 0))
992 {
993 const char
994 *value;
995
996 value=GetImageProperty(image,"exif:ColorSpace",exception);
997 (void) value;
998 if (LocaleCompare(value,"1") != 0)
999 SetsRGBImageProfile(image,exception);
1000 value=GetImageProperty(image,"exif:InteroperabilityIndex",exception);
1001 if (LocaleCompare(value,"R98.") != 0)
1002 SetsRGBImageProfile(image,exception);
1003 icc_profile=GetImageProfile(image,"icc");
1004 }
1005 if ((icc_profile != (const StringInfo *) NULL) &&
1006 (CompareStringInfo(icc_profile,profile) == 0))
1007 {
1008 profile=DestroyStringInfo(profile);
1009 return(MagickTrue);
1010 }
1011#if !defined(MAGICKCORE_LCMS_DELEGATE)
1012 (void) ThrowMagickException(exception,GetMagickModule(),
1013 MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn",
1014 "'%s' (LCMS)",image->filename);
1015#else
1016 {
1017 cmsContext
1018 cms_context;
1019
1020 CMSExceptionInfo
1021 cms_exception;
1022
1023 LCMSInfo
1024 source_info,
1025 target_info;
1026
1027 /*
1028 Transform pixel colors as defined by the color profiles.
1029 */
1030 cms_exception.image=image;
1031 cms_exception.exception=exception;
1032 cms_context=cmsCreateContext(NULL,&cms_exception);
1033 if (cms_context == (cmsContext) NULL)
1034 {
1035 profile=DestroyStringInfo(profile);
1036 ThrowBinaryException(ResourceLimitError,
1037 "ColorspaceColorProfileMismatch",name);
1038 }
1039 cmsSetLogErrorHandlerTHR(cms_context,CMSExceptionHandler);
1040 source_info.profile=cmsOpenProfileFromMemTHR(cms_context,
1041 GetStringInfoDatum(profile),(cmsUInt32Number)
1042 GetStringInfoLength(profile));
1043 if (source_info.profile == (cmsHPROFILE) NULL)
1044 {
1045 profile=DestroyStringInfo(profile);
1046 cmsDeleteContext(cms_context);
1047 ThrowBinaryException(ResourceLimitError,
1048 "ColorspaceColorProfileMismatch",name);
1049 }
1050 if ((cmsGetDeviceClass(source_info.profile) != cmsSigLinkClass) &&
1051 (icc_profile == (StringInfo *) NULL))
1052 status=SetImageProfilePrivate(image,profile,exception);
1053 else
1054 {
1055 CacheView
1056 *image_view;
1057
1058 cmsColorSpaceSignature
1059 signature;
1060
1061 cmsHTRANSFORM
1062 *magick_restrict transform;
1063
1064 cmsUInt32Number
1065 flags;
1066
1067 MagickBooleanType
1068 highres;
1069
1070 MagickOffsetType
1071 progress;
1072
1073 ssize_t
1074 y;
1075
1076 target_info.profile=(cmsHPROFILE) NULL;
1077 if (icc_profile != (StringInfo *) NULL)
1078 {
1079 target_info.profile=source_info.profile;
1080 source_info.profile=cmsOpenProfileFromMemTHR(cms_context,
1081 GetStringInfoDatum(icc_profile),(cmsUInt32Number)
1082 GetStringInfoLength(icc_profile));
1083 if (source_info.profile == (cmsHPROFILE) NULL)
1084 ThrowProfileException(ResourceLimitError,
1085 "ColorspaceColorProfileMismatch",name);
1086 }
1087 highres=MagickTrue;
1088#if !defined(MAGICKCORE_HDRI_SUPPORT) || (MAGICKCORE_QUANTUM_DEPTH > 16)
1089 {
1090 const char
1091 *artifact;
1092
1093 artifact=GetImageArtifact(image,"profile:highres-transform");
1094 if (IsStringFalse(artifact) != MagickFalse)
1095 highres=MagickFalse;
1096 }
1097#endif
1098 SetLCMSInfoScale(&source_info,1.0);
1099 SetLCMSInfoTranslate(&source_info,0.0);
1100 source_info.colorspace=sRGBColorspace;
1101 source_info.channels=3;
1102 switch (cmsGetColorSpace(source_info.profile))
1103 {
1104 case cmsSigCmykData:
1105 {
1106 source_info.colorspace=CMYKColorspace;
1107 source_info.channels=4;
1108 if (highres != MagickFalse)
1109 {
1110 source_info.type=(cmsUInt32Number) TYPE_CMYK_DBL;
1111 SetLCMSInfoScale(&source_info,100.0);
1112 }
1113#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1114 else
1115 source_info.type=(cmsUInt32Number) TYPE_CMYK_8;
1116#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1117 else
1118 source_info.type=(cmsUInt32Number) TYPE_CMYK_16;
1119#endif
1120 break;
1121 }
1122 case cmsSigGrayData:
1123 {
1124 source_info.colorspace=GRAYColorspace;
1125 source_info.channels=1;
1126 if (highres != MagickFalse)
1127 source_info.type=(cmsUInt32Number) TYPE_GRAY_DBL;
1128#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1129 else
1130 source_info.type=(cmsUInt32Number) TYPE_GRAY_8;
1131#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1132 else
1133 source_info.type=(cmsUInt32Number) TYPE_GRAY_16;
1134#endif
1135 break;
1136 }
1137 case cmsSigLabData:
1138 {
1139 source_info.colorspace=LabColorspace;
1140 if (highres != MagickFalse)
1141 {
1142 source_info.type=(cmsUInt32Number) TYPE_Lab_DBL;
1143 source_info.scale[0]=100.0;
1144 source_info.scale[1]=255.0;
1145 source_info.scale[2]=255.0;
1146#if !defined(MAGICKCORE_HDRI_SUPPORT)
1147 source_info.translate[1]=(-0.5);
1148 source_info.translate[2]=(-0.5);
1149#endif
1150 }
1151#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1152 else
1153 source_info.type=(cmsUInt32Number) TYPE_Lab_8;
1154#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1155 else
1156 source_info.type=(cmsUInt32Number) TYPE_Lab_16;
1157#endif
1158 break;
1159 }
1160 case cmsSigRgbData:
1161 {
1162 source_info.colorspace=sRGBColorspace;
1163 if (highres != MagickFalse)
1164 source_info.type=(cmsUInt32Number) TYPE_RGB_DBL;
1165#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1166 else
1167 source_info.type=(cmsUInt32Number) TYPE_RGB_8;
1168#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1169 else
1170 source_info.type=(cmsUInt32Number) TYPE_RGB_16;
1171#endif
1172 break;
1173 }
1174 case cmsSigXYZData:
1175 {
1176 source_info.colorspace=XYZColorspace;
1177 if (highres != MagickFalse)
1178 source_info.type=(cmsUInt32Number) TYPE_XYZ_DBL;
1179#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1180 else
1181 source_info.type=(cmsUInt32Number) TYPE_XYZ_8;
1182#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1183 else
1184 source_info.type=(cmsUInt32Number) TYPE_XYZ_16;
1185#endif
1186 break;
1187 }
1188 default:
1189 ThrowProfileException(ImageError,
1190 "ColorspaceColorProfileMismatch",name);
1191 }
1192 signature=cmsGetPCS(source_info.profile);
1193 if (target_info.profile != (cmsHPROFILE) NULL)
1194 signature=cmsGetColorSpace(target_info.profile);
1195 SetLCMSInfoScale(&target_info,1.0);
1196 SetLCMSInfoTranslate(&target_info,0.0);
1197 target_info.channels=3;
1198 switch (signature)
1199 {
1200 case cmsSigCmykData:
1201 {
1202 target_info.colorspace=CMYKColorspace;
1203 target_info.channels=4;
1204 if (highres != MagickFalse)
1205 {
1206 target_info.type=(cmsUInt32Number) TYPE_CMYK_DBL;
1207 SetLCMSInfoScale(&target_info,0.01);
1208 }
1209#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1210 else
1211 target_info.type=(cmsUInt32Number) TYPE_CMYK_8;
1212#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1213 else
1214 target_info.type=(cmsUInt32Number) TYPE_CMYK_16;
1215#endif
1216 break;
1217 }
1218 case cmsSigGrayData:
1219 {
1220 target_info.colorspace=GRAYColorspace;
1221 target_info.channels=1;
1222 if (highres != MagickFalse)
1223 target_info.type=(cmsUInt32Number) TYPE_GRAY_DBL;
1224#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1225 else
1226 target_info.type=(cmsUInt32Number) TYPE_GRAY_8;
1227#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1228 else
1229 target_info.type=(cmsUInt32Number) TYPE_GRAY_16;
1230#endif
1231 break;
1232 }
1233 case cmsSigLabData:
1234 {
1235 target_info.colorspace=LabColorspace;
1236 if (highres != MagickFalse)
1237 {
1238 target_info.type=(cmsUInt32Number) TYPE_Lab_DBL;
1239 target_info.scale[0]=0.01;
1240 target_info.scale[1]=1/255.0;
1241 target_info.scale[2]=1/255.0;
1242#if !defined(MAGICKCORE_HDRI_SUPPORT)
1243 target_info.translate[1]=0.5;
1244 target_info.translate[2]=0.5;
1245#endif
1246 }
1247#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1248 else
1249 target_info.type=(cmsUInt32Number) TYPE_Lab_8;
1250#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1251 else
1252 target_info.type=(cmsUInt32Number) TYPE_Lab_16;
1253#endif
1254 break;
1255 }
1256 case cmsSigRgbData:
1257 {
1258 target_info.colorspace=sRGBColorspace;
1259 if (highres != MagickFalse)
1260 target_info.type=(cmsUInt32Number) TYPE_RGB_DBL;
1261#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1262 else
1263 target_info.type=(cmsUInt32Number) TYPE_RGB_8;
1264#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1265 else
1266 target_info.type=(cmsUInt32Number) TYPE_RGB_16;
1267#endif
1268 break;
1269 }
1270 case cmsSigXYZData:
1271 {
1272 target_info.colorspace=XYZColorspace;
1273 if (highres != MagickFalse)
1274 target_info.type=(cmsUInt32Number) TYPE_XYZ_DBL;
1275#if (MAGICKCORE_QUANTUM_DEPTH == 8)
1276 else
1277 target_info.type=(cmsUInt32Number) TYPE_XYZ_8;
1278#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
1279 else
1280 source_info.type=(cmsUInt32Number) TYPE_XYZ_16;
1281#endif
1282 break;
1283 }
1284 default:
1285 ThrowProfileException(ImageError,
1286 "ColorspaceColorProfileMismatch",name);
1287 }
1288 switch (image->rendering_intent)
1289 {
1290 case AbsoluteIntent:
1291 {
1292 target_info.intent=INTENT_ABSOLUTE_COLORIMETRIC;
1293 break;
1294 }
1295 case PerceptualIntent:
1296 {
1297 target_info.intent=INTENT_PERCEPTUAL;
1298 break;
1299 }
1300 case RelativeIntent:
1301 {
1302 target_info.intent=INTENT_RELATIVE_COLORIMETRIC;
1303 break;
1304 }
1305 case SaturationIntent:
1306 {
1307 target_info.intent=INTENT_SATURATION;
1308 break;
1309 }
1310 default:
1311 {
1312 target_info.intent=INTENT_PERCEPTUAL;
1313 break;
1314 }
1315 }
1316 flags=cmsFLAGS_HIGHRESPRECALC;
1317#if defined(cmsFLAGS_BLACKPOINTCOMPENSATION)
1318 if (image->black_point_compensation != MagickFalse)
1319 flags|=cmsFLAGS_BLACKPOINTCOMPENSATION;
1320#endif
1321 transform=AcquireTransformTLS(&source_info,&target_info,flags,
1322 cms_context);
1323 if (transform == (cmsHTRANSFORM *) NULL)
1324 ThrowProfileException(ImageError,"UnableToCreateColorTransform",
1325 name);
1326 /*
1327 Transform image as dictated by the source & target image profiles.
1328 */
1329 source_info.pixels=AcquirePixelTLS(image->columns,
1330 source_info.channels,highres);
1331 target_info.pixels=AcquirePixelTLS(image->columns,
1332 target_info.channels,highres);
1333 if ((source_info.pixels == (void **) NULL) ||
1334 (target_info.pixels == (void **) NULL))
1335 {
1336 target_info.pixels=DestroyPixelTLS(target_info.pixels);
1337 source_info.pixels=DestroyPixelTLS(source_info.pixels);
1338 transform=DestroyTransformTLS(transform);
1339 ThrowProfileException(ResourceLimitError,
1340 "MemoryAllocationFailed",image->filename);
1341 }
1342 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1343 {
1344 target_info.pixels=DestroyPixelTLS(target_info.pixels);
1345 source_info.pixels=DestroyPixelTLS(source_info.pixels);
1346 transform=DestroyTransformTLS(transform);
1347 if (source_info.profile != (cmsHPROFILE) NULL)
1348 (void) cmsCloseProfile(source_info.profile);
1349 if (target_info.profile != (cmsHPROFILE) NULL)
1350 (void) cmsCloseProfile(target_info.profile);
1351 return(MagickFalse);
1352 }
1353 if (target_info.colorspace == CMYKColorspace)
1354 (void) SetImageColorspace(image,target_info.colorspace,exception);
1355 progress=0;
1356 image_view=AcquireAuthenticCacheView(image,exception);
1357#if defined(MAGICKCORE_OPENMP_SUPPORT)
1358 #pragma omp parallel for schedule(static) shared(status) \
1359 magick_number_threads(image,image,image->rows,1)
1360#endif
1361 for (y=0; y < (ssize_t) image->rows; y++)
1362 {
1363 const int
1364 id = GetOpenMPThreadId();
1365
1366 MagickBooleanType
1367 sync;
1368
1369 Quantum
1370 *magick_restrict q;
1371
1372 if (status == MagickFalse)
1373 continue;
1374 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1375 exception);
1376 if (q == (Quantum *) NULL)
1377 {
1378 status=MagickFalse;
1379 continue;
1380 }
1381 if (highres != MagickFalse)
1382 TransformDoublePixels(id,image,&source_info,&target_info,
1383 transform,q);
1384 else
1385 TransformQuantumPixels(id,image,&source_info,&target_info,
1386 transform,q);
1387 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1388 if (sync == MagickFalse)
1389 status=MagickFalse;
1390 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1391 {
1392 MagickBooleanType
1393 proceed;
1394
1395#if defined(MAGICKCORE_OPENMP_SUPPORT)
1396 #pragma omp atomic
1397#endif
1398 progress++;
1399 proceed=SetImageProgress(image,ProfileImageTag,progress,
1400 image->rows);
1401 if (proceed == MagickFalse)
1402 status=MagickFalse;
1403 }
1404 }
1405 image_view=DestroyCacheView(image_view);
1406 (void) SetImageColorspace(image,target_info.colorspace,exception);
1407 switch (signature)
1408 {
1409 case cmsSigRgbData:
1410 {
1411 image->type=image->alpha_trait == UndefinedPixelTrait ?
1412 TrueColorType : TrueColorAlphaType;
1413 break;
1414 }
1415 case cmsSigCmykData:
1416 {
1417 image->type=image->alpha_trait == UndefinedPixelTrait ?
1418 ColorSeparationType : ColorSeparationAlphaType;
1419 break;
1420 }
1421 case cmsSigGrayData:
1422 {
1423 image->type=image->alpha_trait == UndefinedPixelTrait ?
1424 GrayscaleType : GrayscaleAlphaType;
1425 break;
1426 }
1427 default:
1428 break;
1429 }
1430 target_info.pixels=DestroyPixelTLS(target_info.pixels);
1431 source_info.pixels=DestroyPixelTLS(source_info.pixels);
1432 transform=DestroyTransformTLS(transform);
1433 if ((status != MagickFalse) &&
1434 (cmsGetDeviceClass(source_info.profile) != cmsSigLinkClass))
1435 status=SetImageProfilePrivate(image,profile,exception);
1436 if (target_info.profile != (cmsHPROFILE) NULL)
1437 (void) cmsCloseProfile(target_info.profile);
1438 }
1439 (void) cmsCloseProfile(source_info.profile);
1440 cmsDeleteContext(cms_context);
1441 }
1442#endif
1443 }
1444 return(status);
1445}
1446␌
1447/*
1448%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1449% %
1450% %
1451% %
1452% R e m o v e I m a g e P r o f i l e %
1453% %
1454% %
1455% %
1456%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1457%
1458% RemoveImageProfile() removes a named profile from the image and returns its
1459% value.
1460%
1461% The format of the RemoveImageProfile method is:
1462%
1463% void *RemoveImageProfile(Image *image,const char *name)
1464%
1465% A description of each parameter follows:
1466%
1467% o image: the image.
1468%
1469% o name: the profile name.
1470%
1471*/
1472MagickExport StringInfo *RemoveImageProfile(Image *image,const char *name)
1473{
1474 StringInfo
1475 *profile;
1476
1477 assert(image != (Image *) NULL);
1478 assert(image->signature == MagickCoreSignature);
1479 if (IsEventLogging() != MagickFalse)
1480 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1481 if (image->profiles == (SplayTreeInfo *) NULL)
1482 return((StringInfo *) NULL);
1483 WriteTo8BimProfile(image,name,(StringInfo *) NULL);
1484 profile=(StringInfo *) RemoveNodeFromSplayTree((SplayTreeInfo *)
1485 image->profiles,name);
1486 return(profile);
1487}
1488␌
1489/*
1490%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1491% %
1492% %
1493% %
1494% R e s e t P r o f i l e I t e r a t o r %
1495% %
1496% %
1497% %
1498%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1499%
1500% ResetImageProfileIterator() resets the image profile iterator. Use it in
1501% conjunction with GetNextImageProfile() to iterate over all the profiles
1502% associated with an image.
1503%
1504% The format of the ResetImageProfileIterator method is:
1505%
1506% ResetImageProfileIterator(Image *image)
1507%
1508% A description of each parameter follows:
1509%
1510% o image: the image.
1511%
1512*/
1513MagickExport void ResetImageProfileIterator(const Image *image)
1514{
1515 assert(image != (Image *) NULL);
1516 assert(image->signature == MagickCoreSignature);
1517 if (IsEventLogging() != MagickFalse)
1518 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1519 if (image->profiles == (SplayTreeInfo *) NULL)
1520 return;
1521 ResetSplayTreeIterator((SplayTreeInfo *) image->profiles);
1522}
1523␌
1524/*
1525%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1526% %
1527% %
1528% %
1529% S e t I m a g e P r o f i l e %
1530% %
1531% %
1532% %
1533%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1534%
1535% SetImageProfile() adds a named profile to the image. If a profile with the
1536% same name already exists, it is replaced. This method differs from the
1537% ProfileImage() method in that it does not apply CMS color profiles.
1538%
1539% The format of the SetImageProfile method is:
1540%
1541% MagickBooleanType SetImageProfile(Image *image,const char *name,
1542% const StringInfo *profile)
1543%
1544% A description of each parameter follows:
1545%
1546% o image: the image.
1547%
1548% o name: the profile name, for example icc, exif, and 8bim (8bim is the
1549% Photoshop wrapper for iptc profiles).
1550%
1551% o profile: A StringInfo structure that contains the named profile.
1552%
1553*/
1554
1555static void *DestroyProfile(void *profile)
1556{
1557 return((void *) DestroyStringInfo((StringInfo *) profile));
1558}
1559
1560static inline const unsigned char *ReadResourceByte(const unsigned char *p,
1561 unsigned char *quantum)
1562{
1563 *quantum=(*p++);
1564 return(p);
1565}
1566
1567static inline const unsigned char *ReadResourceLong(const unsigned char *p,
1568 unsigned int *quantum)
1569{
1570 *quantum=(unsigned int) (*p++) << 24;
1571 *quantum|=(unsigned int) (*p++) << 16;
1572 *quantum|=(unsigned int) (*p++) << 8;
1573 *quantum|=(unsigned int) (*p++);
1574 return(p);
1575}
1576
1577static inline const unsigned char *ReadResourceShort(const unsigned char *p,
1578 unsigned short *quantum)
1579{
1580 *quantum=(unsigned short) (*p++) << 8;
1581 *quantum|=(unsigned short) (*p++);
1582 return(p);
1583}
1584
1585static inline void WriteResourceLong(unsigned char *p,
1586 const unsigned int quantum)
1587{
1588 unsigned char
1589 buffer[4];
1590
1591 buffer[0]=(unsigned char) (quantum >> 24);
1592 buffer[1]=(unsigned char) (quantum >> 16);
1593 buffer[2]=(unsigned char) (quantum >> 8);
1594 buffer[3]=(unsigned char) quantum;
1595 (void) memcpy(p,buffer,4);
1596}
1597
1598static void WriteTo8BimProfile(Image *image,const char *name,
1599 const StringInfo *profile)
1600{
1601 const unsigned char
1602 *datum,
1603 *q;
1604
1605 const unsigned char
1606 *p;
1607
1608 size_t
1609 length;
1610
1611 StringInfo
1612 *profile_8bim;
1613
1614 ssize_t
1615 count;
1616
1617 unsigned char
1618 length_byte;
1619
1620 unsigned int
1621 value;
1622
1623 unsigned short
1624 id,
1625 profile_id;
1626
1627 if (LocaleCompare(name,"icc") == 0)
1628 profile_id=0x040f;
1629 else
1630 if (LocaleCompare(name,"iptc") == 0)
1631 profile_id=0x0404;
1632 else
1633 if (LocaleCompare(name,"xmp") == 0)
1634 profile_id=0x0424;
1635 else
1636 return;
1637 profile_8bim=(StringInfo *) GetValueFromSplayTree((SplayTreeInfo *)
1638 image->profiles,"8bim");
1639 if (profile_8bim == (StringInfo *) NULL)
1640 return;
1641 datum=GetStringInfoDatum(profile_8bim);
1642 length=GetStringInfoLength(profile_8bim);
1643 for (p=datum; p < (datum+length-16); )
1644 {
1645 q=p;
1646 if (LocaleNCompare((char *) p,"8BIM",4) != 0)
1647 break;
1648 p+=4;
1649 p=ReadResourceShort(p,&id);
1650 p=ReadResourceByte(p,&length_byte);
1651 p+=length_byte;
1652 if (((length_byte+1) & 0x01) != 0)
1653 p++;
1654 if (p > (datum+length-4))
1655 break;
1656 p=ReadResourceLong(p,&value);
1657 count=(ssize_t) value;
1658 if ((count & 0x01) != 0)
1659 count++;
1660 if ((count < 0) || (p > (datum+length-count)) || (count > (ssize_t) length))
1661 break;
1662 if (id != profile_id)
1663 p+=count;
1664 else
1665 {
1666 size_t
1667 extent,
1668 offset;
1669
1670 ssize_t
1671 extract_extent;
1672
1673 StringInfo
1674 *extract_profile;
1675
1676 extract_extent=0;
1677 extent=(size_t) ((datum+length)-(p+count));
1678 if (profile == (StringInfo *) NULL)
1679 {
1680 offset=(size_t) (q-datum);
1681 extract_profile=AcquireStringInfo(offset+extent);
1682 (void) memcpy(extract_profile->datum,datum,offset);
1683 }
1684 else
1685 {
1686 offset=(size_t) (p-datum);
1687 extract_extent=(ssize_t) profile->length;
1688 if ((extract_extent & 0x01) != 0)
1689 extract_extent++;
1690 extract_profile=AcquireStringInfo(offset+(size_t) extract_extent+
1691 extent);
1692 (void) memcpy(extract_profile->datum,datum,offset-4);
1693 WriteResourceLong(extract_profile->datum+offset-4,(unsigned int)
1694 profile->length);
1695 (void) memcpy(extract_profile->datum+offset,
1696 profile->datum,profile->length);
1697 }
1698 (void) memcpy(extract_profile->datum+offset+extract_extent,
1699 p+count,extent);
1700 (void) AddValueToSplayTree((SplayTreeInfo *) image->profiles,
1701 ConstantString("8bim"),CloneStringInfo(extract_profile));
1702 extract_profile=DestroyStringInfo(extract_profile);
1703 break;
1704 }
1705 }
1706}
1707
1708static void GetProfilesFromResourceBlock(Image *image,
1709 const StringInfo *resource_block,ExceptionInfo *exception)
1710{
1711 const unsigned char
1712 *datum;
1713
1714 const unsigned char
1715 *p;
1716
1717 size_t
1718 length;
1719
1720 ssize_t
1721 count;
1722
1723 StringInfo
1724 *profile;
1725
1726 unsigned char
1727 length_byte;
1728
1729 unsigned int
1730 value;
1731
1732 unsigned short
1733 id;
1734
1735 datum=GetStringInfoDatum(resource_block);
1736 length=GetStringInfoLength(resource_block);
1737 for (p=datum; p < (datum+length-16); )
1738 {
1739 if (LocaleNCompare((char *) p,"8BIM",4) != 0)
1740 break;
1741 p+=4;
1742 p=ReadResourceShort(p,&id);
1743 p=ReadResourceByte(p,&length_byte);
1744 p+=length_byte;
1745 if (((length_byte+1) & 0x01) != 0)
1746 p++;
1747 if (p > (datum+length-4))
1748 break;
1749 p=ReadResourceLong(p,&value);
1750 count=(ssize_t) value;
1751 if ((p > (datum+length-count)) || (count > (ssize_t) length) ||
1752 (count <= 0))
1753 break;
1754 switch (id)
1755 {
1756 case 0x03ed:
1757 {
1758 unsigned int
1759 resolution;
1760
1761 unsigned short
1762 units;
1763
1764 /*
1765 Resolution.
1766 */
1767 if (count < 10)
1768 break;
1769 p=ReadResourceLong(p,&resolution);
1770 image->resolution.x=((double) resolution)/65536.0;
1771 p=ReadResourceShort(p,&units)+2;
1772 p=ReadResourceLong(p,&resolution)+4;
1773 image->resolution.y=((double) resolution)/65536.0;
1774 /*
1775 Values are always stored as pixels per inch.
1776 */
1777 if ((ResolutionType) units != PixelsPerCentimeterResolution)
1778 image->units=PixelsPerInchResolution;
1779 else
1780 {
1781 image->units=PixelsPerCentimeterResolution;
1782 image->resolution.x/=2.54;
1783 image->resolution.y/=2.54;
1784 }
1785 break;
1786 }
1787 case 0x0404:
1788 {
1789 /*
1790 IPTC profile.
1791 */
1792 profile=BlobToProfileStringInfo("iptc",p,(size_t) count,exception);
1793 if (profile != (StringInfo *) NULL)
1794 (void) SetImageProfileInternal(image,GetStringInfoName(profile),
1795 profile,MagickTrue,exception);
1796 p+=count;
1797 break;
1798 }
1799 case 0x040c:
1800 {
1801 /*
1802 Thumbnail.
1803 */
1804 p+=count;
1805 break;
1806 }
1807 case 0x040f:
1808 {
1809 /*
1810 ICC Profile.
1811 */
1812 profile=BlobToProfileStringInfo("icc",p,(size_t) count,exception);
1813 if (profile != (StringInfo *) NULL)
1814 (void) SetImageProfileInternal(image,GetStringInfoName(profile),
1815 profile,MagickTrue,exception);
1816 p+=count;
1817 break;
1818 }
1819 case 0x0422:
1820 {
1821 /*
1822 EXIF Profile.
1823 */
1824 profile=BlobToProfileStringInfo("exif",p,(size_t) count,exception);
1825 if (profile != (StringInfo *) NULL)
1826 (void) SetImageProfileInternal(image,GetStringInfoName(profile),
1827 profile,MagickTrue,exception);
1828 p+=count;
1829 break;
1830 }
1831 case 0x0424:
1832 {
1833 /*
1834 XMP Profile.
1835 */
1836 profile=BlobToProfileStringInfo("xmp",p,(size_t) count,exception);
1837 if (profile != (StringInfo *) NULL)
1838 (void) SetImageProfileInternal(image,GetStringInfoName(profile),
1839 profile,MagickTrue,exception);
1840 p+=count;
1841 break;
1842 }
1843 default:
1844 {
1845 p+=count;
1846 break;
1847 }
1848 }
1849 if ((count & 0x01) != 0)
1850 p++;
1851 }
1852}
1853
1854static void PatchCorruptProfile(const char *name,StringInfo *profile)
1855{
1856 unsigned char
1857 *p;
1858
1859 size_t
1860 length;
1861
1862 /*
1863 Detect corrupt profiles and if discovered, repair.
1864 */
1865 if (LocaleCompare(name,"xmp") == 0)
1866 {
1867 /*
1868 Remove garbage after xpacket end.
1869 */
1870 p=GetStringInfoDatum(profile);
1871 p=(unsigned char *) strstr((const char *) p,"<?xpacket end=\"w\"?>");
1872 if (p != (unsigned char *) NULL)
1873 {
1874 p+=19;
1875 length=(size_t) (p-GetStringInfoDatum(profile));
1876 if (length != GetStringInfoLength(profile))
1877 {
1878 *p='\0';
1879 SetStringInfoLength(profile,length);
1880 }
1881 }
1882 return;
1883 }
1884 if (LocaleCompare(name,"exif") == 0)
1885 {
1886 /*
1887 Check if profile starts with byte order marker instead of Exif.
1888 */
1889 p=GetStringInfoDatum(profile);
1890 if ((LocaleNCompare((const char *) p,"MM",2) == 0) ||
1891 (LocaleNCompare((const char *) p,"II",2) == 0))
1892 {
1893 const unsigned char
1894 profile_start[] = "Exif\0\0";
1895
1896 StringInfo
1897 *exif_profile;
1898
1899 exif_profile=AcquireStringInfo(6);
1900 if (exif_profile != (StringInfo *) NULL)
1901 {
1902 SetStringInfoDatum(exif_profile,profile_start);
1903 ConcatenateStringInfo(exif_profile,profile);
1904 SetStringInfoLength(profile,GetStringInfoLength(exif_profile));
1905 SetStringInfo(profile,exif_profile);
1906 exif_profile=DestroyStringInfo(exif_profile);
1907 }
1908 }
1909 }
1910}
1911
1912static MagickBooleanType ValidateXMPProfile(Image *image,
1913 const StringInfo *profile,ExceptionInfo *exception)
1914{
1915#if defined(MAGICKCORE_XML_DELEGATE)
1916 xmlDocPtr
1917 document;
1918
1919 /*
1920 Validate XMP profile.
1921 */
1922 const char *artifact=GetImageArtifact(image,"xmp:validate");
1923 if (IsStringTrue(artifact) == MagickFalse)
1924 return(MagickTrue);
1925 document=xmlReadMemory((const char *) GetStringInfoDatum(profile),(int)
1926 GetStringInfoLength(profile),"xmp.xml",NULL,XML_PARSE_NOERROR |
1927 XML_PARSE_NOWARNING);
1928 if (document == (xmlDocPtr) NULL)
1929 {
1930 (void) ThrowMagickException(exception,GetMagickModule(),ImageWarning,
1931 "CorruptImageProfile","`%s' (XMP)",image->filename);
1932 return(MagickFalse);
1933 }
1934 xmlFreeDoc(document);
1935 return(MagickTrue);
1936#else
1937 (void) profile;
1938 (void) ThrowMagickException(exception,GetMagickModule(),
1939 MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (XML)",
1940 image->filename);
1941 return(MagickFalse);
1942#endif
1943}
1944
1945static MagickBooleanType SetImageProfileInternal(Image *image,const char *name,
1946 StringInfo *profile,const MagickBooleanType recursive,
1947 ExceptionInfo *exception)
1948{
1949 char
1950 key[MagickPathExtent];
1951
1952 MagickBooleanType
1953 status;
1954
1955 size_t
1956 length;
1957
1958 assert(image != (Image *) NULL);
1959 assert(image->signature == MagickCoreSignature);
1960 assert(profile != (StringInfo *) NULL);
1961 assert(name != (const char *) NULL);
1962 if (IsEventLogging() != MagickFalse)
1963 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1964 length=GetStringInfoLength(profile);
1965 if ((length == 0) || (length > GetMaxProfileSize()))
1966 {
1967 if (length != 0)
1968 (void) ThrowMagickException(exception,GetMagickModule(),
1969 ResourceLimitWarning,"ProfileSizeExceedsLimit","`%llu'",
1970 (unsigned long long) length);
1971 profile=DestroyStringInfo(profile);
1972 return(MagickTrue);
1973 }
1974 PatchCorruptProfile(name,profile);
1975 if ((LocaleCompare(name,"xmp") == 0) &&
1976 (ValidateXMPProfile(image,profile,exception) == MagickFalse))
1977 {
1978 profile=DestroyStringInfo(profile);
1979 return(MagickTrue);
1980 }
1981 if (image->profiles == (SplayTreeInfo *) NULL)
1982 image->profiles=NewSplayTree(CompareSplayTreeString,RelinquishMagickMemory,
1983 DestroyProfile);
1984 (void) CopyMagickString(key,name,MagickPathExtent);
1985 LocaleLower(key);
1986 status=AddValueToSplayTree((SplayTreeInfo *) image->profiles,
1987 ConstantString(key),profile);
1988 if (status == MagickFalse)
1989 profile=DestroyStringInfo(profile);
1990 else
1991 {
1992 if (LocaleCompare(name,"8bim") == 0)
1993 GetProfilesFromResourceBlock(image,profile,exception);
1994 else
1995 if (recursive == MagickFalse)
1996 WriteTo8BimProfile(image,name,profile);
1997 }
1998 return(status);
1999}
2000
2001MagickExport StringInfo *AcquireProfileStringInfo(const char *name,
2002 const size_t length,ExceptionInfo *exception)
2003{
2004 StringInfo
2005 *profile = (StringInfo *) NULL;
2006
2007 if (length > GetMaxProfileSize())
2008 (void) ThrowMagickException(exception,GetMagickModule(),
2009 ResourceLimitWarning,"ProfileSizeExceedsLimit","`%llu'",
2010 (unsigned long long) length);
2011 else
2012 {
2013 profile=AcquireStringInfo(length);
2014 SetStringInfoName(profile,name);
2015 }
2016 return(profile);
2017}
2018
2019MagickExport StringInfo *BlobToProfileStringInfo(const char *name,
2020 const void *blob,const size_t length,ExceptionInfo *exception)
2021{
2022 StringInfo
2023 *profile;
2024
2025 profile=AcquireProfileStringInfo(name,length,exception);
2026 if (profile != (const StringInfo *) NULL)
2027 (void) memcpy(profile->datum,blob,length);
2028 return(profile);
2029}
2030
2031MagickExport MagickBooleanType SetImageProfile(Image *image,const char *name,
2032 const StringInfo *profile,ExceptionInfo *exception)
2033{
2034 StringInfo
2035 *clone_profile;
2036
2037 if (profile == (const StringInfo *) NULL)
2038 return(MagickFalse);
2039 clone_profile=CloneStringInfo(profile);
2040 return(SetImageProfileInternal(image,name,clone_profile,MagickFalse,
2041 exception));
2042}
2043
2044MagickExport MagickBooleanType SetImageProfilePrivate(Image *image,
2045 StringInfo *profile,ExceptionInfo *exception)
2046{
2047 if (profile == (const StringInfo *) NULL)
2048 return(MagickFalse);
2049 return(SetImageProfileInternal(image,GetStringInfoName(profile),profile,
2050 MagickFalse,exception));
2051}
2052␌
2053/*
2054%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2055% %
2056% %
2057% %
2058% S y n c I m a g e P r o f i l e s %
2059% %
2060% %
2061% %
2062%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2063%
2064% SyncImageProfiles() synchronizes image properties with the image profiles.
2065%
2066% The format of the SyncImageProfiles method is:
2067%
2068% void SyncImageProfiles(Image *image)
2069%
2070% A description of each parameter follows:
2071%
2072% o image: the image.
2073%
2074*/
2075
2076static inline int ReadProfileByte(unsigned char **p,size_t *length)
2077{
2078 int
2079 c;
2080
2081 if (*length < 1)
2082 return(EOF);
2083 c=(int) (*(*p)++);
2084 (*length)--;
2085 return(c);
2086}
2087
2088static inline signed short ReadProfileShort(const EndianType endian,
2089 unsigned char *buffer)
2090{
2091 union
2092 {
2093 unsigned int
2094 unsigned_value;
2095
2096 signed int
2097 signed_value;
2098 } quantum;
2099
2100 unsigned short
2101 value;
2102
2103 if (endian == LSBEndian)
2104 {
2105 value=(unsigned short) buffer[1] << 8;
2106 value|=(unsigned short) buffer[0];
2107 quantum.unsigned_value=value & 0xffff;
2108 return(quantum.signed_value);
2109 }
2110 value=(unsigned short) buffer[0] << 8;
2111 value|=(unsigned short) buffer[1];
2112 quantum.unsigned_value=value & 0xffff;
2113 return(quantum.signed_value);
2114}
2115
2116static inline signed int ReadProfileLong(const EndianType endian,
2117 unsigned char *buffer)
2118{
2119 union
2120 {
2121 unsigned int
2122 unsigned_value;
2123
2124 signed int
2125 signed_value;
2126 } quantum;
2127
2128 unsigned int
2129 value;
2130
2131 if (endian == LSBEndian)
2132 {
2133 value=(unsigned int) buffer[3] << 24;
2134 value|=(unsigned int) buffer[2] << 16;
2135 value|=(unsigned int) buffer[1] << 8;
2136 value|=(unsigned int) buffer[0];
2137 quantum.unsigned_value=value & 0xffffffff;
2138 return(quantum.signed_value);
2139 }
2140 value=(unsigned int) buffer[0] << 24;
2141 value|=(unsigned int) buffer[1] << 16;
2142 value|=(unsigned int) buffer[2] << 8;
2143 value|=(unsigned int) buffer[3];
2144 quantum.unsigned_value=value & 0xffffffff;
2145 return(quantum.signed_value);
2146}
2147
2148static inline signed int ReadProfileMSBLong(unsigned char **p,size_t *length)
2149{
2150 signed int
2151 value;
2152
2153 if (*length < 4)
2154 return(0);
2155 value=ReadProfileLong(MSBEndian,*p);
2156 (*length)-=4;
2157 *p+=4;
2158 return(value);
2159}
2160
2161static inline signed short ReadProfileMSBShort(unsigned char **p,
2162 size_t *length)
2163{
2164 signed short
2165 value;
2166
2167 if (*length < 2)
2168 return(0);
2169 value=ReadProfileShort(MSBEndian,*p);
2170 (*length)-=2;
2171 *p+=2;
2172 return(value);
2173}
2174
2175static inline void WriteProfileLong(const EndianType endian,
2176 const size_t value,unsigned char *p)
2177{
2178 unsigned char
2179 buffer[4];
2180
2181 if (endian == LSBEndian)
2182 {
2183 buffer[0]=(unsigned char) value;
2184 buffer[1]=(unsigned char) (value >> 8);
2185 buffer[2]=(unsigned char) (value >> 16);
2186 buffer[3]=(unsigned char) (value >> 24);
2187 (void) memcpy(p,buffer,4);
2188 return;
2189 }
2190 buffer[0]=(unsigned char) (value >> 24);
2191 buffer[1]=(unsigned char) (value >> 16);
2192 buffer[2]=(unsigned char) (value >> 8);
2193 buffer[3]=(unsigned char) value;
2194 (void) memcpy(p,buffer,4);
2195}
2196
2197static void WriteProfileShort(const EndianType endian,
2198 const unsigned short value,unsigned char *p)
2199{
2200 unsigned char
2201 buffer[2];
2202
2203 if (endian == LSBEndian)
2204 {
2205 buffer[0]=(unsigned char) value;
2206 buffer[1]=(unsigned char) (value >> 8);
2207 (void) memcpy(p,buffer,2);
2208 return;
2209 }
2210 buffer[0]=(unsigned char) (value >> 8);
2211 buffer[1]=(unsigned char) value;
2212 (void) memcpy(p,buffer,2);
2213}
2214
2215static void SyncExifProfile(const Image *image,unsigned char *exif,
2216 size_t length)
2217{
2218#define MaxDirectoryStack 16
2219#define EXIF_DELIMITER "\n"
2220#define EXIF_NUM_FORMATS 12
2221#define TAG_EXIF_OFFSET 0x8769
2222#define TAG_INTEROP_OFFSET 0xa005
2223
2224 typedef struct _DirectoryInfo
2225 {
2226 unsigned char
2227 *directory;
2228
2229 size_t
2230 entry;
2231 } DirectoryInfo;
2232
2233 DirectoryInfo
2234 directory_stack[MaxDirectoryStack] = { { 0, 0 } };
2235
2236 EndianType
2237 endian;
2238
2239 size_t
2240 entry,
2241 number_entries;
2242
2243 SplayTreeInfo
2244 *exif_resources;
2245
2246 ssize_t
2247 id,
2248 level,
2249 offset;
2250
2251 static int
2252 format_bytes[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
2253
2254 unsigned char
2255 *directory;
2256
2257 if (length < 16)
2258 return;
2259 id=(ssize_t) ReadProfileShort(LSBEndian,exif);
2260 if ((id != 0x4949) && (id != 0x4D4D))
2261 {
2262 while (length != 0)
2263 {
2264 if (ReadProfileByte(&exif,&length) != 0x45)
2265 continue;
2266 if (ReadProfileByte(&exif,&length) != 0x78)
2267 continue;
2268 if (ReadProfileByte(&exif,&length) != 0x69)
2269 continue;
2270 if (ReadProfileByte(&exif,&length) != 0x66)
2271 continue;
2272 if (ReadProfileByte(&exif,&length) != 0x00)
2273 continue;
2274 if (ReadProfileByte(&exif,&length) != 0x00)
2275 continue;
2276 break;
2277 }
2278 if (length < 16)
2279 return;
2280 id=(ssize_t) ReadProfileShort(LSBEndian,exif);
2281 }
2282 endian=LSBEndian;
2283 if (id == 0x4949)
2284 endian=LSBEndian;
2285 else
2286 if (id == 0x4D4D)
2287 endian=MSBEndian;
2288 else
2289 return;
2290 if (ReadProfileShort(endian,exif+2) != 0x002a)
2291 return;
2292 /*
2293 This the offset to the first IFD.
2294 */
2295 offset=(ssize_t) ReadProfileLong(endian,exif+4);
2296 if ((offset < 0) || ((size_t) offset >= length))
2297 return;
2298 directory=exif+offset;
2299 level=0;
2300 entry=0;
2301 exif_resources=NewSplayTree((int (*)(const void *,const void *)) NULL,
2302 (void *(*)(void *)) NULL,(void *(*)(void *)) NULL);
2303 do
2304 {
2305 if (level > 0)
2306 {
2307 level--;
2308 directory=directory_stack[level].directory;
2309 entry=directory_stack[level].entry;
2310 }
2311 if ((directory < exif) || (directory > (exif+length-2)))
2312 break;
2313 /*
2314 Determine how many entries there are in the current IFD.
2315 */
2316 number_entries=(size_t) ReadProfileShort(endian,directory);
2317 for ( ; entry < number_entries; entry++)
2318 {
2319 int
2320 components;
2321
2322 unsigned char
2323 *p,
2324 *q;
2325
2326 size_t
2327 number_bytes;
2328
2329 ssize_t
2330 format,
2331 tag_value;
2332
2333 q=(unsigned char *) (directory+2+(12*entry));
2334 if (q > (exif+length-12))
2335 break; /* corrupt EXIF */
2336 if (GetValueFromSplayTree(exif_resources,q) == q)
2337 break;
2338 (void) AddValueToSplayTree(exif_resources,q,q);
2339 tag_value=(ssize_t) ReadProfileShort(endian,q);
2340 format=(ssize_t) ReadProfileShort(endian,q+2);
2341 if ((format < 0) || ((format-1) >= EXIF_NUM_FORMATS))
2342 break;
2343 components=(int) ReadProfileLong(endian,q+4);
2344 if (components < 0)
2345 break; /* corrupt EXIF */
2346 number_bytes=(size_t) components*(size_t) format_bytes[format];
2347 if ((ssize_t) number_bytes < components)
2348 break; /* prevent overflow */
2349 if (number_bytes <= 4)
2350 p=q+8;
2351 else
2352 {
2353 /*
2354 The directory entry contains an offset.
2355 */
2356 offset=(ssize_t) ReadProfileLong(endian,q+8);
2357 if ((offset < 0) ||
2358 ((size_t) (offset+(ssize_t) number_bytes) > length))
2359 continue;
2360 if (~length < number_bytes)
2361 continue; /* prevent overflow */
2362 p=(unsigned char *) (exif+offset);
2363 }
2364 switch (tag_value)
2365 {
2366 case 0x011a:
2367 {
2368 (void) WriteProfileLong(endian,(size_t) (image->resolution.x+0.5),p);
2369 if (number_bytes == 8)
2370 (void) WriteProfileLong(endian,1UL,p+4);
2371 break;
2372 }
2373 case 0x011b:
2374 {
2375 (void) WriteProfileLong(endian,(size_t) (image->resolution.y+0.5),p);
2376 if (number_bytes == 8)
2377 (void) WriteProfileLong(endian,1UL,p+4);
2378 break;
2379 }
2380 case 0x0112:
2381 {
2382 if (number_bytes == 4)
2383 {
2384 (void) WriteProfileLong(endian,(size_t) image->orientation,p);
2385 break;
2386 }
2387 (void) WriteProfileShort(endian,(unsigned short) image->orientation,
2388 p);
2389 break;
2390 }
2391 case 0x0128:
2392 {
2393 if (number_bytes == 4)
2394 {
2395 (void) WriteProfileLong(endian,((size_t) image->units)+1,p);
2396 break;
2397 }
2398 (void) WriteProfileShort(endian,(unsigned short) (image->units+1),p);
2399 break;
2400 }
2401 default:
2402 break;
2403 }
2404 if ((tag_value == TAG_EXIF_OFFSET) || (tag_value == TAG_INTEROP_OFFSET))
2405 {
2406 offset=(ssize_t) ReadProfileLong(endian,p);
2407 if (((size_t) offset < length) && (level < (MaxDirectoryStack-2)))
2408 {
2409 directory_stack[level].directory=directory;
2410 entry++;
2411 directory_stack[level].entry=entry;
2412 level++;
2413 directory_stack[level].directory=exif+offset;
2414 directory_stack[level].entry=0;
2415 level++;
2416 if ((directory+2+(12*number_entries)) > (exif+length))
2417 break;
2418 offset=(ssize_t) ReadProfileLong(endian,directory+2+(12*
2419 number_entries));
2420 if ((offset != 0) && ((size_t) offset < length) &&
2421 (level < (MaxDirectoryStack-2)))
2422 {
2423 directory_stack[level].directory=exif+offset;
2424 directory_stack[level].entry=0;
2425 level++;
2426 }
2427 }
2428 break;
2429 }
2430 }
2431 } while (level > 0);
2432 exif_resources=DestroySplayTree(exif_resources);
2433 return;
2434}
2435
2436static void Sync8BimProfile(const Image *image,const StringInfo *profile)
2437{
2438 size_t
2439 length;
2440
2441 ssize_t
2442 count;
2443
2444 unsigned char
2445 *p;
2446
2447 unsigned short
2448 id;
2449
2450 length=GetStringInfoLength(profile);
2451 p=GetStringInfoDatum(profile);
2452 while (length != 0)
2453 {
2454 if (ReadProfileByte(&p,&length) != 0x38)
2455 continue;
2456 if (ReadProfileByte(&p,&length) != 0x42)
2457 continue;
2458 if (ReadProfileByte(&p,&length) != 0x49)
2459 continue;
2460 if (ReadProfileByte(&p,&length) != 0x4D)
2461 continue;
2462 if (length < 7)
2463 return;
2464 id=(unsigned short) ReadProfileMSBShort(&p,&length);
2465 count=(ssize_t) ReadProfileByte(&p,&length);
2466 if ((count >= (ssize_t) length) || (count < 0))
2467 return;
2468 p+=count;
2469 length-=(size_t) count;
2470 if ((*p & 0x01) == 0)
2471 (void) ReadProfileByte(&p,&length);
2472 count=(ssize_t) ReadProfileMSBLong(&p,&length);
2473 if ((count > (ssize_t) length) || (count < 0))
2474 return;
2475 if ((id == 0x3ED) && (count == 16))
2476 {
2477 if (image->units == PixelsPerCentimeterResolution)
2478 WriteProfileLong(MSBEndian,(unsigned int) CastDoubleToLong(
2479 image->resolution.x*2.54*65536.0),p);
2480 else
2481 WriteProfileLong(MSBEndian,(unsigned int) CastDoubleToLong(
2482 image->resolution.x*65536.0),p);
2483 WriteProfileShort(MSBEndian,(unsigned short) image->units,p+4);
2484 if (image->units == PixelsPerCentimeterResolution)
2485 WriteProfileLong(MSBEndian,(unsigned int) CastDoubleToLong(
2486 image->resolution.y*2.54*65536.0),p+8);
2487 else
2488 WriteProfileLong(MSBEndian,(unsigned int) CastDoubleToLong(
2489 image->resolution.y*65536.0),p+8);
2490 WriteProfileShort(MSBEndian,(unsigned short) image->units,p+12);
2491 }
2492 if (id == 0x0422)
2493 SyncExifProfile(image,p,(size_t) count);
2494 p+=count;
2495 length-=(size_t) count;
2496 }
2497 return;
2498}
2499
2500static void ReplaceXmpValue(StringInfo *profile,size_t start,size_t end,
2501 const char *value)
2502{
2503 char
2504 *datum;
2505
2506 size_t
2507 length,
2508 new_length,
2509 value_length;
2510
2511 length=GetStringInfoLength(profile);
2512 value_length=strlen(value);
2513 new_length=length-(end-start)+value_length;
2514 if (new_length > length)
2515 SetStringInfoLength(profile,new_length);
2516 datum=(char *) GetStringInfoDatum(profile);
2517 (void) memmove(datum+start+value_length,datum+end,length-end);
2518 (void) memcpy(datum+start,value,value_length);
2519 if (new_length < length)
2520 {
2521 SetStringInfoLength(profile,new_length);
2522 datum=(char *) GetStringInfoDatum(profile);
2523 *(datum+new_length)='\0';
2524 }
2525}
2526
2527static MagickBooleanType GetXmpOffsets(const StringInfo *profile,
2528 const char *tag,size_t *start,size_t *end)
2529{
2530 char
2531 *datum,
2532 *pos;
2533
2534 size_t
2535 length,
2536 tag_length;
2537
2538 datum=(char *) GetStringInfoDatum(profile);
2539 length=GetStringInfoLength(profile);
2540 pos=strstr(datum,tag);
2541 tag_length=strlen(tag);
2542 if ((pos == (char *) NULL) || ((pos-datum) < 1) || (*(pos-1) != '<') ||
2543 (((size_t) (pos-datum)+tag_length) > length) ||
2544 (*(pos+tag_length) != '>'))
2545 return(MagickFalse);
2546 *start=(size_t) (pos-datum)+tag_length+1;
2547 pos=strstr(datum+*start,"<");
2548 if (pos == (char *) NULL)
2549 return(MagickFalse);
2550 *end=(size_t) (pos-datum);
2551 return(MagickTrue);
2552}
2553
2554static void GetXmpNumeratorAndDenominator(double value,
2555 unsigned long *numerator,unsigned long *denominator)
2556{
2557 double
2558 df;
2559
2560 *numerator=0;
2561 *denominator=1;
2562 if (value <= MagickEpsilon)
2563 return;
2564 *numerator=1;
2565 df=1.0;
2566 while(fabs(df - value) > MagickEpsilon)
2567 {
2568 if (df < value)
2569 (*numerator)++;
2570 else
2571 {
2572 (*denominator)++;
2573 *numerator=(unsigned long) (value*(*denominator));
2574 }
2575 df=*numerator/(double)*denominator;
2576 }
2577}
2578
2579static void SyncXmpProfile(const Image *image,StringInfo *profile)
2580{
2581 char
2582 value[MagickPathExtent];
2583
2584 size_t
2585 end,
2586 start;
2587
2588 unsigned long
2589 denominator,
2590 numerator;
2591
2592 *value='\0';
2593 if (GetXmpOffsets(profile,"tiff:XResolution",&start,&end) != MagickFalse)
2594 {
2595 GetXmpNumeratorAndDenominator(image->resolution.x,&numerator,
2596 &denominator);
2597 (void) FormatLocaleString(value,MagickPathExtent,"%lu/%lu",numerator,
2598 denominator);
2599 ReplaceXmpValue(profile,start,end,value);
2600 }
2601 if (GetXmpOffsets(profile,"tiff:YResolution",&start,&end) != MagickFalse)
2602 {
2603 if ((fabs(image->resolution.x-image->resolution.y) > MagickEpsilon) ||
2604 (*value == '\0'))
2605 {
2606 GetXmpNumeratorAndDenominator(image->resolution.y,&numerator,
2607 &denominator);
2608 (void) FormatLocaleString(value,MagickPathExtent,"%lu/%lu",
2609 numerator,denominator);
2610 }
2611 ReplaceXmpValue(profile,start,end,value);
2612 }
2613 if (GetXmpOffsets(profile,"tiff:ResolutionUnit",&start,&end) != MagickFalse)
2614 {
2615 (void) FormatLocaleString(value,MagickPathExtent,"%d",
2616 ((int) image->units)+1);
2617 ReplaceXmpValue(profile,start,end,value);
2618 }
2619 if (GetXmpOffsets(profile,"tiff:Orientation",&start,&end) != MagickFalse)
2620 {
2621 (void) FormatLocaleString(value,MagickPathExtent,"%d",
2622 (int) image->orientation);
2623 ReplaceXmpValue(profile,start,end,value);
2624 }
2625}
2626
2627MagickPrivate void SyncImageProfiles(Image *image)
2628{
2629 StringInfo
2630 *profile;
2631
2632 profile=(StringInfo *) GetImageProfile(image,"8BIM");
2633 if (profile != (StringInfo *) NULL)
2634 Sync8BimProfile(image,profile);
2635 profile=(StringInfo *) GetImageProfile(image,"EXIF");
2636 if (profile != (StringInfo *) NULL)
2637 SyncExifProfile(image,GetStringInfoDatum(profile),GetStringInfoLength(
2638 profile));
2639 profile=(StringInfo *) GetImageProfile(image,"XMP");
2640 if (profile != (StringInfo *) NULL)
2641 SyncXmpProfile(image,profile);
2642}
2643
2644static void UpdateClipPath(unsigned char *blob,size_t length,
2645 const size_t old_columns,const size_t old_rows,
2646 const RectangleInfo *new_geometry)
2647{
2648 ssize_t
2649 i,
2650 knot_count,
2651 selector;
2652
2653 knot_count=0;
2654 while (length != 0)
2655 {
2656 selector=(ssize_t) ReadProfileMSBShort(&blob,&length);
2657 switch (selector)
2658 {
2659 case 0:
2660 case 3:
2661 {
2662 if (knot_count != 0)
2663 {
2664 blob+=24;
2665 length-=(size_t) MagickMin(length,24U);
2666 break;
2667 }
2668 /*
2669 Expected subpath length record.
2670 */
2671 knot_count=(ssize_t) ReadProfileMSBShort(&blob,&length);
2672 blob+=22;
2673 length-=(size_t) MagickMin(length,22);
2674 break;
2675 }
2676 case 1:
2677 case 2:
2678 case 4:
2679 case 5:
2680 {
2681 if (knot_count == 0)
2682 {
2683 /*
2684 Unexpected subpath knot.
2685 */
2686 blob+=24;
2687 length-=(size_t) MagickMin(length,24);
2688 break;
2689 }
2690 /*
2691 Add sub-path knot
2692 */
2693 for (i=0; i < 3; i++)
2694 {
2695 double
2696 x,
2697 y;
2698
2699 signed int
2700 xx,
2701 yy;
2702
2703 y=(double) ReadProfileMSBLong(&blob,&length);
2704 y=y*old_rows/4096.0/4096.0;
2705 y-=new_geometry->y;
2706 yy=(signed int) ((y*4096*4096)/new_geometry->height);
2707 WriteProfileLong(MSBEndian,(size_t) yy,blob-4);
2708 x=(double) ReadProfileMSBLong(&blob,&length);
2709 x=x*old_columns/4096.0/4096.0;
2710 x-=new_geometry->x;
2711 xx=(signed int) ((x*4096*4096)/new_geometry->width);
2712 WriteProfileLong(MSBEndian,(size_t) xx,blob-4);
2713 }
2714 knot_count--;
2715 break;
2716 }
2717 case 6:
2718 case 7:
2719 case 8:
2720 default:
2721 {
2722 blob+=24;
2723 length-=(size_t) MagickMin(length,24);
2724 break;
2725 }
2726 }
2727 }
2728}
2729
2730MagickPrivate void Update8BIMClipPath(const Image *image,
2731 const size_t old_columns,const size_t old_rows,
2732 const RectangleInfo *new_geometry)
2733{
2734 const StringInfo
2735 *profile;
2736
2737 size_t
2738 length;
2739
2740 ssize_t
2741 count,
2742 id;
2743
2744 unsigned char
2745 *info;
2746
2747 assert(image != (Image *) NULL);
2748 assert(new_geometry != (RectangleInfo *) NULL);
2749 profile=GetImageProfile(image,"8bim");
2750 if (profile == (StringInfo *) NULL)
2751 return;
2752 length=GetStringInfoLength(profile);
2753 info=GetStringInfoDatum(profile);
2754 while (length > 0)
2755 {
2756 if (ReadProfileByte(&info,&length) != (unsigned char) '8')
2757 continue;
2758 if (ReadProfileByte(&info,&length) != (unsigned char) 'B')
2759 continue;
2760 if (ReadProfileByte(&info,&length) != (unsigned char) 'I')
2761 continue;
2762 if (ReadProfileByte(&info,&length) != (unsigned char) 'M')
2763 continue;
2764 id=(ssize_t) ReadProfileMSBShort(&info,&length);
2765 count=(ssize_t) ReadProfileByte(&info,&length);
2766 if ((count != 0) && ((size_t) count <= length))
2767 {
2768 info+=count;
2769 length-=(size_t) count;
2770 }
2771 if ((count & 0x01) == 0)
2772 (void) ReadProfileByte(&info,&length);
2773 count=(ssize_t) ReadProfileMSBLong(&info,&length);
2774 if ((count < 0) || ((size_t) count > length))
2775 {
2776 length=0;
2777 continue;
2778 }
2779 if ((id > 1999) && (id < 2999))
2780 UpdateClipPath(info,(size_t) count,old_columns,old_rows,new_geometry);
2781 info+=count;
2782 length-=(size_t) MagickMin(length,(size_t) count);
2783 }
2784}
_CMSExceptionInfo
Definition profile.c:113
_CacheView
Definition cache-view.c:66
_ExceptionInfo
Definition exception.h:102
_Image
Definition image.h:132
_ProfileInfo
Definition profile.c:98
_RectangleInfo
Definition geometry.h:130
_SplayTreeInfo
Definition splay-tree.c:84
_StringInfo
Definition string_.h:28